Python学习笔记day8
Python线程
Threading用于提供线程相关的操作,线程是应用程序中工作的最小单元。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
#!/usr/bin/env python # -*- coding:utf-8 -*- import threading import time def show(arg): time.sleep( 1 ) print 'thread' + str (arg) for i in range ( 10 ): t = threading.Thread(target = show, args = (i,)) t.start() print 'main thread stop' |
上述代码创建了10个“前台”线程,然后控制器就交给了CPU,CPU根据指定算法进行调度,分片执行指令。
更多方法:
- start 线程准备就绪,等待CPU调度
- setName 为线程设置名称
- getName 获取线程名称
- setDaemon 设置为后台线程或前台线程(默认)
如果是后台线程,主线程执行过程中,后台线程也在进行,主线程执行完毕后,后台线程不论成功与否,均停止
如果是前台线程,主线程执行过程中,前台线程也在进行,主线程执行完毕后,等待前台线程也执行完成后,程序停止 - join 逐个执行每个线程,执行完毕后继续往下执行,该方法使得多线程变得无意义
- run 线程被cpu调度后执行Thread类对象的run方法
Python threading模块
线程有2种调用方式,如下:
直接调用
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
|
import threading import time def sayhi(num): #定义每个线程要运行的函数 print ( "running on number:%s" % num) time.sleep( 3 ) if __name__ = = '__main__' : t1 = threading.Thread(target = sayhi,args = ( 1 ,)) #生成一个线程实例 t2 = threading.Thread(target = sayhi,args = ( 2 ,)) #生成另一个线程实例 t1.start() #启动线程 t2.start() #启动另一个线程 print (t1.getName()) #获取线程名 print (t2.getName()) |
继承式调用
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
|
import threading import time class MyThread(threading.Thread): def __init__( self ,num): threading.Thread.__init__( self ) self .num = num def run( self ): #定义每个线程要运行的函数 print ( "running on number:%s" % self .num) time.sleep( 3 ) if __name__ = = '__main__' : t1 = MyThread( 1 ) t2 = MyThread( 2 ) t1.start() t2.start() |
线程锁(互斥锁Mutex)
一个进程下可以启动多个线程,多个线程共享父进程的内存空间,也就意味着每个线程可以访问同一份数据,此时,如果2个线程同时要修改同一份数据,会出现什么状况?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
|
import time import threading def addNum(): global num #在每个线程中都获取这个全局变量 print ( '--get num:' ,num ) time.sleep( 1 ) num - = 1 #对此公共变量进行-1操作 num = 100 #设定一个共享变量 thread_list = [] for i in range ( 100 ): t = threading.Thread(target = addNum) t.start() thread_list.append(t) for t in thread_list: #等待所有线程执行完毕 t.join() print ( 'final num:' , num ) |
正常来讲,这个num结果应该是0, 但在python 2.7上多运行几次,会发现,最后打印出来的num结果不总是0,为什么每次运行的结果不一样呢? 哈,很简单,假设你有A,B两个线程,此时都 要对num 进行减1操作, 由于2个线程是并发同时运行的,所以2个线程很有可能同时拿走了num=100这个初始变量交给cpu去运算,当A线程去处完的结果是99,但此时B线程运算完的结果也是99,两个线程同时CPU运算的结果再赋值给num变量后,结果就都是99。那怎么办呢? 很简单,每个线程在要修改公共数据时,为了避免自己在还没改完的时候别人也来修改此数据,可以给这个数据加一把锁, 这样其它线程想修改此数据时就必须等待你修改完毕并把锁释放掉后才能再访问此数据。
*注:不要在3.x上运行,不知为什么,3.x上的结果总是正确的,可能是自动加了锁
加锁版本
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
|
import time import threading def addNum(): global num #在每个线程中都获取这个全局变量 print ( '--get num:' ,num ) time.sleep( 1 ) lock.acquire() #修改数据前加锁 num - = 1 #对此公共变量进行-1操作 lock.release() #修改后释放 num = 100 #设定一个共享变量 thread_list = [] lock = threading.Lock() #生成全局锁 for i in range ( 100 ): t = threading.Thread(target = addNum) t.start() thread_list.append(t) for t in thread_list: #等待所有线程执行完毕 t.join() print ( 'final num:' , num ) |
RLock(递归锁)
说白了就是在一个大锁中还要再包含子锁
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
|
import threading,time def run1(): print ( "grab the first part data" ) lock.acquire() global num num + = 1 lock.release() return num def run2(): print ( "grab the second part data" ) lock.acquire() global num2 num2 + = 1 lock.release() return num2 def run3(): lock.acquire() res = run1() print ( '--------between run1 and run2-----' ) res2 = run2() lock.release() print (res,res2) if __name__ = = '__main__' : num,num2 = 0 , 0 lock = threading.RLock() for i in range ( 10 ): t = threading.Thread(target = run3) t.start() while threading.active_count() ! = 1 : print (threading.active_count()) else : print ( '----all threads done---' ) print (num,num2) |
Events
通过Event来实现两个或多个线程间的交互,下面是一个红绿灯的例子,即起动一个线程做交通指挥灯,生成几个线程做车辆,车辆行驶按红灯停,绿灯行的规则。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
|
import threading,time import random def light(): if not event.isSet(): event. set () #wait就不阻塞 #绿灯状态 count = 0 while True : if count < 10 : print ( '\033[42;1m--green light on---\033[0m' ) elif count < 13 : print ( '\033[43;1m--yellow light on---\033[0m' ) elif count < 20 : if event.isSet(): event.clear() print ( '\033[41;1m--red light on---\033[0m' ) else : count = 0 event. set () #打开绿灯 time.sleep( 1 ) count + = 1 def car(n): while 1 : time.sleep(random.randrange( 10 )) if event.isSet(): #绿灯 print ( "car [%s] is running.." % n) else : print ( "car [%s] is waiting for the red light.." % n) if __name__ = = '__main__' : event = threading.Event() Light = threading.Thread(target = light) Light.start() for i in range ( 3 ): t = threading.Thread(target = car,args = (i,)) t.start() |
多进程multiprocessing
multiprocessing
is a package that supports spawning processes using an API similar to the threading
module. The multiprocessing
package offers both local and remote concurrency, effectively side-stepping the Global Interpreter Lock by using subprocesses instead of threads. Due to this, the multiprocessing
module allows the programmer to fully leverage multiple processors on a given machine. It runs on both Unix and Windows.
1
2
3
4
5
6
7
8
9
10
|
from multiprocessing import Process import time def f(name): time.sleep( 2 ) print ( 'hello' , name) if __name__ = = '__main__' : p = Process(target = f, args = ( 'bob' ,)) p.start() p.join() |
To show the individual process IDs involved, here is an expanded example:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
|
from multiprocessing import Process import os def info(title): print (title) print ( 'module name:' , __name__) print ( 'parent process:' , os.getppid()) print ( 'process id:' , os.getpid()) print ( "\n\n" ) def f(name): info( '\033[31;1mfunction f\033[0m' ) print ( 'hello' , name) if __name__ = = '__main__' : info( '\033[32;1mmain process line\033[0m' ) p = Process(target = f, args = ( 'bob' ,)) p.start() p.join() |
进程间通讯
不同进程间内存是不共享的,要想实现两个进程间的数据交换,可以用以下方法:
Queues
使用方法跟threading里的queue差不多
1
2
3
4
5
6
7
8
9
10
11
|
from multiprocessing import Process, Queue def f(q): q.put([ 42 , None , 'hello' ]) if __name__ = = '__main__' : q = Queue() p = Process(target = f, args = (q,)) p.start() print (q.get()) # prints "[42, None, 'hello']" p.join() |
Pipes
The Pipe()
function returns a pair of connection objects connected by a pipe which by default is duplex (two-way). For example:
1
2
3
4
5
6
7
8
9
10
11
12
|
from multiprocessing import Process, Pipe def f(conn): conn.send([ 42 , None , 'hello' ]) conn.close() if __name__ = = '__main__' : parent_conn, child_conn = Pipe() p = Process(target = f, args = (child_conn,)) p.start() print (parent_conn.recv()) # prints "[42, None, 'hello']" p.join() |
进程同步
Without using the lock output from the different processes is liable to get all mixed up.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
from multiprocessing import Process, Lock def f(l, i): l.acquire() try : print ( 'hello world' , i) finally : l.release() if __name__ = = '__main__' : lock = Lock() for num in range ( 10 ): Process(target = f, args = (lock, num)).start() |
进程池
进程池内部维护一个进程序列,当使用时,则去进程池中获取一个进程,如果进程池序列中没有可供使用的进进程,那么程序就会等待,直到进程池中有可用进程为止。
进程池中有两个方法:
- apply
- apply_async
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
|
from multiprocessing import Process,Pool import time def Foo(i): time.sleep( 2 ) return i + 100 def Bar(arg): print ( '-->exec done:' ,arg) pool = Pool( 5 ) for i in range ( 10 ): pool.apply_async(func = Foo, args = (i,),callback = Bar) #pool.apply(func=Foo, args=(i,)) print ( 'end' ) pool.close() pool.join() #进程池中进程执行完毕后再关闭,如果注释,那么程序直接关闭。 |