python线程与进程

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)