**
**
这篇博客主要内容为python 中多线程以及多进程的效率对比，以及记录自己在做这个实验中遇到的一些问题以及心得
背景引入：
CPU制造商为了追求CPU效率放弃了在CPU频率上的追求(CPU频率即CPU单位时间内可以完成任务的多少)，反而开始把方向转向了多核CPU上。那么如何在多核CPU上充分发挥出多核的优势就成了一个问题。
首先是简单介绍下多线程与多进程：
线程：
是程序执行流的最小单元，是系统独立调度和分配CPU(独立运行)的基本单位。线程(有时被称为轻量级进程)跟进程有些相似，不同的是，所有的线程运行在同一个进程中， 共享相同的运行环境。它们可以想像成是在主进程或“主线程”中并行运行的“迷你进程”。
进程：
是资源分配的基本单位。一个进程包括多个线程。进程(有时被称为重量级进程)是程序的一次 执行。每个进程都有自己的地址空间，内存，数据栈以及其它记录其运行轨迹的辅助数据。操作系 统管理在其上运行的所有进程，并为这些进程公平地分配时间。进程也可以通过 fork 和 spawn 操作 来完成其它的任务。不过各个进程有自己的内存空间，数据栈等，所以只能使用进程间通讯(IPC)， 而不能直接共享信息。
说简单点进程就好比QQ，浏览器这些应用程序，而线程就像QQ里和不同的人的聊天窗口或者浏览器中播放的音乐，显示的网页。
区别：
1.线程与资源分配无关，它属于某一个进程，并与进程内的其他线程一起共享进程的资源。
2.每个进程都有自己一套独立的资源(数据)，供其内的所有线程共享。
3.不论是大小，开销线程要更“轻量级”
4.一个进程内的线程通信比进程之间的通信更快速，有效。(因为共享变量)
测试机：
物理机
虚拟机操作系统
macOS
Ubuntu16.04
CPU
双核
单核
内存
8G
2G
python在管理多线程使用了GIL
pythonGIL解释：
GIL是实现python解释器时引入的一个概念，像C语言一样，python 的解释器也有很多，常见的有CPython，Psyco，PyPy。 而GIL是实现CPyhon时引入的。
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.)
GIL的出现是有历史原因的，对于并行和并发这样的多任务，就是为了提高CPU的使用效率，然而需要注意的是，一个CPU一个时间只能实现一个任务，也就是说一个CPU永远不可能并行的，但是可以借助CPU轮训制度频繁切换任务，完成多任务。
python在刚创立的时候只考虑到了单核CPU，那么考虑到多线程的数据完整性以及状态同步就需要加一把大锁，所以呢，GIL应运而生。
GIL说简单点就是一把大锁，一把有很大权力的锁，一把可以控制CPU的锁，它可以保证一个时间内只能有一个CPU在工作，确保了多线程数据完整性和状态同步，看到这个地方，大家就有疑惑了，那还要多核CPU干什么，都成单核的了。这也确实是GIL局限性的地方。从上面的英文解释中可以看出GIL可
+以保证线程的安全，刚看到这个概念我有点疑惑，难道操作系统自身的线程调度机制不可以吗，通过查找操作系统的资料我发现，操作系统还真的不可以，下面介绍几种调度算法；
1、先到先服务调度算法(FCFS)
根据就绪队列的到达时间来服务，此时就绪队列是一个FIFO队列，先到先服务，后到的线程不能抢占前面正在服务的线程。这种算法的优点是实现简单，缺点也很明显，就是CPU进程区间变化很大时，平均等待时间会变化很大。
2、最短作业优先调度(SJF)
顾名思义，就是CPU进程区间最短的先执行，如果两个进程区间具有同样的长度，那么按照FCFS来调度。
SJF可以是抢占的，也可以是不抢占的。它的平均等待时间优于FCFS。
3、优先级调度
其实上面的SJF算法就是一种特殊的优先级调度，只不过这里的优先级定义更加广泛一些，SJF算法的优先级是按照CPU进程区间长短来定义的，这里的优先级可以是其他的一些定义。
优先级调度可以是抢占的，也可以是非抢占的。
优先级调度的一个主要问题是无穷阻塞(也称为饥饿)，如果一个线程的优先级很低，可能需要等待很长的时间才能到这个线程执行，甚至永远不执行，一种解决方法是老化(随着时间的增长，增加线程的优先级)
4、轮转法调度(RR)
轮转法调度专门是为分时系统设计的。它类似于FCFS，但是增加了抢占为了切换线程。定义一个较小的时间单元，称为时间片，通常为10-100ms。为了实现RR算法，将就绪队列保存为FIFO队列，新进程增加到就绪队列队尾，CPU调度程序从就绪队列选择第一个进程，设置定时器在一个时间片之后再中断，再分派这个进程。
如果该进程的CPU区间小于时间片，进程本身就会释放CPU，调度程序继续处理下一个进程，如果当前进程的CPU区间比时间片长，定时器会产生CPU中断，实行上下文切换，然后将此进程放到就绪队列队尾，继续调度就绪队列第一个进程。
可以看出计算机并不知道代码的具体含义，所以如果代码只是使用数据就没有问题，如果代码要改变数据可能会导致再多线程时数据不同步状态不统一，所以GIL这把锁就可以保证线程的安全。正如上文所说，GIL也确实是一个缺陷无法充分体现出多核的优势，那么我们应该避免这个问题呢：
1.用其他解析器
之前也提到了既然GIL只是CPython的产物，那么其他解析器是不是更好呢？没错，像JPython这样的解析器由于实现语言的特性，他们不需要GIL的帮助。然而由于用了Java/C#用于解析器实现，他们也失去了利用社区众多C语言模块有用特性的机会。所以这些解析器也因此一直都比较小众。所以这个方法并不推荐
2.使用多进程代替多线程
用multiprocessing替代Thread
multiprocessing库的出现很大程度上是为了弥补thread库因为GIL而低效的缺陷。它完整的复制了一套thread所提供的接口方便迁移。唯一的不同就是它使用了多进程而不是多线程。每个进程有自己的独立的GIL，因此也不会出现进程之间的GIL争抢。当然multiprocessing也不是万能良药。它的引入会增加程序实现时线程间数据通讯和同步的困难。multiprocessing由于进程之间无法看到对方的数据，只能通过在主线程申明一个Queue，put再get或者用share memory的方法。这个额外的实现成本使得本来就非常痛苦的多线程程序编码，变得更加痛苦了。但是这仍然是我觉得对于初学者来说最友好的方法了。
代码实现
python中关于线程的使用涉及到threading模块，进程使用涉及multiprocessing模块
都只是使用最基本的start，len方法，所以这里不多赘述。
直接上代码：
需要的第三方库
import requests
import time
import threading
from multiprocessing import Process
首先是线性执行CPU密集型函数，IO密集型函数
# 定义CPU密集型函数
def count(x, y):
c = 0
while c < 500000:
c += 1
x += x
y += y
#定义IO密集型函数
def write():
f = open("test.txt", "w")
for x in range(500000):
f.write("testwriten")
f.close()
def read():
f = open("test.txt", "r")
lines = f.readlines()
f.close()
#定义网络请求函数
head_request = {
'User-Agent':'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_13_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/69.0.3497.100 Safari/537.36'
}
url = "http://www.tieba.com"
def http_request():
try:
res = requests.get(url, headers=head_request)
html = res.text
return {"context": html}
except Exception as e:
return {"error": e}
# CPU密集操作
t = time.time()
for x in range(10):
count(1, 1)
print("cpu函数运行时间：", time.time() - t)
# IO密集操作
t = time.time()
for x in range(10):
write()
read()
print("IO函数运行时间：", time.time() - t)
接下来是多线程并发模拟CPU密集型函数`
# 定义CPU密集型函数
def count(x, y):
c = 0
while c < 500000:
c += 1
x += x
y += y
counts = []
t = time.time()
for x in range(10):
thread = threading.Thread(target=count, args=(1,1))
counts.append(thread)
thread.start()
e = counts.__len__() #这里使用了一个魔术方法，获取counts的长度
while True:
for i in counts:
if not i.is_alive():
e -= 1
if e <= 0:
break # 当所有线程执行完毕后退出
print(time.time() - t)
多进程模拟CPU密集型函数
# 定义CPU密集型函数
def count(x, y):
c = 0
while c < 500000:
c += 1
x += x
y += y
counts = []
t = time.time()
for x in range(10):
process = Process(target=count, args=(1,1))
counts.append(process)
process.start()
e = counts.__len__()
while True:
for i in counts:
if not i.is_alive():
e -= 1
if e <= 0:
break
print(time.time() - t)
物理机
虚拟机线性执行CPU密集型函数
65.29
120
线性执行IO密集型函数
1.76
1.6
多线程并发模拟CPU密集型函数
65.92
132.58
多进程并行模拟CPU密集型函数
38.87
127.9
通过上面的表格进行数据对比，明显发现在多核的情况下，python的多进程要比多线程快得多。那么是为什么呢，这里就要说到python的多线程管理机制，在python3.x中，GIL使用计时器(执行时间达到阈值后，当前线程释放GIL)对线程进行管理，这样对CPU密集型程序更加友好，但依然没有解决GIL导致的同一时间只能执行一个线程的问题，所以效率依然不尽如人意。而且在多核的情况下可能在进程调度轮训的过程中还会产生CPU的竞争会产生更加坏的效果。
#GIL即全局解释器锁
然而对于IO密集型函数或者网络请求函数，多线程就是友好地，因为可以利用函数的挂起空闲时间进行线程的转换，充分利用到了多核CPU的优势。
在单核的情况下，模拟的多进程并行的效率也是优于多线程并发的。
Liunx多线程pthread初探：https://blog.csdn.net/xuanandting/article/details/78842795
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
