多线程
目前市面上常见的系统，如windows、mac os、Linux都支持多线程
什么是多任务
操作系统同时执行多个任务
单核CPU如何实现多任务？
表面看，每个任务都是同时执行，实际上每个任务都在轮询着执行；
只是因为CPU调度和执行速度太快，导致我们感觉是所有任务都在同时执行
多核CPU如何实现多任务？
当任务数小于CPU核心数时，是真正的多任务
当任务数大于CPU核心数时，多余的任务会再次被分配，分配到的CPU进行轮询执行
并发与并行
并发：表面看时一起执行，但是任务数多余CPU核心数
并行：一起执行，但是任务数小于CPU数
实现多任务的方式
1.多进程方式 多操作系统而言，一个任务就是一个进程
2.多线程方式
3.协程方式
4.多进程+多线程方式
python中的多进程
multiprocessing 多进程
from multiprocessing import Process
import time
def func():
while True:
print("这也是一个python进程")
time.sleep(1.5)
if __name__ == '__main__':
print("父进程启动...")
p = Process(target=func)
p.start()
while True:
print("这是一个python进程")
time.sleep(1)
带有参数的多进程
from multiprocessing import Process
import time
def func(str):
while True:
print("这也是一个%s进程"%str)
time.sleep(1.5)
if __name__ == '__main__':
print("父进程启动...")
p = Process(target=func, args=("python",))
p.start()
while True:
print("这是一个python进程")
time.sleep(1)
多进程中的变量
.join() 表示父进程等待子进程结束再继续执行
每个进程都有自己的一套代码段、数据段和堆栈段，互不干扰；
也就是说父进程中的全局变量会在子进程创建时备份一份，
如果在子进程中进行更改不会影响父进程中的变量；
同样如果父进程在创建了子进程后再对全局变量进行修改，同样不会对子进程的变量造成影响
Pocess中传递参数必须为可迭代对象
from multiprocessing import Process
import time
num = 100
def func(num):
print("子进程启动...")
time.sleep(1)
num += 1
print(num)
print("子进程结束...")
if __name__ == '__main__':
print("父进程启动...")
p = Process(target=func, args=(num,))
# 此时子进程已创建，再修改父进程中的全局变量将不会影响子进程
num += 2
p.start()
print("父进程结束...%d" % num)
进程池
1.进程池需要导入 multiprocessing 中的Pool
2.创建进程池时Pool()中的参数表示同时启动的进程数
如果不写则表示本机的逻辑核心数
3.进程池中进程启动不用写 start 语句
4.进程池必须先关闭才能join
5.进程池join后，父进程会等待池内所有进程执行完毕再向下执行
6.进程池内的进程启动顺序由操作系统来决定
from multiprocessing import Pool
import time, random
def func(num):
print("子进程%d启动" % num)
start = time.time()
time.sleep(random.choice([1, 2, 3]))
end = time.time()
print("子进程%d结束，耗时%d秒" % (num, end-start))
def func1():
print("我是一个子进程，我负责计算1+1=2")
if __name__ == '__main__':
print("父进程启动")
# Pool中的参数表示同时启动进程的数量，如果不写则表示本机逻辑核心数
# 进程池中的进程启动顺序由系统来决定
pp = Pool(2)
# # 此处为用for循环建立多个子进程，但是子进程的功能都相同
# for i in range(10):
# pp.apply_async(func, args=(i,))
# 此处为单个建立子进程，子进程的功能可以不同
pp.apply_async(func, args=(1,))
pp.apply_async(func1)
# 进程池中进程不需要写start语句
# 进程池进行join时必须先关闭
pp.close()
# 进程池join后父进程会等待进程池中所有程序结束才继续执行
pp.join()
print("父进程结束")
多线程混乱
多个线程对同一数据进行更改时，次数越大，发生错误或线程混乱的几率越大
import threading
num = 0
def run(n):
global num
for i in range(1000000):
num = num + n
num = num - n
# print(num)
if __name__ == '__main__':
t1 = threading.Thread(target=run, args=(6,))
t2 = threading.Thread(target=run, args=(9,))
t1.start()
t2.start()
t1.join()
t2.join()
print("num = ",num)
锁对象
为了确保一段代码只能由一个线程从头到尾的完整执行
我们引入了锁对象，来限制进行的并发执行,避免多线程并发引起的数据混乱
但是会大大的降低效率
import threading
# 所对象
lock = threading.Lock()
num = 0
def run(n):
global num
for i in range(1000000):
"""
# 第一种写法
# 加锁
lock.acquire()
num += n
num -= n
# 解锁
lock.release()
"""
# 第二种写法
with lock:
num += n
num -= n
if __name__ == '__main__':
t1 = threading.Thread(target=run, args=(10,))
t2 = threading.Thread(target=run, args=(4,))
t1.start()
t2.start()
t1.join()
t2.join()
print("num =", num)
信号量：Semaphore
限定多线程并发数量
线程结束数量：Barrier
限定多线程的结束数量，如果数量不足，则等待，
直到数量满足要求再结束
如果二者同时使用，注意并发数量应大于结束数量
否则线程无法结束，无法继续并发，程序会一直处于等待中
import threading,time
# 设置多线程并发数量
sem = threading.Semaphore(4)
# 设置指定数量结束
bar = threading.Barrier(3)
def run():
with sem:
print("%s--start"%threading.current_thread().name)
time.sleep(1)
bar.wait()
print("%s--end"%threading.current_thread().name)
if __name__ == '__main__':
for i in range(10):
t = threading.Thread(target=run)
t.start()