python線程與進程

標籤：守護線程   資料互動   embed   運行   header   llb   can   tom   ict   

python線程與進程（process)

進程：資源的集合，本身不執行
線程：一串指令

線程共用記憶體，進程獨立記憶體，進程啟動慢，線程啟動快，線程之間資料可以交流，進程之間資料不可以交流。

守護進程

正常情況主線程與子線程沒有依賴關係，程式執行，你走我也走。子子線程裡使用join方法，使主線程等待子線程執行完畢後才執行。子線程設定setDaemon(True)把當前線程設定成守護線程，該線程就不重要了，一定在start之前設定。 python解譯器同一時段只允許存取一個線程

GIL鎖(全域解譯器鎖)

解譯器出口控制，同一時間只有一個線程可以工作。其餘線程等著。啟動的線程實實在在在CPU上了，但同一時間只有一個線程可以拿到資料。全域解譯器鎖。

線程鎖（互斥鎖）

threading.Lock() lock.acquire() lock.release()

遞迴鎖

threading.RLock() 多個門被鎖，鑰匙識別不出哪個對應的門

semaphore(訊號量)

semaphore=threading.BoundedSemaphore(5)#最多允許5個線程同時運行
semaphore.acquire() lock.release() 控制同一時刻允許有多少個線程可以執行，執行個體，線程池，進程池

Event

event=threading.Event()
event.wait()
event.set()
event.clear()
 author = ‘Mr.Bool‘
 import time
 import threading
 event=threading.Event()
 def lighter():
 count=0
 event.set()
 while True:
 if count>5 and count<10:
 event.clear()#變紅燈
 print("紅燈")
 elif count>10:
 event.set()#變綠燈
 print("變綠燈")
 count=0
 else:
 print("現在是綠燈")
 time.sleep(1)
 count+=1

        def car(name):
    while True:
        if event.is_set():
            print("%s 可以通行"%name)
        else:
            print("%s 不可通行"%name)
            event.wait()
        time.sleep(1)
t1=threading.Thread(target=lighter)
t1.start()
t2=threading.Thread(target=car,args=(‘Benz‘,))
t2.start()  

隊列

優點：解耦高效
queue.Queue()先進先出
queue.LifoQueue()後進先出買水果
queue.PriorityQueue()儲存資料時可以設定優先權
put(位置，資料)#put(1，‘wj‘)放置資料在第一位

    author = ‘Mr.Bool‘
    import queue
    import time
    import threading
    q=queue.Queue()
    def Proceder():
        count =0
        while True:
            q.put("骨頭%s"%count)
            print("生產了骨頭%s"%count)
            count+=1
            time.sleep(1)
    def eat(name):
        while True:
            g=q.get()
            print("%s ear %s"%(name,g))
            time.sleep(0.3)

p=threading.Thread(target=Proceder)
p.start()
d1=threading.Thread(target=eat,args=(‘wangwang‘,))
d1.start()
d2=threading.Thread(target=eat,args=(‘wangcai‘,))
d2.start()  

多進程

import multiprocessing
在multiprocessing裡存在Process，Pool,Queue,Pipe,Manager
Process啟動進程
Pool建立進程池使用Pool時一定先close()，後join()
Queue資料互動
Pipe管道資料互動
Manager資料互動共用，可建立dict，list等進行共用使用執行個體：
1. process

import multiprocessing
import time,threading
import os
def threadingrun(name):
    # print("%s is a big man"%name)
    pass
def run(name):
    print("now pid:%s"%os.getpid())
    print("parent pid:%s"%os.getppid())
    t=threading.Thread(target=threadingrun,args=(name,))
    t.start()
if __name__ == ‘__main__‘:
    for i in range(10):
        p1=multiprocessing.Process(target=run,args=("wj",))
        p1.start()  

1. poll

   from multiprocessing import Pool
   import os
   import time
   def processingtest(s):
       time.sleep(2)
       print("in process",os.getpid())
       return s+100
   def Bar(arg):
       print(‘-->exec done:‘,arg,os.getpid())
       pass
   if name=="_main":
    pool=Pool(3)
    print("主進程")
    for i in range(10):
    pool.applyasync(func=processingtest,args=(i,),callback=Bar)
       print(‘end‘)
       pool.close()
       pool.join()  
   

2. Queue:
   

   from multiprocessing import Process,Queue,Pipe,Manager
   def processingtest(s):
       s.put([32,‘hello‘])
       print(‘子進程‘,s.get())
   
   if name=="__main":
    parentpipe,childpipe=Pipe()
    q=Queue()
    p=Process(target=processingtest,args=(q,))
    p.start()
    print(‘父進程‘,q.get()) 
   

3. Pipe:
   

   from multiprocessing import Process,Queue,Pipe,Manager
   def processingtest(childpipe):
    childpipe.send("hello parent")
       print(childpipe.recv())
   if name=="main":
    parentpipe,childpipe=Pipe()
    p=Process(target=processingtest,args=(childpipe,))
       p.start()
       print(parentpipe.recv())
    parentpipe.send("hello son")   
    

4. Manager:
   

   from multiprocessing import Process,Manager
   import os
   def processingtest(d,l):
       d[os.getpid()]=os.getpid()
       l.append(os.getpid())
       pass
   if name=="_main": with Manager() as manager:
    d=manager.dict()
    l=manager.list()
    objlist=[]
    for i in range(10):
    p=Process(target=processingtest,args=(d,l))
    p.start()
    objlist.append(p)
    for i in range(10):
    objlist[i].join()
           print(d)
           print(l)  
   

python線程與進程