day30总结

                    回顾

                    1.进程互斥锁
                    让并发变成串行,牺牲了效率,保证数据安全.
                    mutex = Lock()
                    # 加锁
                    ? mutex.acquire()
                    # 释放锁
                    ? mutex.release()

                    2.队列:
                    相当于在内存中开启了一个空间,可以存放一堆数据,这堆数据都得遵循"先进先出".
                    管道(阻塞) + 锁
                    q = Queue()
                    # 添加数据
                    ? q.put(1)
                    # 若队列满了,会原地等待
                    ? q.put(2)
                    # 若队列满了,不会等待直接报错
                    ? q.put_nowait(2)

                    获取数据,遵循先进先出
                    若队列中没数据,会原地等待
                    q.get() # 1
                    若队列中没数据,会直接报错
                    q.get_nowait() # 1

                    q.empty() # 判断队列是否为空
                    q.full() # 判断队列是否满了

                    3.IPC进程间通信
                    通过队列让进程间实现通信.

                    4.生产者与消费者
                    生产者: 生产数据的
                    消费者; 使用数据的

                    目的: 解决供需不平衡问题.
                    通过队列来实现,生产者消费者供需不平衡问题.

                    5.线程
                    1.什么是线程?
                    进程: 资源单位
                    线程: 执行单位

                    注意: 只要开启一个进程就会有一个线程(主线程).
                    主线程会在进程结束时,一并销毁.

                    2.为什么要使用线程?
                    节省内存资源

                    开启进程:
                    1) 开辟一个新的内存空间
                    2) 会自带一个主线程

                    开启线程:
                    1) 一个进程内可以开启多个线程
                    2) 开启线程的资源远小于进程

                    创建线程的两种方式
                    一:
                    from threading import Thread
                    def task():
                    pass

                    t = Thread(target=task) # 异步提交任务,开启线程
                    t.start()
                    t.join() # 主线程等待子线程结束之后再结束.

                    二:
                    class MyThread(Thread):
                    def run(self):
                    执行任务
                    ? pass

                    t = MyThread()
                    t.start()
                    t.join()

                    6.线程对象的属性
                    current_thread().name # 获取当前线程对象的名字
                    # 返回一个列表,列表中包含当前执行的所有线程对象
                    print(enumerate())
                    # 获取当前执行线程的个数
                    print(activeCount())
                    is_alive() # 判断线程是否存活

                    7.线程互斥锁
                    from threading import Lock()
                    mutex = Lock()
                    mutex.acquire()
                    t1
                    mutex.release()

                    TCP服务端实现并发

                    '''
                    服务端的工作:
                        1.接收客户端的请求
                        2.24小时不间断提供服务
                        3.实现并发
                    
                    '''
                    
                    import socket
                    import time
                    from threading import Thread
                    
                    server = socket.socket()
                    
                    server.bind(
                        ('127.0.0.1', 9527)
                    )
                    
                    server.listen(5)
                    print('启动服务端...')
                    
                    
                    # 线程任务,执行接收客户端消息与发送消息给客户端
                    def working(conn):
                        while True:
                            try:
                                data = conn.recv(1024)
                                if len(data) == 0:
                                    break
                                print(data)
                                time.sleep(1)
                                conn.send(data.upper())
                            except Exception as e:
                                print(e)
                                break
                    
                        conn.close()
                    
                    
                    while True:
                        conn, addr = server.accept()
                        print(addr)
                        t = Thread(target=working, args=(conn, ))
                        t.start()xxxxxxxxxx?'''服务端的工作: ?  1.接收客户端的请求 ?  2.24小时不间断提供服务 ?  3.实现并发'''import socketimport timefrom threading import Threadserver = socket.socket()server.bind( ?  ('127.0.0.1', 9527))server.listen(5)print('启动服务端...')# 线程任务,执行接收客户端消息与发送消息给客户端def working(conn): ?  while True: ? ? ?  try: ? ? ? ? ?  data = conn.recv(1024) ? ? ? ? ?  if len(data) == 0: ? ? ? ? ? ? ?  break ? ? ? ? ?  print(data) ? ? ? ? ?  time.sleep(1) ? ? ? ? ?  conn.send(data.upper()) ? ? ?  except Exception as e: ? ? ? ? ?  print(e) ? ? ? ? ?  break ?  conn.close()while True: ?  conn, addr = server.accept() ?  print(addr) ?  t = Thread(target=working, args=(conn, )) ?  t.start()'''服务端的工作: ?  1.接收客户端的请求 ?  2.24小时不间断提供服务 ?  3.实现并发'''import socketimport timefrom threading import Threadserver = socket.socket()server.bind( ?  ('127.0.0.1', 9527))server.listen(5)print('启动服务端...')# 线程任务,执行接收客户端消息与发送消息给客户端def working(conn): ?  while True: ? ? ?  try: ? ? ? ? ?  data = conn.recv(1024) ? ? ? ? ?  if len(data) == 0: ? ? ? ? ? ? ?  break ? ? ? ? ?  print(data) ? ? ? ? ?  time.sleep(1) ? ? ? ? ?  conn.send(data.upper()) ? ? ?  except Exception as e: ? ? ? ? ?  print(e) ? ? ? ? ?  break ?  conn.close()while True: ?  conn, addr = server.accept() ?  print(addr) ?  t = Thread(target=working, args=(conn, )) ?  t.start()
                    import socket
                    import time
                    
                    client = socket.socket()
                    
                    client.connect(
                        ('127.0.0.1', 9527)
                    )
                    
                    print('启动客户端...')
                    while True:
                        client.send(b'hello')
                        data = client.recv(1024)
                        print(data)
                        time.sleep(1)

                    GIL全局解释器锁

                    '''
                    In CPython, the global interpreter lock, or GIL, is a mutex that prevents multiple
                    native threads from executing Python bytecodes at once. This lock is necessary mainly
                    because CPython’s memory management is not thread-safe. (However, since the GIL
                    exists, other features have grown to depend on the guarantees that it enforces.)
                    
                    在CPython中,全局解释器锁(GIL)是一个防止多个锁的互斥锁
                    本机线程从执行Python字节码一次。这把锁主要是必须的
                    因为CPython的内存管理不是线程安全的。(然而,自从GIL
                    存在时,其他功能已逐渐依赖于它所实施的保证。)
                    
                    '''
                    
                    '''
                    python解释器:
                        1.Cpython
                            C
                            
                        2.Jpython
                            java
                            
                        3.Ppython
                            Python
                    
                    
                    GIL全局解释器锁:
                        基于Cpython来研究全局解释器锁.
                        
                        1.GIL本质上是一个互斥锁.
                        2.GIL的为了阻止同一个进程内多个线程同时执行(并行)
                            - 单个进程下的多个线程无法实现并行,但能实现并发
                        
                        3.这把锁主要是因为CPython的内存管理不是 "线程安全" 的.
                            - 内存管理
                                - 垃圾回收机制
                                
                        GIL的存在就是为了保证线程安全的.
                        
                        注意: 多个线程过来执行,一旦遇到IO操作,就会立马释放GIL解释器锁,交给下一个先进来的线程.
                        
                    '''
                    
                    import time
                    from threading import Thread, current_thread
                    
                    number = 100
                    
                    
                    def task():
                        global number
                        number2 = number
                        # time.sleep(1)
                        number = number2 - 1
                        print(number, current_thread().name)
                    
                    
                    for line in range(100):
                        t = Thread(target=task)
                        t.start()

                    验证多线程的作用

                    '''
                    多线程的作用:
                        站在两个角度去看问题:
                    
                        - 四个任务, 计算密集型, 每个任务需要10s:
                            单核:
                                - 开启进程
                                    消耗资源过大
                                    - 4个进程: 40s
                    
                                - 开启线程
                                    消耗资源远小于进程
                                    - 4个线程: 40s
                    
                            多核:
                                - 开启进程
                                    并行执行,效率比较高
                                    - 4个进程: 10s
                    
                                - 开启线程
                                    并发执行,执行效率低.
                                    - 4个线程: 40s
                    
                    
                    
                        - 四个任务, IO密集型, 每个任务需要10s:
                            单核:
                                - 开启进程
                                    消耗资源过大
                                    - 4个进程: 40s
                    
                                - 开启线程
                                    消耗资源远小于进程
                                    - 4个线程: 40s
                    
                            多核:
                                - 开启进程
                                    并行执行,效率小于多线程,因为遇到IO会立马切换CPU的执行权限
                                    - 4个进程: 40s  +  开启进程消耗的额外时间
                    
                                - 开启线程
                                    并发执行,执行效率高于多进程
                    
                                    - 4个线程: 40s
                    '''
                    from threading import Thread
                    from multiprocessing import Process
                    import os
                    import time
                    
                    
                    # 计算密集型
                    def work1():
                        number = 0
                        for line in range(100000000):
                            number += 1
                    
                    
                    # IO密集型
                    def work2():
                        time.sleep(1)
                    
                    
                    if __name__ == '__main__':
                    
                        # 测试计算密集型
                        # print(os.cpu_count())  # 6
                        # # 开始时间
                        # start_time = time.time()
                        # list1 = []
                        # for line in range(6):
                        #     p = Process(target=work1)  # 程序执行时间5.300818920135498
                        #     # p = Thread(target=work1)  # 程序执行时间24.000795602798462
                        #
                        #     list1.append(p)
                        #     p.start()
                    
                        # IO密集型
                        print(os.cpu_count())  # 6
                        # 开始时间
                        start_time = time.time()
                        list1 = []
                        for line in range(40):
                            # p = Process(target=work2)  # 程序执行时间4.445072174072266
                            p = Thread(target=work2)  # 程序执行时间1.009237289428711
                    
                            list1.append(p)
                            p.start()
                    
                        for p in list1:
                            p.join()
                        end_time = time.time()
                    
                        print(f'程序执行时间{end_time - start_time}')
                    
                    
                    
                    
                    '''
                    在计算密集型的情况下:
                        使用多进程
                        
                    在IO密集型的情况下:
                        使用多线程
                        
                    高效执行多个进程,内多个IO密集型的程序:
                        使用 多进程 + 多线程
                    '''

                    死锁现象

                    '''
                    死锁现象(了解):
                    
                    '''
                    from threading import Lock, Thread, current_thread
                    import time
                    
                    mutex_a = Lock()
                    mutex_b = Lock()
                    #
                    # print(id(mutex_a))
                    # print(id(mutex_b))
                    
                    
                    class MyThread(Thread):
                    
                        # 线程执行任务
                        def run(self):
                            self.func1()
                            self.func2()
                    
                        def func1(self):
                            mutex_a.acquire()
                            # print(f'用户{current_thread().name}抢到锁a')
                            print(f'用户{self.name}抢到锁a')
                            mutex_b.acquire()
                            print(f'用户{self.name}抢到锁b')
                            mutex_b.release()
                            print(f'用户{self.name}释放锁b')
                            mutex_a.release()
                            print(f'用户{self.name}释放锁a')
                    
                        def func2(self):
                            mutex_b.acquire()
                            print(f'用户{self.name}抢到锁b')
                            # IO操作
                            time.sleep(1)
                    
                            mutex_a.acquire()
                            print(f'用户{self.name}抢到锁a')
                            mutex_a.release()
                            print(f'用户{self.name}释放锁a')
                            mutex_b.release()
                            print(f'用户{self.name}释放锁b')
                    
                    
                    for line in range(10):
                        t = MyThread()
                        t.start()
                    
                    
                    '''
                    注意:
                        锁不能乱用.
                    '''

                    递归锁

                    '''
                    递归锁(了解):
                        用于解决死锁问题.
                    
                    RLock: 比喻成万能钥匙,可以提供给多个人去使用.
                        但是第一个使用的时候,会对该锁做一个引用计数.
                        只有引用计数为0, 才能真正释放让另一个人去使用
                    '''
                    
                    from threading import RLock, Thread, Lock
                    import time
                    
                    mutex_a = mutex_b = Lock()
                    
                    
                    class MyThread(Thread):
                    
                        # 线程执行任务
                        def run(self):
                            self.func1()
                            self.func2()
                    
                        def func1(self):
                            mutex_a.acquire()
                            # print(f'用户{current_thread().name}抢到锁a')
                            print(f'用户{self.name}抢到锁a')
                            mutex_b.acquire()
                            print(f'用户{self.name}抢到锁b')
                            mutex_b.release()
                            print(f'用户{self.name}释放锁b')
                            mutex_a.release()
                            print(f'用户{self.name}释放锁a')
                    
                        def func2(self):
                            mutex_b.acquire()
                            print(f'用户{self.name}抢到锁b')
                            # IO操作
                            time.sleep(1)
                            mutex_a.acquire()
                            print(f'用户{self.name}抢到锁a')
                            mutex_a.release()
                            print(f'用户{self.name}释放锁a')
                            mutex_b.release()
                            print(f'用户{self.name}释放锁b')
                    
                    
                    for line in range(10):
                        t = MyThread()
                        t.start()

                    信号量

                    '''
                    信号量(了解):
                    
                        互斥锁: 比喻成一个家用马桶.
                            同一时间只能让一个人去使用
                    
                        信号量: 比喻成公厕多个马桶.
                            同一时间可以让多个人去使用
                    '''
                    from threading import Semaphore, Lock
                    from threading import current_thread
                    from threading import Thread
                    import time
                    
                    sm = Semaphore(5)  # 5个马桶
                    mutex = Lock()  # 5个马桶
                    
                    
                    def task():
                        # mutex.acquire()
                        sm.acquire()
                        print(f'{current_thread().name}执行任务')
                        time.sleep(1)
                        sm.release()
                        # mutex.release()
                    
                    
                    for line in range(20):
                        t = Thread(target=task)
                        t.start()

                    线程队列

                    '''
                    线程Q(了解级别1): 线程队列  面试会问: FIFO
                    
                        - FIFO队列: 先进先出
                        - LIFO队列: 后进先出
                        - 优先级队列: 根据参数内,数字的大小进行分级,数字值越小,优先级越高
                    '''
                    import queue
                    
                    # 普通的线程队列: 先进先出
                    # q = queue.Queue()
                    # q.put(1)
                    # q.put(2)
                    # q.put(3)
                    # print(q.get())  # 1
                    
                    
                    # LIFO队列: 后进先出
                    # q = queue.LifoQueue()
                    # q.put(1)
                    # q.put(2)
                    # q.put(3)
                    # print(q.get())  # 3
                    
                    
                    # 优先级队列
                    q = queue.PriorityQueue()  # 超级了解
                    # 若参数中传的是元组,会以元组中第一个数字参数为准
                    q.put(('a优', '先', '娃娃头', 4))  # a==97
                    q.put(('a先', '优', '娃娃头', 3))  # a==98
                    q.put(('a级', '级', '娃娃头', 2))  # a==99
                    '''
                    1.首先根据第一个参数判断ascii表的数值大小
                    2.判断第个参数中的汉字顺序.
                    3.再判断第二参数中数字--> 字符串数字 ---> 中文
                    4.以此类推
                    '''
                    print(q.get())
                    相关文章
                    相关标签/搜索
                    今期管家婆大图 玄机图六合宝典2020年香港马会正版挂牌免费资料大全开奖历史记录在线查询网