python多线程和多进程（一）

一、多线程

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秒但主线程没有等待就直接执行了打印了；

我们稍作改进：

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

　　主线程执行到，然后等待子线程；

上个第一次使用线程写东西的项目吧，去年刚开始写爬虫因为数量多所以网上到处找资料，东拼西凑总算给我搞出来了

#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()  # 等待线程执行结束

使用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

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

巴特西

python多线程和多进程（一）

最新文章

热门文章