口令：RAPID708第12章 多线程和多进程了解多线程和多进程的含义和区别。掌握多进程的相关操作。掌握多线程的相关操作。程序只能从上到下，
逐行执行代码，多线程让程序拥有分身效果，能同时处理多件事情。多线程是加速程序运算的有效方法，在Python中多线程操作使用“thr
eading”模块。创建线程import threadingdef thread_job(): print(''当前线程个数：
%s''%threading.active_count()) print(''当前线程信息：%s''%threading.curr
ent_thread()) print(''所有线程信息：%s''%threading.enumerate())def init
(): thread = threading.Thread(target=thread_job) #定义线程 t
hread.start() #启动线程if __name__ == ''__main__'': init()多线程
操作时可能会遇到线程抢占的情况。import threadingimport timedef thread_job(): p
rint("T1 start\n") time.sleep(0.1) # 延时0.1s print("T1 fin
ish\n")added_thread = threading.Thread(target=thread_job, name=''T
1'')added_thread.start()print("all done\n")线程等待import threadingimp
ort timedef thread1_job(): print(''T1 start\n'') time.sle
ep(1) print(''T1 finish\n'')def thread2_job(): print(''T2 star
t\n'') print(''T2 finish\n'')def main(): thread1 = threading.T
hread(target=thread1_job, name=''T1'') thread2 = threading.Threa
d(target=thread2_job, name=''T2'') thread1.start() thread2.st
art() thread1.join() #等待线程T1执行完成后，才会继续运行 print(''all d
one\n'')if __name__ == ''__main__'': main()线程存储import threadingim
port timefrom queue import Queuedef job(l,q): for i in range (
len(l)): l[i] = l[i]2 q.put(l) #数据存储def init(): q
=Queue() threads = [] data = [[1,2,3],[4,5,6],[7,7,7],[8,8
,8]] for i in range(4): #创建4个线程 t = threading.Thre
ad(target=job,args=(data[i],q)) t.start() threads.a
ppend(t) for thread in threads: thread.join() result
s = [] for _ in range(4): results.append(q.get()) #获取数
据 print(results)if __name__==''__main__'': init()使用“join( )”方
法虽然在一定程度上加强了线程管理，但是线程运行效果依旧很混乱。import threadingdef job1(): glo
bal A for i in range(10): #全局变量A循环10次，每次循环加1 A+=1
print(''job1'',A)def job2(): global A for i in range(10
): #全局变量A循环10次，每次循环加10 A+=10 print(''job2'',A)if
__name__== ''__main__'': lock=threading.Lock() A=0 t1=thre
ading.Thread(target=job1) t2=threading.Thread(target=job2)
t1.start() t2.start() t1.join() t2.join()线程同步import thre
adingdef job1(): global A, lock lock.acquire() #内存上锁 fo
r i in range(10): A += 1 print(''job1'', A) lock.r
elease() #内存锁打开def job2(): global A, lock lock.acquire()
for i in range(10): A += 10 print(''job2'', A) l
ock.release()if __name__ == ''__main__'': lock = threading.Lock(
) #定义Lock( )对象 A = 0 t1 = threading.Thread(target=job1)
t2 = threading.Thread(target=job2) t1.start() t2.start()
t1.join() t2.join()多线程是有劣势的，“GIL”（全局解释器锁）让它没能更有效率的处理一些分摊的任务，
而现在的电脑大部分配备了多核处理器，多进程可以让电脑更有效率的分配任务给每一个处理器, 这种做法有效解决多线程的弊端。import
multiprocessing as mpdef job(): print(''job'')if __name__==''__m
ain__'': p1 = mp.Process(target=job) p1.start() p1.join()
import multiprocessing as mpdef job(q): res=0 for i in ran
ge(1000): res+=i+i2+i3 q.put(res) #将进程运行结果存放到队列中
if __name__==''__main__'': q = mp.Queue() p1 = mp.Process(tar
get=job,args=(q,)) #进程1 p2 = mp.Process(target=job,args=(q,)
) #进程2 p1.start() p2.start() p1.join() p2.join()
res1 = q.get() #从队列中取出数据 res2 = q.get() print(res1+res2)进
程存储进程池import multiprocessing as mpdef job(x): return xxdef in
it(): pool = mp.Pool() res = pool.map(job, range(10)) pr
int(res)if __name__ == ''__main__'': init()设置进程池CPU核数def init():
pool = mp.Pool(processes=3) #自定义CPU核数量为3 res = pool.ma
p(job, range(10)) print(res)进程池传单个参数def init(): pool = mp.P
ool() res = pool.map(job, range(10)) print(res) res = p
ool.apply_async(job, (2,)) print(res.get()) # 获得结果进程池传多个
参数def init(): pool = mp.Pool() res = pool.map(job, range(1
0)) print(res) res = pool.apply_async(job, (2,)) pri
nt(res.get()) # 获得结果 multi_res = [pool.apply_async(job,
(i,)) for i in range(10)] # 迭代器输入 print([res.get() for
res in multi_res]) #迭代输出进程同步import multiprocessing as mpimpo
rt timedef job(num1, num2): for _ in range(5): time.sle
ep(0.1) # 延时0.1S num1.value += num2 # v.value获取共享
变量值 print(num1.value, end="") def init(): num = mp.Valu
e(''i'', 0) #定义共享变量 p1 = mp.Process(target=job, args=(num,1))
#累加值1 p2 = mp.Process(target=job, args=(num,3)) #累加值3 p
1.start() p2.start() p1.join() p2.join()if __name__ == ''
__main__'': init()进程锁import multiprocessing as mpimport timedef
job(num1, num2, l): l.acquire() #内存锁住 for _ in range(5
): time.sleep(0.1) num1.value += num2 #获取共享内存
print(num1.value) l.release() #内存释放def init(): l = mp.Lock() #创建进程锁 num = mp.Value(''i'', 0) # 定义共享内存 p1 = mp.Process(target=job, args=(num,1,l)) # 将lock传入 p2 = mp.Process(target=job, args=(num,3,l)) p1.start() p2.start() p1.join() p2.join()if __name__ == ''__main__'': init()谢谢！ |
|
