zoukankan      html  css  js  c++  java
  • 线程

    守护进程的应用场景

    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('主线程')
    使用Thtead类
        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('')
    递归锁

     

    信号量  

  • 相关阅读:
    谜之This
    JS 面向对象 ~ 继承的7种方式
    JS 面向对象 ~ 创建对象的 9 种方式
    JS 原型与原型链
    ES6 Promise 详解
    Vue diff 算法
    Vue Router 路由实现原理
    Vue Keep-alive 原理
    Vue 响应式原理
    JS 有趣的JS
  • 原文地址:https://www.cnblogs.com/guodengjian/p/8952232.html
Copyright © 2011-2022 走看看