标签：__ start print number 进程 线程 字长 多线程

1. 全局解释器锁

全局解释器锁 （英语：Global Interpreter Lock，缩写 GIL）

是 计算机程序设计语言解释器 用于 同步线程 的一种机制，它使得任何时刻仅有 一个线程 在执行，即便在 多核心处理器 上，使用 GIL 的解释器也只允许同一时间执行一个线程。常见的使用 GIL 的解释器有 CPython 与 Ruby MRI。

如果，你对上面的不理解，也没有问题。通俗的解释就是：你电脑是 一核或者多核 ，还是你得代码写了了多个线程，但因为 GIL 锁的存在你也就只能运行一个线程，无法同时运行多个线程。

接下来，我们来用个图片来解释一下：

---

比如图中，假如你开了两个线程（Py thread1 、Py tread2），

1. 当我们线程一（Py thread1）开始执行时，这个线程会去我们的解释器中申请到一个锁。也就是我们的 GIL 锁；
2. 然后，解释器接收到一个请求的时候呢，它就会到我们的 OS 里面，申请我们的系统线程；
3. 系统统一你的线程执行的时候，就会在你的 CPU 上面执行。（假设你现在是四核CPU）；
4. 而我们的另一个线程二（py thread2）也在同步运行。
5. 而线程二在向这个解释器申请 GIL 的时候线程二会卡在这里（Python 解释器），因为它的 GIL 锁已经被线程一给拿走了（也就是说：他要进去执行，必须拿到这把锁）；
6. 线程二要运行的话，就必须等我们的线程一运行完成之后（也就是把我们的 GIL 释放之后（图片中的第5步）线程二才能拿到这把锁）；
7. 当线程二拿到这把锁之后就和线程一的运行过程一样。

① Create > ② GIL > ③ 申请原生线程(OS) > ④ CPU 执行（如果有其他线程，都会卡在 Python 解释器的外边）

这个锁其实是 Python 之父想一劳永逸解决线程的安全问题（也就是禁止多线程同时运行）

2. 多线程测试

为了更加直观，我这里使用把每种线程代码单独写出来并做对比：

单线程裸奔：（这也是一个主线程（main thread））

import time

def start():
	for i in range(1000000):
		i += i
	return

# 不使用任何线程（裸着来）
def main():
	start_time = time.time()
	for i in range(10):
		start()
	print(time.time()-start_time)
if __name__ == '__main__':
	main()

输出：

6.553307056427002

注意：因为每台电脑的性能不一样，所运行的结果也相对不同（请按实际情况分析）

---

接下来我们写一个多线程

我们先创建个字典 (thread_name_time) 来存储我们每个线程的名称与对应的时间

import threading,time

def start():
	for i in range(1000000):
		i += i
	return

# # 不使用任何线程（裸着来）
# def main():
# 	start_time = time.time()
# 	for i in range(10):
# 		start()
# 	print(time.time()-start_time)
# if __name__ == '__main__':
# 	main()

def main():
	start_time = time.time()
	thread_name_time = {}# 我们先创建个字典 (thread_name_time) 用来来存储我们每个线程的名称与对应的时间

	for i in range(10):
        # 也就是说，每个线程顺序执行
		thread = threading.Thread(target=start)# target=写你要多线程运行的函数，不需要加括号
		thread.start()# 上一行开启了线程，这一行是开始运行（也就是开启个 run）
		thread_name_time[i] = thread # 添加数据到我们的字典当中，这里为什么要用i做key？这是因为这样方便我们join


	for i in range(10):
		thread_name_time[i].join()
	# 	join() 等待线程执行完毕（也就是说卡在这里，这个线程执行完才会执行下一步）
	print(time.time()-start_time)

if __name__ == '__main__':
	main()

输出

6.2037984102630615

# 6.553307056427002 裸奔
# 6.2037984102630615 单线程顺序执行
# 6.429047107696533 线程并发

我们可以看到，速度上的区别不大。

多线程并发不如单线程顺序执行快

这是得不偿失的

造成这种情况的原因就是 GIL

这里是计算密集型，所以不适用

在我们执行加减乘除或者图像处理的时候，都是在从 CPU 上面执行才可以。Python 因为 GIL 存在，同一时期肯定只有一个线程在执行，这样这样就是造成我们开是个线程和一个线程没有太大区别的原因。

而我们的网络爬虫大多时候是属于 IO 密集与计算机密集

3. IO 密集与计算机密集 [I：Input O：Output]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-iCIACnqY-1583392394098)(assets/1571801967486.png)]

---

BIOS：B：Base、I：Input、O：Output、S：System

也就是你电脑一开机的时候就会启动。

1. 计算密集型

在上面的时候，我们开启了两个线程，如果这两个线程要同时执行，那同一时期 CPU 上只有一个线程在执行。

那从上图可知，那这两个线程就需要频繁的在上下文切换。

Ps：我们这个绿色表示我们这个线程正在执行，红色代表阻塞。

所以，我们可以明显的观察到，线程的上下文切换也是需要消耗资源的（时间-ms）不断的归还和拿取 GIL 等，切换上下文。明显造成很大的资源浪费。

2. IO 密集型

我们现在假设，有个服务器程序（Socket）也就是我们新开的一个程序（也就是我们网络爬虫的最底层）开始爬取目标网页了，我们那个网页呢，有两个线程同时运行，我们线程二已经请求成功开始运行了，也就是上图的 （Thread 2）绿色一条路过去。

而我们的线程一（Thread 1）- Datagram（这里它开启了一个 UDP），然后等待数据建立（也就是等待哪些 HTML、CSS 等数据返回）也就是说，在 **Ready to receive（recvfrom）**之间都是准备阶段。这样就是有一段时间一直阻塞，而我们的线程二可以一直无停歇也不用切换上下文就一直在运行。这样的 IO 密集型就有很大的好处。

IO 密集型，这样就把我们等待的时间计算进去了，节省了大部分时间。

这里我们需要注意的是，我们的多线程是运行在 IO 密集型上的，我们得区分清楚。

还有就是，资源等待，比如有时候我们使用浏览器发起了一个 Get 请求，那浏览器图标上面在转圈圈的时候就是我们请求资源等待的时间，（也就是图上面的 Datagram 到 Ready to receive ）数据建立到数据接收（就是转圈圈的时间）。我们完全就不需要执行它，就让它等待就好。这个时候让另一个线程去执行就好

换言之就是：第一个线程，我们爬取那个网页转圈圈的时候让另一个线程继续爬取。这样就避免了资源浪费。（把时间都利用起来）

注意： 请求资源是不需要 CPU 进行计算的，CPU 参与是很少的，而我们第一个例子，计算数字的 for 循环中，是需要 CPU 进行计算的。

---

3. 避免 GIL

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-G9AH2Mzv-1583392394099)(assets/1571888520939.png)]

前面开头已经提到：因为 GIL 的存在，所以不管我们开了多少线程，同一时间始终只有一个线程在执行。那我们该如何避免 GIL 呢？

那这样的话，我们不开线程不就行，(它的的存在已经无法避免，那我们选择不使用它不就相当于不存在嘛）。那这是，你会想：那不开线程我们开啥呢？

问的好！

我们来开：进程，那怎么说？别急！请听我细细道来。

比方你有 3 个 CPU（当然，你可能有更多，这里就按 3 个 CPU来为例子），那我们就开 3 个进程就好。一个 CPU 上运行就好。

Ps：我们的进程是可以同时运行的。

我们可以看一下下面的图片：

任务管理器

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-6ad47aID-1583392394100)(assets/1571966626435.png)]

我们 任务管理 上的每一项都是一个进程。

多进程比多线程不好的地方是什么呢？

多进程的创建和销毁开销也会更大，成本高。

你可能线程可以开许多的线程，但你的进程就是看你的 CPU 数量。

进程间无法看到对方数据，需要使用栈或者队列进行获取。

每个进程之间都是独立的。

就好像我们上面的谷歌浏览器和我们的 Pycharm 是没有任何关系的，谷歌浏览器上面的数据肯定不可能让 Pycharm 看到。这就是我们所说的进程之间的独立性。

如果你想要一个进行抓取数据，一个进行调用数据，那这时是不能直接调用的，需要你自己定义个结构才能使用。>>> 编程复杂度提升。

---

4. 多线程与多进程

前面的基础讲完了，接下来我们继续来正式进入主题。

4.1 多线程以及非守护线程

# !/usr/bin/python3
# -*- coding: utf-8 -*-
# @Author：AI悦创 @DateTime ：2019/10/25 9:50 @Function ：功能  Development_tool ：PyCharm
# code is far away from bugs with the god animal protecting
#    I love animals. They taste delicious.

import threading, time

def start():
	time.sleep(1)
	print(threading.current_thread().name) # 当前线程名称
	print(threading.current_thread().is_alive()) # 当前线程状态
	print(threading.current_thread().ident) # 当前线程的编号

print('start')
# 要使用多线程哪个函数>>>target=函数,name=给这个多线程取个名字
# 如果你不起一个名字的话，那那它会自己去起一个名字的（pid）也就是个 ident
# 类似声明
thread = threading.Thread(target=start,name='my first thread')

# 每个线程写完你不start()的话，就类似只是声明
thread.start()
print('stop')

输出

"C:\Program Files\Python37\python.exe" C:/daima/pycharm_daima/爬虫大师班/知识点/多线程/多线程以及非守护线程.py
start
stop
my first thread
True
2968

Process finished with exit code 0

如果有参数的话，我们就对多线程参数进行传参数。代码示例：

import threading, time

def start(num):
	time.sleep(num)
	print(threading.current_thread().name)
	print(threading.current_thread().isAlive())
	print(threading.current_thread().ident)

print('start')
thread = threading.Thread(target=start,name='my first thread', args=(1,))

thread.start()
print('stop')

解析：

我认认真看一下我们的运行结果，

start
stop
my first thread
True
2968

我们会发现并不是按我们正常的逻辑执行这一系列的代码。

而是，先执行完 start 然后就直接 stop 然后才会执行我们函数的其他三项。

一个线程它就直接贯穿到底了。也就是先把我们主线程里面的代码运行完，然后才会运行它里面的代码。

我们的代码并不是当代码执行到 thread.start() 等它执行完再执行 print(‘stop’) 。而是，我们线程执行到thread.start() 继续向下执行，同时再执行里面的代码（也就是**start()**函数里面的代码）。(不会卡在 thread.start() 那里) 也不会随着主线程结束而结束

因为，程序在执行到 print(‘stop’) 之后就是主线程结束，而里面开的线程是我们自己开的。当我们主线程执行这个 stop 就已经结束了。

这种不会随着主线程结束而销毁的，这种线程它叫做：非守护线程

1. 主线程会跳过创建的线程继续执行；
2. 直到创建线程运行完毕；
3. 程序结束；

既然，有非守护线程。那就还有守护线程。

4.2 守护线程

如果要修改成守护线程，那你就得在 thread.start() 前面加一个：

thread.setDaemon(True)

需要在我们启动之前设置。

import threading, time

def start(num):
	time.sleep(num)
	print(threading.current_thread().name) # 当前线程的名字
	print(threading.current_thread().isAlive())
	print(threading.current_thread().ident)

print('start')
thread = threading.Thread(target=start,name='my first thread', args=(1,))
thread.setDaemon(True)
thread.start()
print('stop')

我们来看看运行的结果

start
stop

我们可以看见，程序直接运行：start、stop，执行到 **print(‘stop’) 它就结束了。**也就随着我们的主线程结束而结束。并不管它里面还有什么没有执行完。（也不会管他里面的 time.sleep()）我们的主线程一结束，我们的守护线程就会随着主线程一起销毁。

我们日常启动的是非守护线程，守护线程用的较少。

守护线程会伴随主线程一起结束，setDaemon 设置为 True 即可。

学员问题：任务管理器上面超过五六个进程。都是进程的话，怎么能开那么多呢？

答：我们一个 CPU 不止能执行一个进程，就比如我的一个 CPU 里面密麻麻有许多进程。（比方我现在开六个进程）并发执行的。只不过计算机执行的速度非常快，这里我简单讲一下哈。这是计算机原理的课。

不管是任何操作系统，现在就拿单核操作系统来说：我们假设现在只有一个 CPU ，一个 CPU 里面六个进程，同一时间它只有一个进程在运行。不过我们计算执行速度非常快，这个程序执行完，它就会执行一个上下文切换，执行下一个。（因为，它执行的速度非常快，你就会感觉是并发执行一样。）

实际上，一个 CPU 同一时间只有一个进程在执行，一个进程里面它只有一个线程在执行。（当然，这个单核是五六年前了。现在肯定至少有双核。

那就说有第二个 CPU 了。

而第二个和 CPU 上面又有许多个 进程，两个 CPU 是互不相干。

那这时候，第一个 CPU 上面运行一个进程，而我们的第二个 CPU 上面也有一个进程，两个是互补相干。 （就相当于你开了两台电脑。）

但是同一个 CPU 在同一时间只有一个就进程。（不管你（电脑）速度多么快，实际上本质上（在那一秒）只有一个进程在执行。如果你是双核，那就有两个进程。（四核就有四个进程）

---

Python 有个不好的地方，刚刚上面讲到，如果我们有两个 CPU 那就有两个进程在执行（那四个 CPU 就是四个进程在执行），**但是因为 Python 当中存在着 GIL，它即使有四个 CPU 每次也只有一个线程能进去，**也就是说：同一时间当中，一个 CPU 上的一个进程中的一个线程在执行。剩下的都不能运行，我们的 Python 不能利用多核。

如果，大家用的是 C、Java、Go 这种的就没有这个说法了。

5. Lock 锁

接下来是比较难的知识点，比方说我们现在有两个线程，一个是求加一千万次，另一个是减一千万次。按原本得计划来说，一个加一千万一个减一千万结果应该还是零。可是最终得结果并不是等于零，我们多运行几次会发现几次得出来得结果并不相同。多线程代码如下：

import threading
import time

number = 0

def addNumber(i):
	time.sleep(i)
	global number
	for i in range(1000000):
		number += 1
	print("加",number)

def downNumber(i):
	time.sleep(i)
	global number
	for i in range(1000000):
		number -= 1
	print("减",number)

print("start") # 输出一个开始
thread = threading.Thread(target = addNumber, args=(2,)) #开启一个线程（声明）
thread2 = threading.Thread(target = downNumber, args=(2,)) # 开启第二个线程（声明）
thread.start() # 开始
thread2.start() # 开始
thread.join()
thread2.join()
# join 阻塞在这里，直到我们得阻塞线程执行完毕才会向下执行
print("外", number)
print("stop")

就算单线程也会出现两个值：1000000 与 -1000000，两个函数谁先运行就是输出谁的结果，为什么呢？因为两个函数调用的是全局变量 number 所以，如果先运行加法函数，加法得到的结果是 1000000 ，那全局下的 number 的值也会变成：1000000 ，那减法的操作亦然就是 0。反过来也是一个意思。

import threading
import time

number = 0

def addNumber():
	global number
	for i in range(1000000):
		number += 1
	print("加",number)
	return number

def downNumber():
	global number
	for i in range(1000000):
		number -= 1
	print("减",number)
	return number

sum_num = downNumber() + addNumber()
print("Result", sum_num)

# 输出
减 -1000000
加 0
Result -1000000


# 修改以下代码，其他不变：
sum_num = addNumber() + downNumber()

# 输出
加 1000000
减 0
Result 1000000

由上面的多线程代码，我可以发现结果：两个线程操作同一个数字，最后得到的数字是混乱的。为什么说是混乱的呢？

我们现在所要做的是一个赋值，number += 1 其实也就是 number = number + 1，的这个操作。而在我们的 Python 当中，我们是先：计算右边的，然后赋值给左边的，一共两步。

我先来看一下正确的运行流程：

# 我们的 number = 0
# 第一步是先运行我们的代码：
a = number + 1 # 等价于 0+1=1 
# 也就是先运行右边的，然后赋值给 a

number = a # 然后，再把 a 的结果赋值个 number

# 上面运行完加法之后，我们加下来运行减肥的操作。
b = number - 1 # 等价于 1-1 = 0
# 然后，赋值个 number

# 最后 number 等于 0
number = 0

上面的过成是正确的流程，可在多线程里面呢？

number = 0 # 开始初始值 0
a = number+1 # 等价于 0+1=1
# 这个地方要注意！！！
# 在运行完上面一步的时候，还没来得急把结果赋值给 number
# 就开始运行减法操作：
b = number-1 # 等价于 0-1=-1
# 然后，这两个运行结束之后就被赋值：
number=b # b = -1
number=a # a = 1

# 最终得结果为：
number = 1

上面就是我们刚才结果错乱得原因，也就是说：我们计算和赋值是两部，但是该多线程它没有顺序执行，这也就是我们所说的线程不安全。

因为，执行太快了，两个线程交互交织在一起，最终得到我们这个错误结果。以上就是线程不安全的问题。

这就是需要 Lock 锁，给它上一把锁，来达到我们 number 的效果，这个时候为了避免错误，我们要给他上一把锁了。

import threading
import time

lock = threading.Lock() # 创建一个最简单的 读写锁
number = 0

def addNumber():
	global number
	for i in range(1000000):
		lock.acquire() # 先获取
		number += 1
		# 中间的这个过程让他强制有这个计算和赋值的过程，也就是让他执行完这两个操作，后再切换。
		# 这样就不会完成计算后，还没来的及赋值就跑到下一个去了。
		# 这样也就防止了线程不安全的情况
		lock.release() # 再释放

def downNumber():
	global number
	for i in range(1000000):
		lock.acquire()
		number -= 1
		lock.release()

print("start") # 输出一个开始
thread = threading.Thread(target = addNumber) #开启一个线程（声明）
thread2 = threading.Thread(target = downNumber) # 开启第二个线程（声明）
thread.start() # 开始
thread2.start() # 开始
thread.join()
thread2.join()
# join 阻塞在这里，直到我们得阻塞线程执行完毕才会向下执行
print("外", number)
print("stop")

# 输出
start
外 0
stop

在代码：lock.acquire() 与 lock.release() 中间的这个过程让它强制有这个计算和赋值的过程，也就是让他执行完这两个操作，后再切换。这样就不会完成计算后，还没来的及赋值就跑到下一个去了。这样也就防止了线程不安全的情况。

然后，就是我们第一个线程拿到这把锁的 lock.acquire() 了，那另一个线程就会在 lock.acquire() 阻塞了，直到我们另一个线程把 lock.release() 锁释放，然后拿到锁执行，就这样不断地切换拿锁执行。

**死锁：**就是前面的线程拿到锁之后，运行完却不释放锁，下一个线程在等待前一个线程释放锁，这种就是死锁。说的直白一点就是，相互等待。就像照镜子一样，你中有我，我中有你。也就是在没有 release 的这种情况。（你等我表白，我等你表白）

6. 递归锁 RLOCK

再次复用，一个锁可以再嵌套一个锁。向我们上面的普通锁，一个线程里面，你只能获取一次。如果获取第二次就会报错。

递归锁什么时候用呢？需要更低精度的，力度更小，为了更小的力度。

import threading
import time

class Test:
	rlock = threading.RLock()
	def __init__(self):
		self.number = 0

	def execute(self, n):
		# 原本是获取锁和释放锁，那如果有时候你忘记了写 lock.release() 那就变成了死锁。
		# 而 with 可以解决这个问题。
		with Test.rlock:
			# with 内部有个资源释放的机制
			self.number += n

	def add(self):
		with Test.rlock:
			self.execute(1)

	def down(self):
		with Test.rlock:
			self.execute(-1)

def add(test):
	for i in range(1000000):
		test.add()

def down(test):
	for i in range(1000000):
		test.down()
        
if __name__ == '__main__':
	thread = Test() # 实例化
	t1 = threading.Thread(target=add, args=(thread,))
	t2 = threading.Thread(target=down, args=(thread,))
	t1.start()
	t2.start()
	t1.join()
	t2.join()
	print(t.number)

我们会发现这个递归锁是比较耗费时间的，也就死我们获取锁与释放锁都是进行上下文切换导致资源消耗的，所以说开启的锁越多，所耗费的资源也就越多，程序的运行速度也就越慢。一些大的工程很少上这么多的锁，因为这个锁的速度会拖慢你整个程序的运行速度。所以得思考好，用不用这些东西。

7. 多进程

多线程在 IO 密集型用的比较多，也就是在爬虫方面用的比较多。而 CPU 密集型根本就不用多线程。

我们一般的策略是，多进程加多线程，这样的结合是最好。我需要用到这个库：

import multiprocessing

import multiprocessing
import time

def start(i):
	time.sleep(3)
	print(i)
	# current process
	# 当前进程
	print(multiprocessing.current_process().name) # 当前进程的名字
	print(multiprocessing.current_process().pid) # 进程控制符
	print(multiprocessing.current_process().is_alive()) # 判断进程是否存活
    # 因为，我们有些进程卡死，所以我就要自己把进程卡死

if __name__ == '__main__':
	print('start')
	p = multiprocessing.Process(target=start, args=(1,), name='p1')
	p.start()
	print('stop')

PID（进程控制符）英文全称为Process Identifier，它也属于电工电子类技术术语。

PID就是各进程的身份标识,程序一运行系统就会自动分配给进程一个独一无二的PID。进程中止后PID被系统回收，可能会被继续分配给新运行的程序。

PID一列代表了各进程的进程ID,也就是说,PID就是各进程的身份标识。

在实际调试中，只能先大致设定一个经验值，然后根据调节效果修改。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-BQOUtcxb-1583392394101)(08-多线程与多进程.assets/image-20200229140520623.png)]

8. 进程通信

Python 多进程之间是默认无法通信的，因为是并发执行的。所以需要借助其他数据结构。

举个例子：

你一个进程抓取到数据，要给另一个进程用，就需要进程通信。

队列：就像排队一样，先进先出。也就是你先放进去的数据，也就先取出数据。

栈：主要用在 C 和 C++ 上的数据结构。主要存储用户自定义的数据。它是后进先出。先进去的垫在底层，后进的在上面。

from multiprocessing import Process, Queue
# Process ：进程
# Queue ：队列
# import multiprocessing

def write(q):
	# multiprocessing.current_process().name
	# multiprocessing.current_process().pid
	# multiprocessing.current_process().is_alive()
	print("Process to write: {}" .format(Process.pid))
	for i in range(10):
		print("Put {} to queue...".format(i))
		q.put(i) # 把数字放到我们的队列里面去

def read(q):
	print("Process to read: {}" .format(Process.pid))
	while True:
		# 这里为什么要使用 while 呢？因为我们要不断的循环，队列当中有可能没有数据，所以需要一直循环获取。
		# 当然，你也可以直接指定循环的次数
		value = q.get() # 获取队列中的数据（队列中没有数据就会阻塞在那里）
		print("Get {} from queue." .format(value))

# 所以就有以下策略：一个线程抓取 url 放入队列之中，另一个队列解析
if __name__ == '__main__':
	# 父进程创建 Queue ，并传给各个子进程：
	q = Queue() # 队列
	pw = Process(target=write, args=(q, ))
	pr = Process(target=read, args=(q, ))
	# 启动子进程 pw ，写入：
	pw.start()
	# 启动子进程 pr， 读取：
	pr.start()
	# 等待 pw 结束
	pw.join()

举个实操的小例子：

from multiprocessing import Process, Queue
import requests
from lxml import etree
headers = {'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/80.0.3987.116 Safari/537.36'}
def spider_url(queue):
	session = requests.Session()
	session.headers = headers
	html = requests.get('https://www.baidu.com')
	xml = etree.HTML(html.text)
	url = xml.xpath("//div[@class="f-tag"]")
	queue.put(url)

def parse_url(queue):
	while True:
		value = queue.get()
		titl = value[0]

if __name__ == '__main__':
	queue = Queue()
	spider_url = Process(target=spider_url, args=(queue,))
	parse_url = Process(target=parse_url, args=(queue,))
	spider_url.start()
	parse_url.start()
	spider_url.join()
	parse_url.join()

9. 进程池与线程池

为什么需要进程池与线程池呢，我就用前面我们在进行上下文切换的时候会有资源消耗，而在这个基础上，创建线程与删除线程都是需要消耗更多的资源。而这个池就节省了资源消耗，这样我们就不用进行创建和销毁了，只要获取里面的使用即可。

9.1 进程池

第一种方法（多任务）：

from multiprocessing import Pool
def function_square(data):
	result = data*data
	return result

if __name__ == '__main__':
	inputs = [i for i in range(100)]
	# inputs = (i for i in range(100))
	# inputs = list(range(100))
	pool = Pool(processes=4) # 如果你不指定数目的化，它就会根据你电脑状态，自行创建。
	# 按你的电脑自动创建相应的数目
	# map 把任务交给进程池
	# pool.map(function, iterable)
	pool_outputs = pool.map(function_square, inputs)
	# pool_outputs = pool.map(function_square, (2,3, 4, 5))
	pool.close()
	pool.join()
	print("Pool     :", pool_outputs)

第二种方法（单任务）：

from multiprocessing import Pool
def function_square(data):
	result = data*data
	return result

if __name__ == '__main__':
	pool = Pool(processes=4) # 如果你不指定数目的化，它就会根据你电脑状态，自行创建。（按你的电脑自动创建相应的数目）
	# map 把任务交给进程池
	# pool.map(function, iterable)
	pool_outputs = pool.apply(function_square, args=(10, ))
	pool.close()
	pool.join()
	print("Pool     :", pool_outputs)

使用 from multiprocessing import Pool：引入进程池 ，那这个进程池，它是可以可以提供指定数量进程池，如果有新的请求提交到进程池，如果这个进程池还没有满的话，就创建新的进程来执行请求。 如果池满的话，就会先等待。

# 那么，我们可以首先声明这个进程池；
# 然后，使用 map 方法，那其实这个 map 方法和正常的 map 方法是一致的。
# map：
# pool = Pool()
# pool.map(main, [i*10 for i in range(10)])
# 第一个参数：他会将数组中的每一个元素拿出来，当作函数的一个个参数，然后创建一个个进程，放到进程池里面去运行。
# 第二个参数：构造一个数组，然后也就是 0 到 90 的这么一个循环，那我们直接使用 list 构造一下

9.3 实战（猫眼 TOP100 + re + multiprocessing）

# !/usr/bin/python3
# -*- coding: utf-8 -*-
# @Author：AI悦创 @DateTime ：2020/2/12 15:23 @Function ：功能  Development_tool ：PyCharm
# code is far away from bugs with the god animal protecting
#    I love animals. They taste delicious.
# https://maoyan.com/board/4?offset=0
# https://maoyan.com/board/4?offset=10
# https://maoyan.com/board/4?offset=20
# https://maoyan.com/board/4?offset=30
import requests,re,json
from requests.exceptions import RequestException
from multiprocessing import Pool # 引入进程池
headers = {
	'user-agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/80.0.3987.87 Safari/537.36'
}
session = requests.Session()
session.headers = headers

def get_one_page(url):
	try:
		response = session.get(url)
		if response.status_code == 200:
			return response.text
		return None
	except RequestException:
		return None
def parse_one_page(html):
	pattern = re.compile('<dd>.*?board-index.*?>(\d+)</i>.*?src="(.*?)".*?name.*?><a'
						 +'.*?>(.*?)</a>.*?star">(.*?)</p>.*?releasetime">(.*?)</p>.*?integer">'
						  +'(.*?)</i>.*?fraction">(.*?)</i>.*?</dd>', re.S)
	# 标签的开始和结尾都要写出来！！！
	items = re.findall(pattern, html)
	# 使用 yield 把这个方法变成一个生成器
	# 要把返回的结果做成一个键值对的形式
	for item in items:
		yield {
			'index': item[0],
			'image': item[1],
			'title': item[2],
			'actor': item[3].strip()[17:],
			'time': item[4][5:],
			'score': item[5]+item[6]
		}
def write_to_file(content):
	# print(type(content))
	# with open('result.txt', 'a') as f:
	with open('result.txt', 'a', encoding='utf-8') as f:
		# 字典转换成字符串
		# f.write(json.dumps(content) + '\n') # 中文编码变成 Unicode
		f.write(json.dumps(content, ensure_ascii=False) + '\n')
		f.close()

def main(offset):
	url = f'https://maoyan.com/board/4?offset={offset}'
	html = get_one_page(url)
	for item in parse_one_page(html):
		print(item)
		write_to_file(item)

# 1.0
# if __name__ == '__main__':
# 	for i in range(10): # range(0, 100, 10)
# 		main(i*10)
# 2.0
if __name__ == '__main__':
	pool = Pool()
	pool.map(main, [i*10 for i in range(10)])

# 优化，如果你要秒抓的话，使用 from multiprocessing import Pool # 引入进程池 ，当然我们目的不是秒抓，而是学习一下多进程的用法
# 那么这个进程池，他是可以可以提供指定数量进程池，如果有新的请求提交到进程池，如果这个进程池还没有满的话，就创建新的进程来执行请求。
# 如果池满的话，就会先等待
# 那么，我们可以首先声明这个进程池；
# 然后，使用 map 方法，那其实这个 map 方法和正常的 map 方法是一致的。
# map：
# pool = Pool()
# pool.map(main, [i*10 for i in range(10)])
# 第一个参数：他会将数组中的每一个元素拿出来，当作函数的一个个参数，然后创建一个个进程，放到进程池里面去运行。
# 第二个参数：构造一个数组，然后也就是 0 到 90 的这么一个循环，那我们直接使用 list 构造一下

9.2 线程池

我找了许多包，这个包还是不错的：Pip install threadpool

# project = 'Code', file_name = '线程池', author = 'AI悦创'
# time = '2020/3/3 0:05', product_name = PyCharm
# code is far away from bugs with the god animal protecting
#    I love animals. They taste delicious.

import time
import threadpool

# 执行比较耗时的函数，需要开多线程
def get_html(url):
	time.sleep(3)
	print(url)
# 按原本的单线程运行时间为：300s
# 而多线程池的化：30s
# 使用多线程执行 telent 函数
urls = [i for i in range(100)]
pool = threadpool.ThreadPool(10) # 建立线程池

# 提交任务给线程池
requests = threadpool.makeRequests(get_html, urls)

# 开始执行任务
for req in requests:
	pool.putRequest(req)
pool.wait()

作业

将你原先写过的任何一个爬虫程序改为多线程或者多进程。

 

标签：__,start,print,number,进程,线程,字长,多线程
来源： https://blog.51cto.com/u_13962552/2888007

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。