1. 概念：简单地说，就是同时可以运行多个任务
2.并发：指的是任务数多余cpu核数，通过操作系统的各种任务调度算法，实现用多个任务“一起”执行（实际上总有一些任务不在执行，因为切换任务的速度相当快，看上去一起执行而已）
3.并行：指的是任务数小于等于cpu核数，即任务真的是一起执行的
4.真正的"并行"只能在多核CPU上实现，现实中由于任务数量远远多于CPU的核心数量，所以基本上都是“并发”。 操作系统会自动把很多任务轮流调度到每个核心上执行。
1.线程是一个抽象的概念，可以把它想象成程序在执行代码时的那个执行流
2.通过线程实现多任务
在Python中如果想使用线程实现多任务，可以使用thread模块 但是它比较底层，即意味着过程较为复杂不方便使用；推荐使用threading模块，它是对thread做了一些包装的，可以更加方便使用
3.. 使用threading模块
1)单线程的执行
import time
def say_sorry():
print("亲爱的，我错了，我能吃饭了吗？")
time.sleep(1)
for i in range(5):
say_sorry()
2）多线程执行
import threading
import time
def say_sorry():
print("亲爱的，我错了，我能吃饭了吗？")
time.sleep(1)
for i in range(5):
t = threading.Thread(target=say_sorry)
t.start() # 启动线程，即让线程开始执行
由此总结：
可以明显看出使用了多线程并发的操作，花费时间要短很多
当调用start()时，才会真正的创建线程，并且开始执行
4.. 同时执行多个不同的任务
import threading
from time import sleep, ctime
def sing():
for i in range(3):
print("正在唱歌...%d" % i)
sleep(1)
def dance():
for i in range(3):
print("正在跳舞...%d" % i)
sleep(1)
print('---开始---:%s' % ctime())
t1 = threading.Thread(target=sing)
t2 = threading.Thread(target=dance)
t1.start()
t2.start()
#sleep(5) # 屏蔽此行代码，试试看，程序是否会立马结束？
print('---结束---:%s' % ctime())
import threading
from time import sleep,ctime
def sing():
for i in range(3):
print("正在唱歌...%d" % i)
sleep(1)
def dance():
for i in range(3):
print("正在跳舞...%d" % i)
sleep(1)
print('---开始---:%s' % ctime())
t1 = threading.Thread(target=sing)
t2 = threading.Thread(target=dance)
t1.start()
t2.start()
while True:
# threading.enumerate()能够得到当前这个程序中正在运行的所有任务，是一个列表
length = len(threading.enumerate())
print('当前运行的线程数为：%d' % length)
if length <= 1:
break
# 延时一会，等等其他线程执行
sleep(0.5)
同时指定多个不同任务的代码编写流程
如果在一个程序中需要有多个任务一起执行，可以将每个任务单独放到一个函数中
使用threading.Thread创建一个对象，注意实参target需要指定为刚刚定义的函数名（不要写上小括号，那表示调用函数了）
调用threading.Thread返回的对象中的start方法（会让这个线程开始运行）
注意：主线程会等待所有的子线程结束后才结束
5.多线程执行的顺序不确定
import threading
from time import sleep, ctime
def test1():
"""
这是一个单独的任务
"""
for i in range(10):
print("任务1...%d" % i)
sleep(0.1)
def test2():
"""
这是另外一个单独的任务
"""
for i in range(5):
print("任务2...%d" % i)
sleep(0.2)
t1 = threading.Thread(target=test1)
t2 = threading.Thread(target=test2)
t1.start()
t2.start()
总结：
使用threading.enumerate()能够得到当前程序在运行时，所有的线程信息，以列表的方式返回
我们可以让主线程(程序运行后的默认线程)，判断threading.enumerate()返回的线程数量，如果只有1个线程，那么就表示当前主线程自己，意味着没有其他的子线程(使用threading创建的那些线程)，此时就可以结束主线程，只要主线程结束 那么这个程序也就结束了
1. 为什么要用队列
任务程序，有很多时候，需要相互配合才能完成一件有意义的事情，例如：
一个线程专门用来接收数据
另外一个线程专门用来存储刚刚接收的数据
如果需要将以上2个线程相互配合那么理论上来说，效率会很高。但是线程中的变量各自是各自的，为了能够让多个线程之间共享某些数据，就可以使用队列来实现数据共享
2. 什么是队列
一种特殊的存储数据的方式，可以实现先存入的数据，先出去。、
3.队列的使用
import queue
q = queue.Queue()
q.put('11') # 存入字符串
q.put(22) # 存入整数
q.put({'num': 100}) # 存入字典
print(q.get()) # 11
print(q.get()) # 22
print(q.get()) # {'num': 100}
小结：
先进先出（FIFO）
可以存放任意类型数据
4. 堆栈Queue
import queue
q = queue.LifoQueue()
q.put('11') # 存入字符串
q.put(22) # 存入整数
q.put({'num': 100}) # 存入字典
print(q.get()) # {'num': 100}
print(q.get()) # 22
print(q.get()) # 11
小结
后进先出（LIFO）
可以存放任意数据类型
5. 优先级Queue
import queue
q = queue.PriorityQueue()
q.put((10, 'Q'))
q.put((30, 'Z'))
q.put((20, 'A'))
print(q.get()) # (10, 'Q')
print(q.get()) # (20, 'A')
print(q.get()) # (30, 'Z')
小结
存放的数据是元组类型，第1个元素表示优先级，第2个元素表示存储的数据
优先级数字越小优先级越高
数据优先级高的优先被取出
用于VIP用户数据优先被取出场景，因为上面两种都要挨个取出
fom threading import Thread
import time
g_num = 100
def work1():
global g_num
for i in range(3):
g_num += 1
print("----in work1, g_num is %d---" % g_num)
def work2():
global g_num
print("----in work2, g_num is %d---" % g_num)
print("---线程创建之前g_num is %d---" % g_num)
t1 = Thread(target=work1)
t1.start()
#延时一会，保证t1线程中的事情做完
time.sleep(1)
t2 = Thread(target=work2)
t2.start()
运行结果:
---线程创建之前g_num is 100---
----in work1, g_num is 103---
----in work2, g_num is 103---
小结：
在一个进程内的所有线程共享全局变量，很方便在多个线程间共享数据
缺点是：线程是对全局变量随意遂改可能造成多线程之间对全局变量的混乱（即线程非安全）
import threading
import time
g_num = 0
def work1(num):
global g_num
for i in range(num):
g_num += 1
print("----in work1, g_num is %d---"%g_num)
def work2(num):
global g_num
for i in range(num):
g_num += 1
print("----in work2, g_num is %d---"%g_num)
print("---线程创建之前g_num is %d---"%g_num)
t1 = threading.Thread(target=work1, args=(100,))
t1.start()
t2 = threading.Thread(target=work2, args=(100,))
t2.start()
while len(threading.enumerate()) != 1:
time.sleep(1)
print("2个线程对同一个全局变量操作之后的最终结果是:%s" % g_num)
运行结果：
---线程创建之前g_num is 0---
----in work1, g_num is 100---
----in work2, g_num is 200---
2个线程对同一个全局变量操作之后的最终结果是:200
总结：
如果多个线程同时对同一个全局变量操作，会出现资源竞争问题，从而数据结果会不正确
1.为什么要用互斥锁
当多个线程几乎同时修改某一个共享数据的时候，需要进行同步控制
线程同步能够保证多个线程安全访问竞争资源，最简单的同步机制是引入互斥锁。
2.互斥锁的作用
互斥锁为资源引入一个状态：锁定/非锁定
某个线程要更改共享数据时，先将其锁定，此时资源的状态为“锁定”，其他线程不能更改；直到该线程释放资源，将资源的状态变成“非锁定”，其他的线程才能再次锁定该资源。互斥锁保证了每次只有一个线程进行写入操作，从而保证了多线程情况下数据的正确性。
3.. 使用互斥锁
threading模块中定义了Lock类，可以方便的使用
# 创建锁
mutex = threading.Lock()
# 锁定
mutex.acquire()
# 释放
mutex.release()
注意：
如果这个锁之前是没有上锁的，那么acquire不会堵塞（堵塞：理解为程序卡在这里等待某个条件满足）
如果在调用acquire对这个锁上锁之前 它已经被 其他线程上了锁，那么此时acquire会堵塞，直到这个锁被解锁为止
4. 上锁解锁过程（了解）
每一个锁都有状态，当一个线程调用锁的acquire()方法获得锁时，锁就进入“locked”状态。
每次只有一个线程可以获得锁。如果此时另一个线程试图获得这个锁，该线程就会变为“blocked”状态，称为“阻塞”，直到拥有锁的线程调用锁的release()方法释放锁之后，即这个锁进入“unlocked”状态后，才能获取到这个锁
线程调度程序从处于同步阻塞状态的线程中选择一个来获得锁，并使得该线程进入运行（running）状态。
5.总结
阻止了多线程并发执行，包含锁的某段代码实际上只能以单线程模式执行，效率就大大地下降了
由于可以存在多个锁，不同的线程持有不同的锁，并试图获取对方持有的锁时，可能会造成死锁
一个程序运行起来后，代码+用到的资源 称之为进程，它是操作系统分配资源的基本单元。
在python中使用使用进程实现多任务的方式有3种：
创建Process对象
基础Process类，创建自己的对象，实现run翻番
使用进程池
1.创建进程的方式1
from multiprocessing import Process
import time
def test():
"""子进程单独执行的代码"""
while True:
print('---test---')
time.sleep(1)
if __name__ == '__main__':
p=Process(target=test)
p.start()
# 主进程单独执行的代码
while True:
print('---main---')
time.sleep(1)
小结：
.通过额外创建一个进程，可以实现多任务
使用进程实现多任务的流程：
创建一个Process对象，且在创建时通过target指定一个函数的引用
当调用start时，会真正的创建一个子进程
2. 进程PID(进程号)
from multiprocessing import Process
import os
import time
def run_proc():
"""子进程要执行的代码"""
print('子进程运行中，pid=%d...' % os.getpid()) # os.getpid获取当前进程的进程号
print('子进程将要结束...')
if __name__ == '__main__':
print('父进程pid: %d' % os.getpid()) # os.getpid获取当前进程的进程号
p = Process(target=run_proc)
p.start()
小结
每个进程都有1个数字来标记，这个数字称之为进程号
Linux系统中查看PID的命令是ps
可以通过Linux命令kill pid的方式结束一个进程，如果进程结束了，就表示这个程序运行结束
3.Process创建的实例对象的常用方法
start()：启动子进程实例（创建子进程）
is_alive()：判断子进程是否还在活着
join([timeout])：是否等待子进程执行结束，或等待多少秒
terminate()：不管任务是否完成，立即终止子进程
4.创建进程的方式二：
from multiprocessing import Process
import time
class MyNewProcess(Process):
def run(self):
while True:
print('---1---')
time.sleep(1)
if __name__=='__mian__':
p = MyNewProcess()
# 调用p.start()方法，p会先去父类中寻找start()，然后在Process的start方法中调用run方法
p.start()
while True:
print('---Main---')
time.sleep(1)
5..小结
此种创建多进程的流程
自定义一个类，继承Process类
实现run方法
通过自定义的类，创建实例对象
调用实例对象的start方法
对比
自定义继承Process类的方式比 直接创建Process对象 要稍微复杂一些，但是可以用来实现更多较为复杂逻辑的功能
建议
如果想快速的实现一个进程，功能较为简单的话，可以直接创建Process的实例对象
如果想实现一个功能较为完整、逻辑较为复杂的进程，可以自定义继承Process类 来实现
6.线程共享全局变量
import threading
import time
nums = []
def task1():
for i in range(3):
nums.append(i)
print("task1 中 nums:", nums)
print("task1 即将结束")
def task2():
print("task2 中 nums:", nums)
print("task2 即将结束")
t1 = threading.Thread(target=task1)
t2 = threading.Thread(target=task2)
t1.start()
time.sleep(2)
t2.start()
7.进程不共享全局变量
from multiprocessing import Process
import os
import time
nums = [11, 22]
def work1():
"""子进程要执行的代码"""
print("in process1 pid=%d ,nums=%s" % (os.getpid(), nums))
for i in range(3):
nums.append(i)
time.sleep(1)
print("in process1 pid=%d ,nums=%s" % (os.getpid(), nums))
def work2():
"""子进程要执行的代码"""
print("in process2 pid=%d ,nums=%s" % (os.getpid(), nums))
if __name__ == '__main__':
p1 = Process(target=work1)
p1.start()
time.sleep(2)
p2 = Process(target=work2)
p2.start()
说明
使用Queue()时，若括号中没有指定最大可接收的消息数量，或数量为负值，那么就代表可接受的消息数量没有上限（直到内存的尽头）
Queue的几个方法功能说明：
Queue.qsize()：返回当前队列包含的消息数量
Queue.empty()：如果队列为空，返回True，反之False
Queue.full()：如果队列满了，返回True,反之False
Queue.get([block[, timeout]])：获取队列中的一条消息，然后将其从列队中移除，block默认值为True
如果block使用默认值，且没有设置timeout（单位秒），消息列队如果为空，此时程序将被阻塞（停在读取状态），直到从消息列队读到消息为止，如果设置了timeout，则会等待timeout秒，若还没读取到任何消息，则抛出Queue.Empty异常
如果block值为False，消息列队如果为空，则会立刻抛出Queue.Empty异常
Queue.get_nowait()：相当Queue.get(False)
Queue.put(item,[block[, timeout]])：将item消息写入队列，block默认值为True
如果block使用默认值，且没有设置timeout（单位秒），消息列队如果已经没有空间可写入，此时程序将被阻塞（停在写入状态），直到从消息列队腾出空间为止，如果设置了timeout，则会等待timeout秒，若还没空间，则抛出Queue.Full异常
如果block值为False，消息列队如果没有空间可写入，则会立刻抛出Queue.Full异常
Queue.put_nowait(item)：相当Queue.put(item, False)
8.程间的通信-Queue
我们以Queue为例，在父进程中创建两个子进程，一个往Queue里写数据，一个从Queue里读数据：
from multiprocessing import Process, Queue
import time, random
# 写数据进程执行的代码:
def task1(q):
for value in ['A', 'B', 'C']:
print('Put %s to queue...' % value)
q.put(value)
time.sleep(random.random())
# 读数据进程执行的代码:
def task2(q):
while True:
if not q.empty():
value = q.get(True)
print('Get %s from queue.' % value)
time.sleep(random.random())
else:
break
if __name__=='__main__':
# 父进程创建Queue，并传给各个子进程：
q = Queue()
write_p = Process(target=task1, args=(q,))
read_p = Process(target=task2, args=(q,))
# 启动子进程pw，写入:
write_p.start()
# 等待pw结束:
write_p.join()
# 启动子进程pr，读取:
read_p.start()
read_p.join()
# pr进程里是死循环，无法等待其结束，只能强行终止:
print('')
print('所有数据都写入并且读完')
总结：
通过使用Queue能够将2个互不相干的进程，能够共享数据，从而能够将一个较大的程序分成多个子功能来实现，每个子功能单独为一个进程，即使其中一个进程因为特殊情况挂掉了，也不会影响整个程序的运行
9.创建进程方式3-进程池
初始化Pool时，可以指定一个最大进程数，当有新的请求提交到Pool中时，如果池还没有满，那么就会创建一个新的进程用来执行该请求；但如果池中的进程数已经达到指定的最大值，那么该请求就会等待，直到池中有进程结束，才会用之前的进程来执行新的任务
from multiprocessing import Pool
import os
import random
import time
def worker(num):
for i in range(5):
print('===pid=%d==num=%d='%(os.getpid(),num))
time.sleep(1)
# 3表示进程池中最多有三个进程一起执行
pool=Pool(3)
for i in range(10):
print('---%d---'%i)
# 向进程中添加任务
# 注意：如果添加的任务数量超过了进程池中进程的个数的话，那么就不会接着往进程池中添加，
# 如果还没有执行的话，他会等待前面的进程结束，然后在往
# 进程池中添加新进程
pool.apply_async(worker,(i,))
pool.close() # 关闭进程池
pool.join() # 主进程在这里等待，只有子进程全部结束之后，在会开启主线程
apply_async(func[, args[, kwds]])：使用非阻塞方式调用func（并行执行，堵塞方式必须等待上一个进程退出才能执行下一个进程），args为传递给func的参数列表，kwds为传递给func的关键字参数列表；
close()：关闭Pool，使其不再接受新的任务；
terminate()：不管任务是否完成，立即终止；
join()：主进程阻塞，等待子进程的退出， 必须在close或terminate之后使用；
10进程池中的Queue
进程池中使用队列multiprocessing.Manager().Queue()
# 修改import中的Queue为Manager
from multiprocessing import Manager,Pool
import os,time,random
def reader(q):
print("reader启动(%s),父进程为(%s)" % (os.getpid(), os.getppid()))
for i in range(q.qsize()):
print("reader从Queue获取到消息：%s" % q.get(True))
def writer(q):
print("writer启动(%s),父进程为(%s)" % (os.getpid(), os.getppid()))
for i in "itcast":
q.put(i)
if __name__=="__main__":
print("(%s) start" % os.getpid())
q = Manager().Queue() # 使用Manager中的Queue
po = Pool()
po.apply_async(writer, (q,))
time.sleep(1) # 先让上面的任务向Queue存入数据，然后再让下面的任务开始从中取数据
po.apply_async(reader, (q,))
po.close()
po.join()
print("(%s) End" % os.getpid())
运行结果:
(11095) start
writer启动(11097),父进程为(11095)
reader启动(11098),父进程为(11095)
reader从Queue获取到消息：i
reader从Queue获取到消息：t
reader从Queue获取到消息：c
reader从Queue获取到消息：a
reader从Queue获取到消息：s
reader从Queue获取到消息：t
(11095) End
1. 通俗理解进程、线程
进程，能够完成多任务，比如 在一台电脑上能够同时运行多个QQ
线程，能够完成多任务，比如 一个QQ中的多个聊天窗口
2.定义：
进程：进程是系统进行资源分配和调度的一个独立单位
线程：线程是进程的一个实体，是CPU调度和分派的基本单位,它是比进程更小的能独立运行的基本单位.线程自己基本上不拥有系统资源,只拥有一点在运行中必不可少的资源(如程序计数器,一组寄存器和栈),但是它可与同属一个进程的其他的线程共享进程所拥有的全部资源.
3.区别
一个程序至少有一个进程,一个进程至少有一个线程.
线程的划分尺度小于进程(资源比进程少)，使得多线程程序的并发性高。
进程在执行过程中拥有独立的内存单元，而多个线程共享内存，从而极大地提高了程序的运行效率
4.优缺点
线程和进程在使用上各有优缺点：线程执行开销小，但不利于资源的管理和保护；而进程正相反。
协程，又称微线程，纤程。英文名Coroutine。协程，利用线程在等待某个资源的期间执行其他函数，切换资源消耗非常小，协程效率相当快。
进程是资源分配的单位，真正执行代码的是线程，操作系统真正调度的是线程。
进程没有线程效率高，进程占用资源多，线程占用资源少，比线程更少的是协程。
协程依赖于线程、线程依赖于进程，进程一死线程必挂，线程一挂协程必死
一般不用多进程，可以考虑使用多线程，如果多线程里面有很多网络请求，网络可能会有堵塞，此时用协程比较合适。
线程：t1 = threading.Thread(target=func_name, args=(num,), name=”子线程名字”)
互斥锁：Mutex = threading.Lock()
进程： P = Multiprocessing.Process(target=func_name[,args=(元组), kwargs={字典}])
定义进程池，最大进程池最大数 Po = Pool(3)
通过Queue实现进程间通信：
Q = multiprocessing.Queue(3) # 3代表队列中最多可以接收三条消息：如果是通过进程池创建的进程，那么队列的使用要用 multiprocessing.Manager().Queue()的方式，否则会报错
扫一扫
2176
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
