一、多线程

  1. Python的标准库提供了两个模块：_thread和threading，_thread是低级模块，threading是高级模块，对_thread进行了封装。绝大多数情况下，只需要使用threading这个模块。 
import threading
from time import ctime,sleep
def func1(func):
    print u" 我是函数%s.此刻打印时间： %s" %(func,ctime())
    sleep(5)
    print u'%s再次打印时间%s' % (func,ctime())
def func2(func):
    print u"我是函数 %s此刻打印时间： %s" %(func,ctime())
    sleep(5)
    print u'%s再次打印时间%s'%(func,ctime())

threads = []
t1 = threading.Thread(target=func1,args=('func1',)) #创建线程，args传参必须以元组方式传入    
threads.append(t1)
t2 = threading.Thread(target=func2,args=('func2',))#创建线程，args传参必须以元组方式传入
threads.append(t2)
if __name__ == '__main__': 
     for t in threads: 
       # t.setDaemon(True) #设置守护线程（主线程退出，子线程也会退出，不会挂起占用资源）
         t.start() #启动线程
     print u'脚本结束时间%s'%ctime()

 运行结果：（注意setDaemon（））

我是函数func1.此刻打印时间： Fri Sep 07 15:43:15 2018
我是函数 func2此刻打印时间： Fri Sep 07 15:43:15 2018
脚本结束时间Fri Sep 07 15:43:15 2018  #（三个都是同一时间打印）


func1再次打印时间Fri Sep 07 15:43:20 2018 
func2再次打印时间Fri Sep 07 15:43:20 2018 #（两个都为等待5秒后同事打印）

说明;func1,func2都是同时一时间执行任务了，但是为什么脚本结束时间先打印了，原因是主线程被分成两个子线程同时运行，但是子线程有等待5秒但主线程没有等待就直接执行了打印了；

  1. 我们稍作改进：
import threading
from time import ctime,sleep
def func1(func):
    print u" 我是函数%s.此刻打印时间： %s" %(func,ctime())
    sleep(5)
    print u'%s再次打印时间%s' % (func,ctime())
def func2(func):

    print u"我是函数 %s此刻打印时间： %s" %(func,ctime())
    sleep(5)
    print u'%s再次打印时间%s'%(func,ctime())
threads = []
t1 = threading.Thread(target=func1,args=('func1',))
threads.append(t1)
t2 = threading.Thread(target=func2,args=('func2',))
threads.append(t2)

if __name__ == '__main__':
    for t in threads:
        # t.setDaemon(True) #设置守护线程（主线程退出，子线程也会退出，不会挂起占用资源）
        t.start()
    for t in threads:
        t.join()  # 等待线程执行结束
print u'脚本结束时间%s'%ctime()
我是函数func1.此刻打印时间： Fri Sep 07 16:09:29 2018
我是函数 func2此刻打印时间： Fri Sep 07 16:09:29 2018
func1再次打印时间Fri Sep 07 16:09:34 2018
func2再次打印时间Fri Sep 07 16:09:34 2018
脚本结束时间Fri Sep 07 16:09:34 2018

　　主线程执行到

python modbus TCP多线程 python 多线程模块_爬虫

，然后等待子线程；

  1. 上个第一次使用线程写东西的项目吧，去年刚开始写爬虫因为数量多所以网上到处找资料，东拼西凑总算给我搞出来了 
#encoding:utf-8
import requests
import threading
from lxml import etree
import codecs,csv


def return_link():
    Link = []
    for  i in range(2000):
        url="http://www.xzgsj.gov.cn/baweb/show/shiju/gg.jsp?fenceid=95000000&total=45192&queryType=6&pagenum="+str(i)+"&action=gg.jsp?ssid=ZxSlh1DBkGGpV2hnWMSt5PG7f8FPjTbvH78vJ1nFcwYyMhWzGBzy!1470507879!1500631589968&findWenhao=&findName="
        Link.append(url)
    return  Link


def get_href():
    while True:
        lock.acquire()
        if len(Link) == 0:
            lock.release()
            break
        else:
            url = Link.pop(0)
            lock.release()
            r = requests.get(url, headers=headers).content
            print url
            pages = etree.HTML(r.decode('utf-8'))
            a = pages.xpath(u"//table[@width='700']/tr[position()>1]/td/a/@onclick")
            for i in a:
                a = i.replace('javaScript:window.open(\'', '').replace('\',\'a\',\'width=550 height=350\')', '')
                url = 'http://www.xzgsj.gov.cn/baweb/show/shiju/' + a
                with codecs.open('url.csv','ab') as f:
                    w = csv.writer(f)
                    w.writerow([url])

if __name__ == '__main__':
    headers = {
        "User-Agent": "Mozilla/5.0 (Windows NT 6.1; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/59.0.3071.115 Safari/537.36"
    }
    lock = threading.Lock()#线程锁
    Link = return_link()
    tasks = []  # 任务列表
    for x in range(5):
        t = threading.Thread(target=get_href)  # 准备线程函数及参数
        t.setDaemon(True)  # 设置守护线程（主线程退出，子线程也会退出，不会挂起占用资源）
        tasks.append(t)
    for t in tasks:
        t.start()  # 启动多线程（任务列表有多少个值，就会启动多少个线程）
    for t in tasks:
        t.join()  # 等待线程执行结束
  1. View Code
  2. 使用Threading模块创建线程，直接从threading.Thread继承，然后重写__init__方法和run方法：（和第一个例子一样只是基于类的使用） 
import threading
from time import ctime,sleep

class myThread(threading.Thread):  # 继承父类threading.Thread
    def __init__(self, threadID, name, counter):
        threading.Thread.__init__(self)
        self.threadID = threadID
        self.name = name
        self.counter = counter
    def run(self):  # 把要执行的代码写到run函数里面 线程在创建后会直接运行run函数
        print "Starting " + self.name,u'时间{}'.format(ctime())
        sleep(5)
        print "Exiting " + self.name,u'时间{}'.format(ctime())

# 创建新线程
thread1 = myThread(1, "Thread-1", 1)
thread2 = myThread(2, "Thread-2", 2)

# 开启线程
tasks = []
tasks.append(thread1)
tasks.append(thread2)
if __name__ == '__main__':
    for t in tasks:
        # t.setDaemon(True) #设置守护线程（主线程退出，子线程也会退出，不会挂起占用资源）
        t.start()
    for t in tasks:
        t.join()  # 等待线程执行结束
    print u'脚本结束时间%s'%ctime()
结果：
Starting Thread-1 时间Fri Sep 07 17:13:53 2018
Starting Thread-2 时间Fri Sep 07 17:13:53 2018
Exiting Thread-1 时间Fri Sep 07 17:13:58 2018
Exiting Thread-2 时间Fri Sep 07 17:13:58 2018

脚本结束时间Fri Sep 07 17:13:58 201

  1. 第一篇over,以后想到再加吧