线程

守护进程的应用场景

import time
import 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('33[46m消费者===》%s 吃了 %s33[0m' %(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('33[45m生产者者===》%s 生产了 %s33[0m' %(name,res))



if __name__ == '__main__':
    #1、共享的盆
    q=JoinableQueue()


    #2、生产者们
    p1=Process(target=producer,args=('egon',q,'包子'))
    p2=Process(target=producer,args=('刘清政',q,'泔水'))
    p3=Process(target=producer,args=('杨军',q,'米饭'))

    #3、消费者们
    c1=Process(target=consumer,args=('alex',q))
    c2=Process(target=consumer,args=('梁书东',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('主进程结束')

 from multiprocessing import JoinableQueue

使用JoinableQueue类，


#         q.task_done()  告诉消费者队列已经取完了
    

#     # 确定生产者确确实实已经生产完毕
#     p1.join()
#     p2.join()
#     p3.join()
#     # 在生产者生产完毕后，拿到队列中元素的总个数，然后直到元素总数变为0，q.join()这一行代码才算运行完毕
#     q.join()
#     #q.join()一旦结束就意味着队列确实被取空，消费者已经确确实实把数据都取干净了
#     print('主进程结束')

线程

　　

什么是线程

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

进程和线程的区别

　　进程根本就不是一个执行单位，进程其实是一个资源单位，一个进程内自带一个线程，线程才是执行单　　

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

　　创建线程的开销比创建进程的开销小很多

开启线程的两种方式：　

    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=('ehon',))
            t.start()
            print('主线程')

    from multiprocessing import Process
    from  threading import Thread

    import time

    class MyThread(Thread):
        def run(self):
            print('%s is running' %self.name)
            time.sleep(3)

    if __name__ == '__main__':
        t =MyThread()
        t.start()
        print('主线程')

线程对象的其他方法：

from multiprocessing import Process
from threading import Thread,current_thread,active_count,enumerate
import time

def task():
    print('%s is running' %current_thread().name)
#current_thread(),返回当前线程的信息，此处返回的是线程名字
    time.sleep(3)

if __name__ == '__main__':
    t1 = Thread(target=task,)
    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)
 

守护线程：

　　主线程完全执行结束（所有的非守护线程结束），守护线程也随之结束　

线程互斥锁

　from threading import Lock

　　将线程局部由并发变为串行，用法和进程互斥锁一样

　　牺牲了速度，保证的数据的正确性

死锁和递归锁

　　递归锁：同一把锁，每acquire一次，锁计数加一，每release一次，计数减一　

    from threading import RLock

    mutexA=mutexB=RLock()

from threading import Thread,Lock,RLock
    import time

    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()

        print('主')

 

信号量