关于写这篇是看了好久别人的博客，有了一点点的认知并且具体应用到自己以后网络爬虫中，所以先分享一下吧，以后自己再看看。
<转载> 为什么在Python里推荐使用多进程而不是多线程？
经常我们会听到老手说：“Python下多线程是鸡肋，推荐使用多进程！”，但是为什么这么说呢？
要知其然，更要知其所以然。所以有了下面的深入研究：
首先强调背景：
1、GIL是什么？
GIL的全称是Global Interpreter Lock(全局解释器锁)，来源是python设计之初的考虑，为了数据安全所做的决定。
2、每个CPU在同一时间只能执行一个线程（在单核CPU下的多线程其实都只是并发，不是并行，并发和并行从宏观上来讲都是同时处理多路请求的概念。但并发和并行又有区别，并行是指两个或者多个事件在同一时刻发生；而并发是指两个或多个事件在同一时间间隔内发生。）
在Python多线程下，每个线程的执行方式：
1、获取GIL
2、执行代码直到sleep或者是python虚拟机将其挂起。
3、释放GIL
可见，某个线程想要执行，必须先拿到GIL，我们可以把GIL看作是“通行证”，并且在一个python进程中，GIL只有一个。拿不到通行证的线程，就不允许进入CPU执行。
在Python2.x里，GIL的释放逻辑是当前线程遇见IO操作或者ticks计数达到100（ticks可以看作是Python自身的一个计数器，专门做用于GIL，每次释放后归零，这个计数可以通过 sys.setcheckinterval 来调整），进行释放。
而每次释放GIL锁，线程进行锁竞争、切换线程，会消耗资源。并且由于GIL锁存在，python里一个进程永远只能同时执行一个线程(拿到GIL的线程才能执行)，这就是为什么在多核CPU上，python的多线程效率并不高。
那么是不是python的多线程就完全没用了呢？
在这里我们进行分类讨论：
1、CPU密集型代码(各种循环处理、计数等等)，在这种情况下，由于计算工作多，ticks计数很快就会达到阈值，然后触发GIL的释放与再竞争（多个线程来回切换当然是需要消耗资源的），所以python下的多线程对CPU密集型代码并不友好。
2、IO密集型代码(文件处理、网络爬虫等)，多线程能够有效提升效率(单线程下有IO操作会进行IO等待，造成不必要的时间浪费，而开启多线程能在线程A等待时，自动切换到线程B，可以不浪费CPU的资源，从而能提升程序执行效率)。所以python的多线程对IO密集型代码比较友好。
而在python3.x中，GIL不使用ticks计数，改为使用计时器（执行时间达到阈值后，当前线程释放GIL），这样对CPU密集型程序更加友好，但依然没有解决GIL导致的同一时间只能执行一个线程的问题，所以效率依然不尽如人意。
请注意：多核多线程比单核多线程更差，原因是单核下多线程，每次释放GIL，唤醒的那个线程都能获取到GIL锁，所以能够无缝执行，但多核下，CPU0释放GIL后，其他CPU上的线程都会进行竞争，但GIL可能会马上又被CPU0拿到，导致其他几个CPU上被唤醒后的线程会醒着等待到切换时间后又进入待调度状态，这样会造成线程颠簸(thrashing)，导致效率更低
回到最开始的问题：经常我们会听到老手说：“python下想要充分利用多核CPU，就用多进程”，原因是什么呢？
原因是：每个进程有各自独立的GIL，互不干扰，这样就可以真正意义上的并行执行，所以在python中，多进程的执行效率优于多线程(仅仅针对多核CPU而言)。
所以在这里说结论：多核下，想做并行提升效率，比较通用的方法是使用多进程，能够有效提高执行效率
转载地址：http://bbs.51cto.com/thread-1349105-1.html
以下便为自己的一点点小理解，还有从网上找的一些资源，应用到具体的爬虫中去。很简单的分享。
进程和线程的区别以及应用
“”"
根本区别：进程是操作系统资源分配的基本单位，而线程是任务调度和执行的基本单位。
开销方面：进程有独立的代码和数据空间，程序之间切换会有较大的开销；而线程可以看做轻量级的进程，开销较小。
所处环境：操作系统中能同时运行多个进程(也就是程序)；而同一个进程中可以有多个线程同时执行(不过每个时间片中只有一个线程执行)
内存分配方面：系统在运行的时候为每个进程分配不同的内存空间。除了CPU以外，系统不会为线程分配内存(线程所使用的资源来自所属的进程)，线程自建共享资源。
包含关系：进程至少有一个线程，线程是进程的一部分。
“”"
第一个例子：这是正常平时做的请求百度的。
import time
import requests
start_time = time.time()
for i in range(20):
time.sleep(1)
response = requests.get(url='http://www.baidu.com')
if response.status_code == 200:
print('响应成功')
end_time = time.time()
print('总共花费了 %s秒 时间' % (end_time - start_time))
# 结果：总共花费了 24.24276304244995秒 时间
第二个例子：进程的用法
import os, time
import requests
import multiprocessing
def worker(sing, lock):
lock.acquire()
time.sleep(1)
response = requests.get(url='http://www.baidu.com')
if response.status_code == 200:
print('响应成功')
lock.release()
time.sleep(1)
if __name__ == '__main__':
plist = []
lock = multiprocessing.Lock()
for j in range(20):
start_time = time.time()
p = multiprocessing.Process(target=worker, args=('process', lock))
p.start()
plist.append(p)
p.join()
end_time = time.time()
print('总共花费了 %s秒 时间' % (end_time - start_time))
# 结果：总共花费了 19.673285961151123秒 时间
"""
在multiprocessing.Process实例化一个对象之后，该对象有必要调用join方法.而对于多线程来说，由于只有一个进程，所有子线程共享同一片内存，所以不是必须要进行join调用
python多进程中，同样需要全局解释器锁，因为每个子进程都有一把GIL，那么当它们向stdout输出时，可以同时争抢stdout资源，导致在每个子进程输出时会把不同子进程的输出字符混合在一起，无法阅读，影响代码的标志位判断，
所以上例子中使用了Lock同步，在一个子进程输出完成之后再允许另一个子进程得到stdout的权限，这样避免了多个任务同时向终端输出
"""
进程池
例子一： 正常时候的访问。
import os, time
import requests
import multiprocessing
start_time = time.time()
for i in range(20):
time.sleep(1)
response = requests.get(url='http://www.baidu.com')
if response.status_code == 200:
print('响应成功')
end_time = time.time()
print('总共花费了 %s秒 时间' % (end_time - start_time))
# 结果：总共花费了 24.24276304244995秒 时间
例子二：使用进程池
import os, time
import requests
import multiprocessing
def worker(msg):
print('msg: ', msg)
time.sleep(1)
for i in range(20):
response = requests.get(url='http://www.baidu.com')
if response.status_code == 200:
print('响应成功')
print('end')
if __name__ == '__main__':
start_time = time.time()
pool = multiprocessing.Pool(processes=8)
pool.apply_async(worker, (8,))
# pool.apply(func, (msg,)) # 阻塞,apply()源自内建函数，用于间接的调用函数，并且按位置把元祖或字典作为参数传入。
pool.close()
pool.join()
end_time = time.time()
print('总共花费了 %s秒 时间' % (end_time - start_time))
#结果为：总共花费了3.341890573501587秒时间
从上述结果可以完全看出来 使用多进程可以在任务量比较多的情况下效率更高。
注意apply_async和apply的差别，此外，进程池请求函数处理还可以用map，imap，注意传递参数的区别。
例子三 进程池请求函数处理还可以用map，imap：
import os, time
import requests
import multiprocessing
def worker(msg):
print('msg: ', msg)
time.sleep(1)
for i in range(20):
headers = {
'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/64.0.3282.119 Safari/537.36'
}
agent_response = requests.get(url='http://www.baidu.com', headers=headers)
if agent_response.status_code == 200:
print('响应成功')
print('end')
if __name__ == '__main__':
start_time = time.time()
pool = multiprocessing.Pool(8)
# msg = range(50)
pool.map(worker, (6,)) # 阻塞 map 所要传入的信息是一个可迭代的,不能为空
# pool.imap(worker, [msg, ]) # 非阻塞, 注意与apply传的参数的区别
pool.close()
pool.join()
end_time = time.time()
print('总共花费了 %s秒 时间' % (end_time - start_time))
# 结果 总共花费了 9.194029808044434秒 时间 事实证明在任务量比较大的时候 可以适当的增加进程数量,但是必须要注意进程数量不然就把别人网站搞崩溃
"""
总结如下：
我们经常在进行网络编程的时候，常常见到同步、异步、阻塞、非阻塞四种调用方式。下面是对这些术语的一些简答理解
同步：
同步就是在发出一个功能调用的时候，在没有得到结果之前，该调用就不返回。我们再说同步、异步的时候，特指那些需要其他部件协作或者需要一定时间完成任务。
异步：
一个异步过程调用发出后，调用者不能立刻得到这个结果。
阻塞：
阻塞是指调用结果返回之前，当前线程会被挂起。函数只有在得到结果之后才会返回。对于同步调用来说，很多时候当前线程还是激活的，只是从逻辑上当前函数没有返回而已。
非阻塞：
非阻塞和阻塞的概念相对应，指在不能立刻得到结果之前，该函数不会阻塞当前线程，而会立刻返回。
"""
可能理解还是有点偏差力，欢迎指出来，有关于进程池的感觉你们还是直接可以借鉴运用。
参考大佬博客：https://www.cnblogs.com/webber1992/p/6217327.html