并行编程——多线程

代码格式化的快捷键Ctrl + Alt + L
代码格式化的命令code -> Reformat Code
一、概述
（一）非并发
1、程序由单个步骤序列构成
2、包含独立子任务的程序执行性能低
（二）并发
1、异发、高效
2、分解子任务、简化流程与逻辑
（三）进程 process
1、一个程序的执行实例
2、每个进程有自己的地址空间、内存、数据栈及辅助数据
（四）线程 thread
1、同一进程内，可被并行激活的控制流
2、共享相同上下文（空间地址、数据结构）
3、特点
（1）便于信息共享和通信
（2）线程访问顺序差异会导致结果不一致（条件 race condition)
（五）Python GIL 全局解释器锁
1、Glogal Interpreter Lock
2、Python 代码由虚拟机（解释器主循环）控制
3、主循环同时只能有一个控制线程执行
二、多线程
（一）_thread 加下划线表示python已经不建议我们使用这个模块了
1、特点
（1）没有控制进程结束机制
（2）只有一个同步原语（锁）
（3）功能少于theading模块
2、 .start_new_thread(function,args,**kwargs=None)开始线程
args参数要以元组的方式来写
单线程示例：
import time
def worker(n):
print(‘函数执行开始于：{}’.format(time.ctime()))
time.sleep(n)
print(f’函数执行结束于：{time.ctime()}’)

def main():
print(f’【主函数执行开始于：{time.ctime()}】’)
worker(4)
worker(2)
print(f’【主函数执行结束于：{time.ctime()}】’)

if name == ‘main’:
main()

多线程_thread 示例：
import time
import _thread
def worker(n):
print(‘函数执行开始于：{}’.format(time.ctime()))
time.sleep(n)
print(f’函数执行结束于：{time.ctime()}’)

def main():
print(f’【主函数执行开始于：{time.ctime()}】’)
_thread.start_new_thread(worker,(4,))
_thread.start_new_thread(worker,(2,))

time.sleep(4)
print(f'【主函数执行结束于：{time.ctime()}】')

if name == ‘main’:
main()

（二）threading模块
1、 .Thread线程类
（1）构造
.Thread(target=目标函数,args=(参数,))
或者：
自定义Thread派生类，重写run方法逻辑
（2）启动线程
.start()
（3）要求主线程等待
.join()
（4）线程名称
.name

应用：
import time
import threading

def worker(n):
print(‘函数执行开始于：{}’.format(time.ctime()))
time.sleep(n)
print(f’函数执行结束于：{time.ctime()}’)

def testThread():
print(f’【主函数执行开始于：{time.ctime()}】’)

threads = []
t1 = threading.Thread(target=worker, args=(4,))
threads.append(t1)

t2 = threading.Thread(target=worker, args=(2,))
threads.append(t2)

for t in threads:
    t.start()

for t in threads:
    t.join()
    
print(f'【主函数执行结束于：{time.ctime()}】')

if name == ‘main’:
testThread()
2、 .current_thread() 获取当前线程
例如：
import time
import threading

def worker(n):
print(’{}函数执行开始于：{}’.format(threading.current_thread().name,time.ctime()))
time.sleep(n)
print(f’{threading.current_thread().name}函数执行结束于：{time.ctime()}’)

def testThread():
print(f’【主函数执行开始于：{time.ctime()}】’)

threads = []
t1 = threading.Thread(target=worker, args=(4,))
threads.append(t1)

t2 = threading.Thread(target=worker, args=(2,))
threads.append(t2)

for t in threads:
    t.start()

for t in threads:
    t.join()
print(f'【主函数执行结束于：{time.ctime()}】')

if name == ‘main’:
testThread()

派生类的应用：
import time
import threading

def worker(n):
print(’{}函数执行开始于：{}’.format(threading.current_thread().name,time.ctime()))
time.sleep(n)
print(f’{threading.current_thread().name}函数执行结束于：{time.ctime()}’)

class MyThread(threading.Thread):
def init(self,func,args):
threading.Thread.init(self)
self.func = func
self.args = args
def run(self):
self.func(*self.args)

def testThread():
print(f’【主函数执行开始于：{time.ctime()}】’)

threads = []
t1 = myThread(worker,(4,))
threads.append(t1)

t2 = myThread(worker, (2,))
threads.append(t2)

for t in threads:
    t.start()

for t in threads:
    t.join()

print(f'【主函数执行结束于：{time.ctime()}】')

if name == ‘main’:
testThread()
3、同步原语：锁 threading.Lock
（1）.acquire() 获得
（2）.release() 释放
（3）支持上下文操作 with lock:
例如：
import threading
import time
import random
eggs = []
lock = threading.Lock()
def put_egg(n,lst):
# lock.acquire() #锁上
with lock:
for i in range(1,n+1):
time.sleep(random.randint(0,2))
lst.append(i)
# lock.release() #解锁

def major():
threads = []

for i in range(3):
    t = threading.Thread(target=put_egg,args=(5,eggs))
    threads.append(t)

for t in threads:
    t.start()

for t in threads:
    t.join()

print(eggs)

if name ==‘main’:
major()