线程
进程
通过了解我们知道操作系统中进程的概念，程序并不能单独运行，只有将程序装载到内存中，系统为它分配资源才能运行，而这种执行的程序就称之为进程。程序和进程的区别就在于：程序是指令的集合，它是进程运行的静态描述文本；进程是程序的一次执行活动，属于动态概念。在多道编程中，我们允许多个程序同时加载到内存中，在操作系统的调度下，可以实现并发地执行。这是这样的设计，大大提高了CPU的利用率。进程的出现让每个用户感觉到自己独享CPU，因此，进程就是为了在CPU上实现多道编程而提出的。
简单的说：进程其实就是资源单位，表示一块内存空间
线程的引入
我们知道进程的优点是：提供了多道编程，让每个人都拥有自己的CPU和其他资源，可以提高计算机的利用率。但是同时也有缺点的，主要提现在：
1.进程只能在一个时间干一件事，如果想一心二用或者三用，进程就无能为力了
2.进程执行过程中如果阻塞了（等待输入等），整个进程就会挂起，即便进程中有些工作不依赖于输入的数据，也无法执行。
想要解决上述问题，引入了线程
线程
在80年代，出现了能独立运行的基本单位———线程（Threads)，
简单的说：线程才是执行单位，表示真正的代码指令。我们可以将进程比喻是车间，线程是车间里的流水线，一个进程内部至少含有一个线程
1.一个进程内可以开设多个线程
2.同一个进程下的多个线程数据是共享的
注意：进程是资源分配的最小单位，线程是CPU调度的最小单位，每一个进程至少有一个线程
进程与线程的区别
- 地址空间和其它资源（如打开文件）：进程间相互独立，同一进程的各线程间共享。某进程内的线程在其它进程不可见。
- 通信：进程间通信IPC，线程间可以直接读写进程数据段（如全局变量）来进行通信——需要进程同步和互斥手段的辅助，以保证数据的一致性。
- 调度和切换：线程上下文切换比进程上下文切换要快得多。（创建进程要申请内存空间，但是线程是在申请好的内存空间直接创建，所以创建进程消耗是要远远大于线程的）
- 在多线程操作系统中，进程不是一个可执行的实体。
*通过漫画了解线程进城 ——————设置超链接
线程的特点
在多线程的操作系统中，通常是在一个进程中包括多个线程，每个线程都是作为利用CPU的基本单位，是花费最小开销的实体。
1.轻型实体
线程中的实体基本上不拥有系统资源，只是有一点必不可少的、能保证独立运行的资源。
2.独立调度和分派的基本单位
在多线程OS中，线程是能独立运行的基本单位，因而也是独立调度和分派的基本单位。由于线程很“轻”，故线程的切换非常迅速且开销小（在同一进程中的）。
3.共享进程资源
线程在同一进程中的各个线程，都可以共享该进程所拥有的资源，这首先表现在：所有线程都具有相同的进程id，这意味着，线程可以访问该进程的每一个内存资源；此外，还可以访问进程所拥有的已打开文件、定时器、信号量机构等。由于同一个进程内的线程共享内存和文件，所以线程之间互相通信不必调用内核。
4.可并发执行
在一个进程中的多个线程之间，可以并发执行，甚至允许在一个进程中所有线程都能并发执行；同样，不同进程中的线程也能并发执行，充分利用和发挥了处理机与外围设备并行工作的能力。
线程在一个进程中的并发执行如下图：
创建线程的多种方法
引入Thread模块
方法一
不用
from threading import Thread
import time
def task(name):
print(f'{name} is running')
time.sleep(0.1)
print(f'{name} is over')
t = Thread(target=task,args=('jason',))
t.start()
print('主线程')
代码结果：
jason is running
主线程
jason is over
因为for循环是进程同时启动的，所有我们计算时间有可能会
方法二
from threading import Thread
import time
class MyThread(Thread):
def run(self):
print('run is running')
time.sleep(1)
print('run is over')
obj = MyThread()
obj.start()
print('主线程')
代码展示：
run is running
主线程
run is over
创建进程与线程的速度比较
等所有的进程或线程结束后再统计总共花的时间
-
进程
from multiprocessing import Process import time def task(name): print(f'{name} is running') time.sleep(0.1) print(f'{name} is over') if __name__ == '__main__': start_time = time.time() p_list = [] for i in range(100): p = Process(target=task,args=('用户%s'%i,)) p.start() p_list.append(p) for p in p_list: p.join() print(time.time()-start_time) 代码展示： 用户0 is running 用户1 is running .... 用户15 is running 用户0 is over 用户1 is over 用户16 is running ..... 用户99 is over 用户98 is over 0.8929297924041748 -
线程
from threading import Thread import time def task(name): print(f'{name} is running') time.sleep(0.1) print(f'{name} is over') if __name__ == '__main__': start_time = time.time() t_list = [] for i in range(100): t = Thread(target=task,args=('用户%s'%i,)) t.start() t_list.append(t) for t in t_list: t.join() print(time.time()-start_time) 代码展示： 用户0 is running 用户1 is running .... 用户63 is over 用户0 is over 0.11278319358825684线程消耗的时间要比进程消耗的时间少
线程诸多方法
1. 线程的join方法
from threading import Thread
import time
def task(name):
print(f'{name} is running')
time.sleep(0.1)
print(f'{name} is over')
t = Thread(target=task,args=('kiki',))
t.start()
t.join()
print('主线程')
代码展示：
kiki is running
kiki is over
主线程
2. 同一个进程内多条线程数据共享
因为是同一个进程，空间的数据是共享的
from threading import Thread
money = 8888
def task():
global money
money = 6666
t = Thread(target=task)
t.start()
t.join()
print(money) # 6666
3.current_thread() 方法
既可以查看线程号，也可以查看线程的主线程进程号和子进程的线程号
from threading import Thread,current_thread
import os
money = 8888
def task():
global money
money = 6666
print(current_thread().name)
print('子线程进程号',os.getpid())
for i in range(5):
t = Thread(target=task)
t.start()
# t.join()
# print(money) # 6666
print(current_thread().name)
print('主线程进程号',os.getpid())
代码展示：
Thread-1
子线程进程号 21756
Thread-2
子线程进程号 21756
Thread-3
子线程进程号 21756
Thread-4
子线程进程号 21756
Thread-5
子线程进程号 21756
MainThread
主线程进程号 21756
4.current_thread() 方法 （进程下的线程数）
from threading import Thread,current_thread,active_count
import os
money = 8888
def task():
# time.sleep(3)
global money
money = 6666
print(current_thread().name)
print('子线程进程号',os.getpid())
for i in range(5):
t = Thread(target=task)
t.start()
# t.join()
# print(money) # 6666
print('线程的个数：',active_count()) # 线程的个数： 1
print(current_thread().name)
print('主线程进程号',os.getpid())
一般存活的线程数都是1，因为for循环结束之后只剩下内存自带的一个主线程，就算是空代码也有一个线程，如果想统计所有的线程数的话，就必须添加了time.sleep(3),
3. 守护线程
守护线程伴随着被守护的线程的结束而结束，进程下所有的非守护线程结束，主线程（主进程）才能真正结束。
from threading import Thread
import time
def task():
print('子线程运行task函数')
time.sleep(3)
print('子线程运行task结束')
t = Thread(target=task)
# t.daemon = True
t.start()
# t.daemon = True
print('主线程')
多线程实现TCP服务端并发
1.GIL全局解释器锁
1. 概念
重要点
GIL是CPython解释器的特性
GIL全局解释器锁的理解
# 官方文档对GIL的解释
In CPython, the global interpreter lock, or GIL, is a mutex that prevents multiple native threads from executing Python bytecodes at once. This lock is necessary mainly because CPython’s memory management is not thread-safe. (However, since the GIL exists, other features have grown to depend on the guarantees that it enforces.
理解：
-
在CPython解释器中存在全局解释器锁，简称GIL
python解释器有很多类型
CPython JPython PyPython (常用的是CPython解释器) -
GIL本质也是一把互斥锁 用来阻止同一个进程内多个线程同时执行(重要)，降低了CPU的利用率
-
GIL的存在是因为CPython解释器中，针对多线程无法保存数据的安全，简单说就是内存管理不是线程安全的(垃圾回收机制)。
垃圾回收机制：引用计数、标记清除、分代回收 说明：垃圾回收机制不允许多个线程启动，每一个进程都有垃圾回收机制，当线程的引用计数为0，垃圾回收机制就会回收掉，如果引入了GIL机制，多个线程绑定数据值之后，会去找解释器，GIL枪锁是在解释器之前，GIL释放锁是在解释器之后，当一个线程抢到了GIL锁之后，其他的线程就会等着，当抢到GIL锁会被CPU执行，释放之后，其余的线程继续抢GIL锁，依次类推，此过程不会有IO操作，如下图
2.验证GIL的存在
2.1 没有IO操作
from threading import Thread
num = 100
def task():
global num
num -= 1
t_list = []
for i in range(100):
t = Thread(target=task)
t.start() # 这里是if 操作
# t.join() 这里是指每个线程运行结束
t_list.append(t)
for t in t_list:
t.join() # 不能在上面加，要不然就不能保证所有的线程都运行完毕
print(num) # 0
当第一个线程去抢GIL，其他的线程只能等第一个线程运行结束之后第二个线程才去抢GIL；等第二个线程运行结束之后第三个线程才去抢GIL，依次类推，最后的num持续减为0
2.2 如果当里面有io操作，输出的结果为99
当线程1抢到GIL锁后，当count = num=100，就会遇到IO操作（time.sleep(0.1)），其他线程就会去抢GIL锁，例如是线程2抢到GIL锁，线程2执行到当count = num=100，也会遇到IO操作（time.sleep(0.1)），依次类推，当最后一个线程99抢到GIL锁，执行count = num=100，也会遇到IO操作，当所有线程通过睡眠时间0.1s就自动会执行num = count -1=100-1=99，大家的count都是100
import time
from threading import Thread
num = 100
def task():
global num
count = num
time.sleep(0.1)
num = count -1
t_list = []
for i in range(100):
t = Thread(target=task)
t.start() # 这里是if 操作
t_list.append(t)
for t in t_list:
t.join() # 不能在上面加，要不然就不能保证所有的线程都运行完毕
print(num) # 99
3.GIL与普通互斥锁
GIL只能够确保同进程内多线程数据不会被垃圾回收机制弄乱 ，并不能确保程序里面的数据是否安全。既然CPython解释器中有GIL 那么我们以后写代码是不是就不需要操作锁了!!!（看需求的）
并发变成了串行
import time
from threading import Thread,Lock
num = 100
def task(mutex):
global num
mutex.acquire() # 枪锁
count = num
time.sleep(0.1)
num = count - 1
mutex.release() # 释放锁
mutex = Lock()
t_list = []
for i in range(100):
t = Thread(target=task,args=(mutex,))
t.start()
t_list.append(t)
for t in t_list:
t.join()
print(num) # 0
上述说明了：只能一个线程完成枪锁—运行完成—释放锁操作之后，下一个线程再执行前面的操作，还是将并发变成了串行
2.python多线程是否有用
同一个进程内多个线程确实无法使用到多核优势，但是并不是没有用，要看情况
1.IO密集型(代码有IO操作)
在IO密集型，多线程是有用的，如：同一个进程中的多线程（每个10s)是可以实现同时并发，但是多进程，每个进程都需要一个CPU的参与，每个进程都要创建内存空间等，所有多线程肯定要多进程要耗时小
代码展示：
from threading import Thread
from multiprocessing import Process
import time
def work():
time.sleep(2) # 模拟纯IO操作
if __name__ == '__main__':
""" 多线程"""
start_time = time.time()
t_list = []
for i in range(100):
t = Thread(target=work)
t.start()
t_list.append(t)
for t in t_list:
t.join()
print('总耗时:%s' % (time.time() - start_time)) # 总耗时:2.0168938636779785
"""多进程"""
# start_time = time.time()
# p_list = []
# for i in range(100):
# p = Process(target=work)
# p.start()
# p_list.append(p)
# for p in p_list:
# p.join()
# print('总耗时:%s' % (time.time() - start_time)) # 总耗时:2.7177116870880127
IO密集型
多线程:2.0168938636779785
多进程:2.7177116870880127
2.计算密集型(代码没有IO)
在计算密集型，多核优势明显，多线程效率低，如，线程和进程各4个，每个都需要耗时10s，每个线程都必须老老实实的要CPU参与，多线程总耗时就是就是40s;而多进程是可以有多个CPU参与的，多进程总耗时就是10s
总结：我们还有多进程和协程，将上述不足降低到最小
from threading import Thread
from multiprocessing import Process
import os
import time
def work():
# 计算密集型
res = 1
for i in range(1, 100000):
res *= i
if __name__ == '__main__':
""" 多进程"""
# print(os.cpu_count()) # 16 查看当前计算机CPU个数
# start_time = time.time()
# p_list = []
# for i in range(12): # 一次性创建12个进程
# p = Process(target=work)
# p.start()
# p_list.append(p)
# for p in p_list: # 确保所有的进程全部运行完毕
# p.join()
# print('总耗时:%s' % (time.time() - start_time)) # 获取总的耗时总耗时:3.126591920852661
""" 多线程 """
start_time = time.time()
t_list = []
for i in range(12):
t = Thread(target=work)
t.start()
t_list.append(t)
for t in t_list:
t.join()
print('总耗时:%s' % (time.time() - start_time)) # 获取总的耗时总耗时:总耗时:24.778605699539185
计算密集型
多进程:3.126591920852661
多线程:24.778605699539185
3.死锁现象
acquire()
release()
from threading import Thread,Lock
import time
mutexA = Lock() # 产生一把锁
mutexB = Lock() # 产生一把锁
class MyThread(Thread):
def run(self):
self.func1()
self.func2()
def func1(self):
mutexA.acquire()
print(f'{self.name}抢到了A锁')
mutexB.acquire()
print(f'{self.name}抢到了B锁')
mutexB.release()
print(f'{self.name}释放了B锁')
mutexA.release()
print(f'{self.name}释放了A锁')
def func2(self):
mutexB.acquire()
print(f'{self.name}抢到了B锁')
# time.sleep(1)
mutexA.acquire()
print(f'{self.name}抢到了A锁')
mutexA.release()
print(f'{self.name}释放了A锁')
mutexB.release()
print(f'{self.name}释放了B锁')
for i in range(10):
obj = MyThread()
obj.start()
如果添加了IO操作（time.sleep(1)），当线程1在func1锁定了A锁并走完了func1,开始走func2,此时的其他线程都会去抢锁A，所以线程1很轻松的在func2锁定了B锁；而线程1走完func1时，所有线程都会去抢A锁，比如线程2抢到了锁A，准备抢B锁时，但B锁已经被线程1抢了；此时线程1遇到了IO操作，程序就会卡住，因为线程1已经锁定了B锁，接下抢A锁，但是A锁已经被线程2锁定了;而B锁又被线程1锁定了，线程2也抢不了B锁，程序就会一直卡住
4.信号量
在python并发编程中信号量相当于多把互斥锁，而在有些知识中信号量意思时到达某个条件自动触发其他操作。
from threading import Thread, Lock, Semaphore
import time
import random
sp = Semaphore(5) # 一次性产生五把锁
class MyThread(Thread):
def run(self):
sp.acquire()
print(self.name)
time.sleep(random.randint(1, 3))
sp.release()
for i in range(20):
t = MyThread()
t.start()
代码展示：
Thread-1抢到了A锁
Thread-1抢到了B锁
Thread-1释放了B锁
Thread-1释放了A锁
Thread-1抢到了B锁
Thread-1抢到了A锁
Thread-1释放了A锁
Thread-1释放了B锁
Thread-2抢到了A锁
Thread-2抢到了B锁
Thread-2释放了B锁
Thread-2释放了A锁
Thread-2抢到了B锁
Thread-2抢到了A锁
Thread-2释放了A锁
Thread-2释放了B锁
每次可以进五个线程，第一次就可以产生五个线程，但每个线程的时间不同，后面就会根据每个线程用完之后再执行剩余的线程，直到执行完20个线程
5.event事件
from threading import Thread, Event
import time
event = Event() # 类似于造了一个红绿灯
def light():
print('红灯亮着的 所有人都不能动')
time.sleep(3)
print('绿灯亮了 油门踩到底 给我冲!!!')
event.set()
def car(name):
print('%s正在等红灯' % name)
event.wait()
print('%s加油门 飙车了' % name)
t = Thread(target=light)
t.start()
for i in range(20):
t = Thread(target=car, args=('熊猫PRO%s' % i,))
t.start()
6.进程池和线程池
进程和线程能否无限制的创建 >>>不可以
因为硬件的发展赶不上软件，有物理极限， 如果我们在编写代码的过程中无限制的创建进程或者线程可能会导致计算机奔溃
池
降低程序的执行效率，但是保证了计算机硬件的安全
进程池
提前创建好固定数据的进程供后续程序的调用，超出则等待
线程池
提前创建好固定数量的线程后续程序的调用，超出则等待
代码演示
from concurrent.futures import ProcessPoolExecutor, ThreadPoolExecutor
import os
import time
import random
from threading import current_thread
# 1.产生含有固定数量线程的线程池
# pool = ThreadPoolExecutor(10)
pool = ProcessPoolExecutor(5)
def task(n):
print('task is running')
# time.sleep(random.randint(1, 3))
# print('task is over', n, current_thread().name)
# print('task is over', os.getpid())
return '我是task函数的返回值'
def func(*args, **kwargs):
print('from func')
if __name__ == '__main__':
# 2.将任务提交给线程池即可
for i in range(20):
# res = pool.submit(task, 123) # 朝线程池提交任务
# print(res.result()) # 不能直接获取
# pool.submit(task, 123).add_done_callback(func)
使用进程池和线程池的目的：
1.异步回调机制add_done_callback(func)(反馈机制)
协程
进程：资源单位
线程：执行单位
协程：单线程下实现并发(效率极高)
在代码层面欺骗CPU 让CPU觉得我们的代码里面没有IO操作
实际上IO操作被我们自己写的代码检测 一旦有 立刻让代码执行别的
(该技术完全是程序员自己弄出来的 名字也是程序员自己起的)
核心:自己写代码完成切换+保存状态
代码展示：
import time
from gevent import monkey;
monkey.patch_all() # 固定编写 用于检测所有的IO操作(猴子补丁)
from gevent import spawn
def func1():
print('func1 running')
time.sleep(3)
print('func1 over')
def func2():
print('func2 running')
time.sleep(5)
print('func2 over')
if __name__ == '__main__':
start_time = time.time()
# func1()
# func2()
s1 = spawn(func1) # 检测代码 一旦有IO自动切换(执行没有io的操作 变向的等待io结束)
s2 = spawn(func2)
s1.join()
s2.join()
print(time.time() - start_time) # 8.01237154006958 协程 5.015487432479858
协程实现并发
import socket
from gevent import monkey;monkey.patch_all() # 固定编写 用于检测所有的IO操作(猴子补丁)
from gevent import spawn
def communication(sock):
while True:
data = sock.recv(1024)
print(data.decode('utf8'))
sock.send(data.upper())
def get_server():
server = socket.socket()
server.bind(('127.0.0.1', 8080))
server.listen(5)
while True:
sock, addr = server.accept() # IO操作
spawn(communication, sock)
s1 = spawn(get_server)
s1.join()
如何不断的提升程序的运行效率
多进程下开多线程 多线程下开协程
原文地址：http://www.cnblogs.com/zhanglanhua/p/16913618.html
