4, GIL Global Interpreter Lock, событие событие, семафор

 

 

 

Сегодня содержание 
    1, GIL Global Interpreter Замок 
    2, тупики 
    3, семафоры 
    4, событие событие 
    5, очереди 
на: GIL Global Interpreter Блокировка 
    Что GIL Global Interpreter Lock: 
        его сущность мьютекс, является в CPython блокировки интерпретатора, одновременно стал серийным, за 
        счет эффективности, обеспечения безопасности данных! 
    Роль: Выполните то же самое время используется для предотвращения нескольких потоков в одном процессе 
        (несколько потоков параллельно , не могут быть достигнуты в течение того же самого процесса , но могут быть реализованы одновременно) 
        наличие GIL происходит потому , что управление памятью CPython интерпретатор не поточно 
        изучение Python многопоточность полезно , если обсуждаемые вопросы нужны 
            четыре 10s ресурсоемких задачи 
            в одноядерных случаях 
                открытой нить более провинциальных ресурсы 
            многоядерных случае 
                открытого процесс 10s 
                открытая нить 40s 

            четыре IO ресурсоемких задач в 
            одноядерных случаях 
                открытых тема больше экономить ресурсы 
            многожильный случае 
                открытые темы больше экономить ресурсы

    2 死锁：

    from threading import Thread,Lock,current_thread,RLock
    import time

    # RLock 递归锁
    # Rlock可以被第一个抢到锁的人连续的acquire和release
    #每acquire一次锁身上的计数加1
    #每release一次锁身上的计数减1
    #只要锁的计数不为0 其他人都不能抢


    mutexA = Lock()
    mutexB = Lock()
    #mutexA = mutexB = RLock()  # A B现在是同一把锁


    class MyThread(Thread):
        def run(self):  # 创建线程自动触发run方法 run方法内调用func1 func2相当于也是自动触发
            self.func1()
            self.func2()

        def func1(self):
            mutexA.acquire()
            print('%s抢到了A锁'%self.name)  # self.name等价于current_thread().name
            mutexB.acquire()
            print('%s抢到了B锁'%self.name)
            mutexB.release()
            print('%s释放了B锁'%self.name)
            mutexA.release()
            print('%s释放了A锁'%self.name)

        def func2(self):
            mutexB.acquire()
            print('%s抢到了B锁'%self.name)
            time.sleep(1)
            mutexA.acquire()
            print('%s抢到了A锁' % self.name)
            mutexA.release()
            print('%s释放了A锁' % self.name)
            mutexB.release()
            print('%s释放了B锁' % self.name)

        for i in range(10):
            t = MyThread()
            t.start()
    3，信号量   （Semaphore）
        # 信号量可能在不同的领域中 对应不同的知识点

            互斥锁:一个厕所(一个坑位)
            信号量:公共厕所(多个坑位)

            from threading import Semaphore,Thread
            import time
            import random

            # 同时有四十个线程来抢五个坑位，即有五个线程抢到五个坑位，同时执行五个线程
            五个人同时抢到锁，同时释放锁
            sm = Semaphore(5)  # 造了一个含有五个的坑位的公共厕所

            def task(name):
                sm.acquire()
                print('%s占了一个坑位'%name)
                time.sleep(random.randint(1,3))   抢到锁睡得时间不一样
                sm.release()

            for i in range(40):
                t = Thread(target=task,args=(i,))
                t.start()
    4，event事件  一个子进程等待另一个子进程接受再走，或者一个子线程等待另一个子线程结束再走
            即 子等子时，就用event事件，子执行完毕给另一个子发信号，另一个子只要等待到信号，就开始立即执行
        案列： 红灯与车   （灯一个，车多个，即给车多个线程）
        from threading import Event,Thread
        import time

        # 先生成一个event对象********
        e = Event()

        def light():
            print('红灯正亮着')
            time.sleep(3)
            e.set()  # 发信号**********
            print('绿灯亮了')

        def car(name):
            print('%s正在等红灯'%name)
            e.wait()  # 等待信号**********
            print('%s加油门飙车了'%name)

        t = Thread(target=light)
        t.start()

        for i in range(10):
            t = Thread(target=car,args=('伞兵%s'%i,))
            t.start()

    5，队列（多线程优先用队列，而不是加锁）
        同一个进程下的多个线程本来就是数据共享 为什么还要用队列
        因为队列是管道+锁  使用队列你就不需要自己手动操作锁的问题
        因为锁操作的不好极容易产生死锁现象
        import queue

        q = queue.Queue()    # 普通队列，产生一个队列对象
        q.put('hahha')
        print(q.get())


        q = queue.LifoQueue()    #后进先出队列，==》堆栈
        q.put(1)
        q.put(2)
        q.put(3)
        print(q.get())


        q = queue.PriorityQueue()  #优先级队列，支持你给你放的数据设置优先级，
        取的时候，数字越小 优先级越高***********
        q.put((10,'haha'))
        q.put((100,'hehehe'))
        q.put((0,'xxxx'))
        q.put((-10,'yyyy'))
        print(q.get())