python的线程和进程（python的线程进程和线程所）

线程

概念

线程是操作系统能够进行运算调度的最小单位。它被包含在进程之中，是进程中的实际运作单位。一条线程指的是进程中一个单一顺序的控制流，一个进程中可以并发多个线程，每条线程并行执行不同的任务。一个线程是一个execution context（执行上下文），即一个CPU执行时所需要的一串指令。

线程的工作方式

假设你正在读一本书，没有读完，你想休息一下，但是你想在回来时恢复到当时读的具体进度。有一个方法就是记下页数、行数与字数这三个数值，这些数值就是execution context。如果你的室友在你休息的时候，使用相同的方法读这本书。你和她只需要这三个数字记下来就可以在交替的时间共同阅读这本书了。

线程的工作方式与此类似。CPU会给你一个在同一时间能够做多个运算的幻觉，实际上它在每个运算上只花了极少的时间，本质上CPU同一时刻只干了一件事。它能这样做就是因为它有每个运算的execution context。就像你能够和你朋友共享同一本书一样，多任务也能共享同一块CPU。

进程

概念

一个程序的执行实例就是一个进程。每一个进程提供执行程序所需的所有资源。（进程本质上是资源的集合）

一个进程有一个虚拟的地址空间、可执行的代码、操作系统的接口、安全的上下文（记录启动该进程的用户和权限等等）、唯一的进程ID、环境变量、优先级类、最小和最大的工作空间（内存空间），还要有至少一个线程。

每一个进程启动时都会最先产生一个线程，即主线程。然后主线程会再创建其他的子线程。

与进程相关的资源包括:

• 内存页（同一个进程中的所有线程共享同一个内存空间）
• 文件描述符(e.g. open sockets)
• 安全凭证（e.g.启动该进程的用户ID）

进程与线程区别

1. 同一个进程中的线程共享同一内存空间，但是进程之间是独立的。
2. 同一个进程中的所有线程的数据是共享的（进程通讯），进程之间的数据是独立的。
3. 对主线程的修改可能会影响其他线程的行为，但是父进程的修改（除了删除以外）不会影响其他子进程。
4. 线程是一个上下文的执行指令，而进程则是与运算相关的一簇资源。
5. 同一个进程的线程之间可以直接通信，但是进程之间的交流需要借助中间代理来实现。
6. 创建新的线程很容易，但是创建新的进程需要对父进程做一次复制。
7. 一个线程可以操作同一进程的其他线程，但是进程只能操作其子进程。
8. 线程启动速度快，进程启动速度慢（但是两者运行速度没有可比性）。

多线程

线程常用方法

方法注释start()线程准备就绪，等待CPU调度setName()为线程设置名称getName()获取线程名称setDaemon(True)设置为守护线程join()逐个执行每个线程，执行完毕后继续往下执行run()线程被cpu调度后自动执行线程对象的run方法，如果想自定义线程类，直接重写run方法就行了

Thread类

1.普通创建方式

 1import threading
 2import time
 3
 4def run(n):
 5 print("task", n)
 6 time.sleep(1)
 7 print('2s')
 8 time.sleep(1)
 9 print('1s')
10 time.sleep(1)
11 print('0s')
12 time.sleep(1)
13
14t1 = threading.Thread(target=run, args=("t1",))
15t2 = threading.Thread(target=run, args=("t2",))
16t1.start()
17t2.start()

输出结果：

1task t1
2task t2
32s
42s
51s
61s
70s
80s

2.继承threading.Thread来自定义线程类 其本质是重构Thread类中的run方法

 1import threading
 2import time
 3
 4
 5class MyThread(threading.Thread):
 6 def __init__(self, n):
 7 super(MyThread, self).__init__() # 重构run函数必须要写
 8 self.n = n
 9
10 def run(self):
11 print("task", self.n)
12 time.sleep(1)
13 print('2s')
14 time.sleep(1)
15 print('1s')
16 time.sleep(1)
17 print('0s')
18 time.sleep(1)
19
20
21if __name__ == "__main__":
22 t1 = MyThread("t1")
23 t2 = MyThread("t2")
24
25 t1.start()
26 t2.start()

守护进程

我们看下面这个例子，这里使用setDaemon(True)把所有的子线程都变成了主线程的守护线程，因此当主进程结束后，子线程也会随之结束。所以当主线程结束后，整个程序就退出了。

 1import threading
 2import time
 3
 4def run(n):
 5 print("task", n)
 6 time.sleep(1) #此时子线程停1s
 7 print('3')
 8 time.sleep(1)
 9 print('2')
10 time.sleep(1)
11 print('1')
12
13for i in range(3):
14 t = threading.Thread(target=run, args=("t-%s" % i,))
15 t.setDaemon(True) #把子进程设置为守护线程，必须在start()之前设置
16 t.start()
17
18time.sleep(0.5) #主线程停0.5秒
19print(threading.active_count()) #输出活跃的线程数

输出结果：

1task t-0
2task t-1
3task t-2
44

GIL

在非python环境中，单核情况下，同时只能有一个任务执行。多核时可以支持多个线程同时执行。但是在python中，无论有多少核，同时只能执行一个线程。究其原因，这就是由于GIL的存在导致的。

GIL的全称是Global Interpreter Lock(全局解释器锁)，来源是python设计之初的考虑，为了数据安全所做的决定。某个线程想要执行，必须先拿到GIL，我们可以把GIL看作是“通行证”，并且在一个python进程中，GIL只有一个。拿不到通行证的线程，就不允许进入CPU执行。GIL只在cpython中才有，因为cpython调用的是c语言的原生线程，所以他不能直接操作cpu，只能利用GIL保证同一时间只能有一个线程拿到数据。而在pypy和jpython中是没有GIL的。

Python多线程的工作过程：

python在使用多线程的时候，调用的是c语言的原生线程。

1. 拿到公共数据
2. 申请gil
3. python解释器调用os原生线程
4. os操作cpu执行运算
5. 当该线程执行时间到后，无论运算是否已经执行完，gil都被要求释放
6. 进而由其他进程重复上面的过程
7. 等其他进程执行完后，又会切换到之前的线程（从他记录的上下文继续执行）

整个过程是每个线程执行自己的运算，当执行时间到就进行切换（context switch）。

python针对不同类型的代码执行效率也是不同的：

1. CPU密集型代码(各种循环处理、计算等等)，在这种情况下，由于计算工作多，ticks计数很快就会达到阈值，然后触发GIL的释放与再竞争（多个线程来回切换当然是需要消耗资源的），所以python下的多线程对CPU密集型代码并不友好。
2. IO密集型代码(文件处理、网络爬虫等涉及文件读写的操作)，多线程能够有效提升效率(单线程下有IO操作会进行IO等待，造成不必要的时间浪费，而开启多线程能在线程A等待时，自动切换到线程B，可以不浪费CPU的资源，从而能提升程序执行效率)。所以python的多线程对IO密集型代码比较友好。

使用建议

python下想要充分利用多核CPU，就用多进程。因为每个进程有各自独立的GIL，互不干扰，这样就可以真正意义上的并行执行，在python中，多进程的执行效率优于多线程(仅仅针对多核CPU而言)。

GIL在python中的版本差异：

1. 在python2.x里，GIL的释放逻辑是当前线程遇见IO操作或者ticks计数达到100时进行释放。（ticks可以看作是python自身的一个计数器，专门做用于GIL，每次释放后归零，这个计数可以通过sys.setcheckinterval 来调整）。而每次释放GIL锁，线程进行锁竞争、切换线程，会消耗资源。并且由于GIL锁存在，python里一个进程永远只能同时执行一个线程(拿到GIL的线程才能执行)，这就是为什么在多核CPU上，python的多线程效率并不高。
2. 在python3.x中，GIL不使用ticks计数，改为使用计时器（执行时间达到阈值后，当前线程释放GIL），这样对CPU密集型程序更加友好，但依然没有解决GIL导致的同一时间只能执行一个线程的问题，所以效率依然不尽如人意。

线程锁

由于线程之间是进行随机调度，并且每个线程可能只执行n条执行之后，当多个线程同时修改同一条数据时可能会出现脏数据，所以，出现了线程锁，即同一时刻允许一个线程执行操作。线程锁用于锁定资源，你可以定义多个锁, 像下面的代码, 当你需要独占某一资源时，任何一个锁都可以锁这个资源，就好比你用不同的锁都可以把相同的一个门锁住是一个道理。

由于线程之间是进行随机调度，如果有多个线程同时操作一个对象，如果没有很好地保护该对象，会造成程序结果的不可预期，我们也称此为“线程不安全”。

实测：在python2.7、mac os下，运行以下代码可能会产生脏数据。但是在python3中就不一定会出现下面的问题。

 1import threading
 2import time
 3
 4def run(n):
 5 global num
 6 num += 1
 7
 8num = 0
 9t_obj = [] 
10
11for i in range(20000):
12 t = threading.Thread(target=run, args=("t-%s" % i,))
13 t.start()
14 t_obj.append(t)
15
16for t in t_obj:
17 t.join()
18
19print "num:", num

产生脏数据后的运行结果：

1num: 19999

多进程

在linux中，每个进程都是由父进程提供的。每启动一个子进程就从父进程克隆一份数据，但是进程之间的数据本身是不能共享的。

 1from multiprocessing import Process
 2import time
 3def f(name):
 4 time.sleep(2)
 5 print('hello', name)
 6
 7if __name__ == '__main__':
 8 p = Process(target=f, args=('bob',))
 9 p.start()
10 p.join()
11from multiprocessing import Process
12import os
13
14def info(title):
15 print(title)
16 print('module name:', __name__)
17 print('parent process:', os.getppid()) #获取父进程id
18 print('process id:', os.getpid()) #获取自己的进程id
19 print("\n\n")
20
21def f(name):
22 info('\033[31;1mfunction f\033[0m')
23 print('hello', name)
24
25if __name__ == '__main__':
26 info('\033[32;1mmain process line\033[0m')
27 p = Process(target=f, args=('bob',))
28 p.start()
29 p.join()

进程间通信

由于进程之间数据是不共享的，所以不会出现多线程GIL带来的问题。多进程之间的通信通过Queue()或Pipe()来实现

Queue()

使用方法跟threading里的queue差不多

 1from multiprocessing import Process, Queue
 2
 3def f(q):
 4 q.put([42, None, 'hello'])
 5
 6if __name__ == '__main__':
 7 q = Queue()
 8 p = Process(target=f, args=(q,))
 9 p.start()
10 print(q.get()) # prints "[42, None, 'hello']"
11 p.join()

Pipe()

Pipe的本质是进程之间的数据传递，而不是数据共享，这和socket有点像。pipe()返回两个连接对象分别表示管道的两端，每端都有send()和recv()方法。如果两个进程试图在同一时间的同一端进行读取和写入那么，这可能会损坏管道中的数据。

 1from multiprocessing import Process, Pipe
 2
 3def f(conn):
 4 conn.send([42, None, 'hello'])
 5 conn.close()
 6
 7if __name__ == '__main__':
 8 parent_conn, child_conn = Pipe() 
 9 p = Process(target=f, args=(child_conn,))
10 p.start()
11 print(parent_conn.recv()) # prints "[42, None, 'hello']"
12 p.join()

Manager

通过Manager可实现进程间数据的共享。Manager()返回的manager对象会通过一个服务进程，来使其他进程通过代理的方式操作python对象。manager对象支持 list, dict, Namespace, Lock, RLock, Semaphore, BoundedSemaphore, Condition, Event, Barrier, Queue, Value ,Array.

 1from multiprocessing import Process, Manager
 2
 3def f(d, l):
 4 d[1] = '1'
 5 d['2'] = 2
 6 d[0.25] = None
 7 l.append(1)
 8 print(l)
 9
10if __name__ == '__main__':
11 with Manager() as manager:
12 d = manager.dict()
13
14 l = manager.list(range(5))
15 p_list = []
16 for i in range(10):
17 p = Process(target=f, args=(d, l))
18 p.start()
19 p_list.append(p)
20 for res in p_list:
21 res.join()
22
23 print(d)
24 print(l)

进程锁（进程同步）

数据输出的时候保证不同进程的输出内容在同一块屏幕正常显示，防止数据乱序的情况。

Without using the lock output from the different processes is liable to get all mixed up.

 1from multiprocessing import Process, Lock
 2
 3def f(l, i):
 4 l.acquire()
 5 try:
 6 print('hello world', i)
 7 finally:
 8 l.release()
 9
10if __name__ == '__main__':
11 lock = Lock()
12
13 for num in range(10):
14 Process(target=f, args=(lock, num)).start()

进程池

由于进程启动的开销比较大，使用多进程的时候会导致大量内存空间被消耗。为了防止这种情况发生可以使用进程池，（由于启动线程的开销比较小，所以不需要线程池这种概念，多线程只会频繁得切换cpu导致系统变慢，并不会占用过多的内存空间）

进程池中常用方法：

方法解释apply()同步执行（串行）apply_async()异步执行（并行）terminate()立刻关闭进程池join()主进程等待所有子进程执行完毕。必须在close或terminate()之后。close()等待所有进程结束后，才关闭进程池。

例子：

 1from multiprocessing import Process,Pool
 2import time
 3
 4def Foo(i):
 5 time.sleep(2)
 6 return i+100
 7
 8def Bar(arg):
 9 print('-->exec done:',arg)
10
11pool = Pool(5) #允许进程池同时放入5个进程
12
13for i in range(10):
14 pool.apply_async(func=Foo, args=(i,),callback=Bar) #func子进程执行完后，才会执行callback，否则callback不执行（而且callback是由父进程来执行了）
15 #pool.apply(func=Foo, args=(i,))
16
17print('end')
18pool.close()
19pool.join() #主进程等待所有子进程执行完毕。必须在close()或terminate()之后。

进程池内部维护一个进程序列，当使用时，去进程池中获取一个进程，如果进程池序列中没有可供使用的进程，那么程序就会等待，直到进程池中有可用进程为止。在上面的程序中产生了10个进程，但是只能有5同时被放入进程池，剩下的都被暂时挂起，并不占用内存空间，等前面的五个进程执行完后，再执行剩下5个进程。