python爬虫怎么写多线程_Python爬虫【第3篇】【多线程】

一、多线程

Python标准库提供2个模块，thread是低级模块，threading是高级模块

1.threading模块创建多线程

方式1：把1个函数传入并创建Thread实例，然后调用start方法开始执行

importrandomimporttime,threading#新线程执行的代码

defthread_run(urls):print 'Current %s is running...' %threading.current_thread().namefor url inurls:print '%s ---->>> %s' %(threading.current_thread().name,url)

time.sleep(random.random())print '%s ended' %threading.current_thread().nameprint '%s is running...' %threading.current_thread().name

t1= threading.Thread(target=thread_run,name='Thread_1',args=(['url_1','url_2','url_3'],))

t2= threading.Thread(target=thread_run,name='Thread_2',args=(['url_4','url_5','url_6'],))

t1.start()

t2.start()

t1.join()

t2.join()print '%s ended' %threading.current_thread().name

执行结果：

MainThreadisrunning...

Current Thread_1isrunning...

Thread_1---->>>url_1

Current Thread_2isrunning...

Thread_2---->>>url_4

Thread_1---->>>url_2

Thread_2---->>>url_5

Thread_2---->>>url_6

Thread_1---->>>url_3

Thread_1 ended

Thread_2 ended

MainThread ended

方式2：从threading.Thread继承并创建线程类，然后重写__init__方法和run方法

importrandomimporttime,threadingclassmyThread(threading.Thread):def __init__(self,name,urls):

threading.Thread.__init__(self,name=name)

self.urls=urlsdefrun(self):print 'Current %s is running...' %threading.current_thread().namefor url inurls:print '%s ---->>> %s' %(threading.current_thread().name,url)

time.sleep(random.random())print '%s ended' %threading.current_thread().nameprint '%s is running...' %threading.current_thread().name

t1= threading.Thread(target=thread_run,name='Thread_1',args=(['url_1','url_2','url_3'],))

t2= threading.Thread(target=thread_run,name='Thread_2',args=(['url_4','url_5','url_6'],))

t1.start()

t2.start()

t1.join()

t2.join()print '%s ended' %threading.current_thread().name

执行结果：

MainThreadisrunning...

Current Thread_1isrunning...

Thread_1---->>>url_1

Current Thread_2isrunning...

Thread_2---->>>url_4

Thread_2---->>>url_5

Thread_1---->>>url_2

Thread_1---->>>url_3

Thread_2---->>>url_6

Thread_2 ended

Thread_1 ended

MainThread ended

二、线程同步：

作用：若多个线程共同对某个数据修改，则会出现不可预料的结果，为保证数据的正确性，需对多个线程进行同步。

实现方法：使用Thread对象的Lock和RLock

1.Lock对象【acquire、release方法】

若1个线程连续2次进行acquire操作，那么忧郁第1次acquire后未release，第2次acquire将挂起线程，会导致Lock对象一直不会release，导致线程死锁

2.RLock对象【acquire、release方法】

允许1个线程多次对其进行acquire操作（原因：内部通过1个counter变量维护线程acquire的次数），且每1次acquire操作必须有1个release操作与之对应，在所有的release操作完成后，别的线程才能申请该RLock对象

importthreading

mylock=threading.RLock()

num=0classmyThread(threading.Thread):def __init__(self,name):

threading.Thread.__init__(self,name=name)defrun(self):globalnumwhileTrue:

mylock.acquire()print '%s locked,Number:%d'%(threading.current_thread().name,num)if num>=4:

mylock.release()print '%s released,Number:%d'%(threading.current_thread().name,num)breaknum+ = 1

print '%s released,Number:%d'%(threading.current_thread().name,num)

mylock.release()if __name__=='__main__':

thread1= myThread('Thread_1')

thread2= myThread('Thread_2')

thread1.start()

thread2.start()

执行结果：

Thread_1 locked,Number:0

Thread_1 released,Number:1Thread_1 locked,Number:1Thread_1 released,Number:2Thread_2 locked,Number:2Thread_2 released,Number:3Thread_1 locked,Number:3Thread_1 released,Number:4Thread_2 locked,Number:4Thread_2 released,Number:4Thread_1 locked,Number:4Thread_1 released,Number:4

三、协程

协程，又称微线程。协程是一种用户态的轻量级线程。

协程拥有自己的寄存器上下文和栈。协程调度切换时，将寄存器上下文和栈保存到其他地方，在切回来的时候，恢复先前保存的寄存器上下文和栈。因此：

协程能保留上一次调用时的状态（即所有局部状态的一个特定组合），每次过程重入时，就相当于进入上一次调用的状态，换种说法：进入上一次离开时所处逻辑流的位置。

协程定义：

必须在只有一个单线程里实现并发

修改共享数据不需加锁

用户程序里自己保存多个控制流的上下文栈

一个协程遇到IO操作自动切换到其它协程

协程的优点：

无需线程上下文切换的开销

无需原子操作锁定及同步的开销

方便切换控制流，简化编程模型

高并发+高扩展性+低成本：一个CPU支持上万的协程都不是问题。所以很适合用于高并发处理。

"原子操作(atomic operation)是不需要synchronized"，所谓原子操作是指不会被线程调度机制打断的操作；这种操作一旦开始，就一直运行到结束，中间不会有任何 context switch （切换到另一个线程）。原子操作可以是一个步骤，也可以是多个操作步骤，但是其顺序是不可以被打乱，或者切割掉只执行部分。视作整体是原子性的核心。

协程的缺点：

无法利用多核资源：协程的本质是个单线程,它不能同时将 单个CPU 的多个核用上,协程需要和进程配合才能运行在多CPU上.当然我们日常所编写的绝大部分应用都没有这个必要，除非是cpu密集型应用。

进行阻塞（Blocking）操作（如IO时）会阻塞掉整个程序

Python协程实现方法（yield）:

importtimeimportqueuedefconsumer(name):print("--->starting eating baozi...")whileTrue:

new_baozi= yield

print("[%s] is eating baozi %s" %(name,new_baozi))#time.sleep(1)

defproducer():

r= con.__next__()

r= con2.__next__()

n=0while n < 5:

n+=1con.send(n)

con2.send(n)print("\033[32;1m[producer]\033[0m is making baozi %s" %n )if __name__ == '__main__':

con= consumer("c1")

con2= consumer("c2")

p= producer()

Python协程实现方法（greenlet）:

greenlet是一个用C实现的协程模块，相比与python自带的yield，它可以使你在任意函数之间随意切换，而不需把这个函数先声明为generator。

#-*- coding:utf-8 -*-

from greenlet importgreenletdeftest1():print(12)

gr2.switch()print(34)

gr2.switch()deftest2():print(56)

gr1.switch()print(78)

gr1=greenlet(test1)

gr2=greenlet(test2)

gr1.switch()

问题：比generator简单，但好像还没有解决一个问题，就是遇到IO操作，自动切换

Python协程实现方法（Gevent）

Gevent 是一个第三方库，可以轻松通过gevent实现并发同步或异步编程，在gevent中用到的主要模式是Greenlet, 它是以C扩展模块形式接入Python的轻量级协程。 Greenlet全部运行在主程序操作系统进程的内部，但它们被协作式地调度。

importgeventdeffunc1():print('\033[31;1m李闯在跟海涛搞...\033[0m')

gevent.sleep(2)print('\033[31;1m李闯又回去跟继续跟海涛搞...\033[0m')deffunc2():print('\033[32;1m李闯切换到了跟海龙搞...\033[0m')

gevent.sleep(1)print('\033[32;1m李闯搞完了海涛，回来继续跟海龙搞...\033[0m')

gevent.joinall([

gevent.spawn(func1),

gevent.spawn(func2),#gevent.spawn(func3),

])

执行结果：

李闯在跟海涛搞...

李闯切换到了跟海龙搞...

李闯搞完了海涛，回来继续跟海龙搞...

李闯又回去跟继续跟海涛搞...

同步与异步的区别

importgeventdeftask(pid):"""Some non-deterministic task"""gevent.sleep(0.5)print('Task %s done' %pid)defsynchronous():for i in range(1,10):

task(i)defasynchronous():

threads= [gevent.spawn(task, i) for i in range(10)]

gevent.joinall(threads)print('Synchronous:')

synchronous()print('Asynchronous:')

asynchronous()

该程序的重要部分是将task函数封装到Greenlet内部线程的gevent.spawn。 初始化的greenlet列表存放在数组threads中，此数组被传给gevent.joinall 函数，

后者阻塞当前流程，并执行所有给定的greenlet。执行流程只会在 所有greenlet执行完后才会继续向下走。

遇到IO阻塞时会自动切换任务

from gevent importmonkey; monkey.patch_all()importgeventfrom urllib.request importurlopendeff(url):print('GET: %s' %url)

resp=urlopen(url)

data=resp.read()print('%d bytes received from %s.' %(len(data), url))

gevent.joinall([

gevent.spawn(f,'https://www.python.org/'),

gevent.spawn(f,'https://www.yahoo.com/'),

gevent.spawn(f,'https://github.com/'),

])

通过gevent实现单线程下的多socket并发

#Server Side

importsysimportsocketimporttimeimportgeventfrom gevent importsocket,monkey

monkey.patch_all()defserver(port):

s=socket.socket()

s.bind(('0.0.0.0', port))

s.listen(500)whileTrue:

cli, addr=s.accept()

gevent.spawn(handle_request, cli)defhandle_request(conn):try:whileTrue:

data= conn.recv(1024)print("recv:", data)

conn.send(data)if notdata:

conn.shutdown(socket.SHUT_WR)exceptException as ex:print(ex)finally:

conn.close()if __name__ == '__main__':

server(8001)#Client Side

importsocket

HOST= 'localhost' #The remote host

PORT = 8001 #The same port as used by the server

s =socket.socket(socket.AF_INET, socket.SOCK_STREAM)

s.connect((HOST, PORT))whileTrue:

msg= bytes(input(">>:"),encoding="utf8")

s.sendall(msg)

data= s.recv(1024)#print(data)

print('Received', repr(data))

s.close()

哈哈哈