day 30守护进程的与应用，线程

一守护进程与应用

import time,random

from multiprocessing import Process,JoinableQueue

def consumer(name,q):

　　while True:

　　　　res=q.get()

　　　　if res is None:break

　　　　time.sleep(random.randint(1,3))

　　　　print('%s 吃了%s'%(name,res))

　　　　q.task_done()

def producer(name,q,food):

　　for i in range(5):

　　　　time.sleep(random.randint(1,2))

　　　　res='%s%s'%(food,i)

　　　　q.put(res)

　　　　print('%s 生产了%s'%(name,res))

if __name__=='__main__':

　　q=JoinableQueue()

　　p1=Process(target=producer,args=('aa',q,'包子'))

　　p2=Process(target=producer,args=('aa',q,'包子'))

　　c1=Process(target=consumer,args=('alex',q))

　　c2=Process(target=consumer,args=('bb',q))

　　c1.daemon=True

　　c2.daemon=True

　　p1.start()

　　p2.start()

　　p3.start()

　　c1.start()

　　c2.start()

　　#确定生产者确实已经生产完毕

　　p1.join()

　　p2.join()

　　p3.join()

　　#在生产者生产完毕后，拿 到队列中元素的总个数，然后直到元素总数为0，q.join()这一行代码才算运行

　　q.join()

　　#q.join()一旦结束就意味着队列确实被取空，消费者已经确确实实把数据都取干净了

　　print('主进程结束')

二、线程

1、什么是线程

　　线程指的是一条流水线的工作过程

　　进程根本就不是一个执行单位，进程其实是一个资源单位

　　一个进程内自带一个线程，线程才是执行单位

2、进程VS 线程

　　1、同一进程内的线程们共享该进程内资源，不同进程内的线程资源肯定是隔离的

　　 2、创建线程的开销比创建进程要小的多

三、开启线程的两种方式

from multiprocessing import Process

from threading import Thread

import time

def task(name):

　　print('%s is running'%name)

　　time.sleep(3)

if __name__=='__main__':

　　t=Thread(target=task,args=('egon',))

　　t.start()

　　print('主线程')

class MyThread(Thread):

　　def run(self):

　　　　print('%s is running'%self.name)

　　　　time.sleep(2)

if __name__=='__main__':

　　t=MyThread()

　　t.start()

　　print('主线程')

四、进程VS线程

PID

from threading import Thread
import time,os

def task():
    print('%s is running' %os.getpid())
    time.sleep(3)

if __name__ == '__main__':
    t=Thread(target=task,)
    t.start()
    print('主线程',os.getpid())
2、线程创建开销小
3、同一进程内的多个线程共享该进程内的资源

from threading import Thread
import time,os

x=1000
def task():
    global x
    x=0

if __name__ == '__main__':
    t=Thread(target=task,)
    t.start()
    t.join()
    print('主线程',x)
五、线程对象的其它方法

Thread实例对象的方法
   isAlive(): 返回线程是否活动的。
   getName(): 返回线程名。
   setName(): 设置线程名。

threading模块提供的一些方法：
   threading.currentThread(): 返回当前的线程变量。
   threading.enumerate(): 返回一个包含正在运行的线程的list。正在运行指线程启动后、结束前，不包括启动前和终止后的线程。
   threading.activeCount(): 返回正在运行的线程数量，与len(threading.enumerate())有相同的结果。

from threading import Thread,current_thread,active_count,enumerate
import time,os

def task():
    print('%s is running' %current_thread().name)
    time.sleep(3)

if __name__ == '__main__':
    t1=Thread(target=task,name='第一个线程')
    t2=Thread(target=task,)
    t3=Thread(target=task,)
    t1.start()
    t2.start()
    t3.start()

    # print(t1.is_alive())
    print(active_count())
    print(enumerate())
    print('主线程',current_thread().name)
六、守护线程

无论是进程还是线程，都遵循：守护xxx会等待主xxx运行完毕后被销毁

需要强调的是：运行完毕并非终止运行

#1.对主进程来说，运行完毕指的是主进程代码运行完毕

#2.对主线程来说，运行完毕指的是主线程所在的进程内所有非守护线程统统运行完毕，主线程才算运行完毕

详细解释：

#1 主进程在其代码结束后就已经算运行完毕了（守护进程在此时就被回收）,然后主进程会一直等非守护的子进程都运行完毕后回收子进程的资源(否则会产生僵尸进程)，才会结束，

#2 主线程在其他非守护线程运行完毕后才算运行完毕（守护线程在此时就被回收）。因为主线程的结束意味着进程的结束，进程整体的资源都将被回收，而进程必须保证非守护线程都运行完毕后才能结束。

from threading import Thread
import time
def foo():
    print(123)
    time.sleep(5)
    print("end123")

def bar():
    print(456)
    time.sleep(3)
    print("end456")

if __name__ == '__main__':

    t1=Thread(target=foo)
    t2=Thread(target=bar)

    t1.daemon=True
    t1.start()
    t2.start()
    print("main-------")

七、线程互斥锁

from threading import Thread,Lock
import time

mutex=Lock()
x=100

def task():
    global x
    mutex.acquire()
    temp=x
    time.sleep(0.1)
    x=temp-1
    mutex.release()


if __name__ == '__main__':
    start=time.time()
    t_l=[]
    for i in range(100):
        t=Thread(target=task)
        t_l.append(t)
        t.start()
    for t in t_l:
        t.join()

    print('主',x)
    print(time.time()-start)
八、死锁现象与递归锁
所谓死锁： 是指两个或两个以上的进程或线程在执行过程中，因争夺资源而造成的一种互相等待的现象，若无外力作用，它们都将无法推进下去。此时称系统处于死锁状态或系统产生了死锁，这些永远在互相等待的进程称为死锁进程，如下就是死锁

from threading import Thread,Lock,RLock
import time

# mutexA=Lock()
# mutexB=Lock()

mutexA=mutexB=RLock()

class MyThread(Thread):
    def run(self):
        self.f1()
        self.f2()

    def f1(self):
        mutexA.acquire()
        print('%s 拿到了A锁' %self.name)

        mutexB.acquire()
        print('%s 拿到了B锁' %self.name)
        mutexB.release()

        mutexA.release()

    def f2(self):
        mutexB.acquire()
        print('%s 拿到了B锁' %self.name)
        time.sleep(0.1)

        mutexA.acquire()
        print('%s 拿到了A锁' %self.name)
        mutexA.release()

        mutexB.release()


if __name__ == '__main__':
    for i in range(10):
        t=MyThread()
        t.start()

    # t1=MyThread()
    # t1.start()
    #
    # t2=MyThread()
    # t2.start()
    #
    # t3=MyThread()
    # t3.start()
    print('主')

解决方法，递归锁，在Python中为了支持在同一线程中多次请求同一资源，python提供了可重入锁RLock。

这个RLock内部维护着一个Lock和一个counter变量，counter记录了acquire的次数，从而使得资源可以被多次require。直到一个线程所有的acquire都被release，其他的线程才能获得资源。上面的例子如果使用RLock代替Lock，则不会发生死锁：

mutexA=mutexB=threading.RLock() #一个线程拿到锁，counter加1,该线程内又碰到加锁的情况，则counter继续加1，这期间所有其他线程都只能等待，等待该线程释放所有锁，即counter递减到0为止

九信号量：

同进程的一样

Semaphore管理一个内置的计数器，
每当调用acquire()时内置计数器-1；
调用release() 时内置计数器+1；
计数器不能小于0；当计数器为0时，acquire()将阻塞线程直到其他线程调用release()。

实例：(同时只有5个线程可以获得semaphore,即可以限制最大连接数为5)：

from threading import Thread,Semaphore,current_thread
import time,random

sm=Semaphore(5)

def go_wc():
    sm.acquire()
    print('%s 上厕所ing' %current_thread().getName())
    time.sleep(random.randint(1,3))
    sm.release()

if __name__ == '__main__':
    for i in range(23):
        t=Thread(target=go_wc)
        t.start()

与进程池是完全不同的概念，进程池Pool(4)，最大只能产生4个进程，而且从头到尾都只是这四个进程，不会产生新的，而信号量是产生一堆线程/进程