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())
        相关文章
        相关标签/搜索
        香港马会免费资枓大全香港开奖结果_香港马会2019开奖结果_2019 最快开奖记录结果_小鱼儿玄机2站开奖 开奖结果 芜湖市| 辉南县| 沅陵县| 云南省| 泗阳县| 息烽县| 南木林县| 巴楚县| 盐边县| 大方县| 西峡县| 法库县| 玛纳斯县| 康保县| 洛川县| 涟水县| 樟树市| 三原县| 赣榆县| 双鸭山市| 澳门| 宁蒗| 堆龙德庆县| 晋州市| 新疆| 阿勒泰市| 禹州市| 任丘市| 安丘市| 呼玛县| 嘉峪关市| 会同县| 河间市| 黎城县| 石城县| 丰城市| 北安市| 昌都县| 日土县| 峨眉山市| 乌拉特前旗| 五寨县| 佛山市| 通辽市| 千阳县| 胶南市| 余庆县| 汉沽区| 霍山县| 吉木乃县| 贡觉县| 瑞丽市| 泸西县| 千阳县| 八宿县| 射洪县| 郸城县| 鸡东县| 桦甸市| 西安市| 三亚市| 龙陵县| 额济纳旗| 葫芦岛市| 清苑县| 涟源市| 高唐县| 田林县| 久治县| 都兰县| 彭山县| 鞍山市| 香港| 盐池县| 张家界市| 资兴市| 绿春县| 武安市| 崇义县| 益阳市| 仁怀市| 顺义区| 中阳县| 花莲市| 吕梁市| 新疆| 蚌埠市| 长宁区| 清原| 西贡区| 荥经县| 定州市| 大庆市| 北流市| 顺平县| 南平市| 楚雄市| 化隆| 淮阳县| 临高县| 贞丰县| 信宜市| 旌德县| 尚志市| 正定县| 于田县| 建阳市| 南江县| 长武县| 周口市| 乌海市| 罗田县| 甘孜县| 尉犁县| 浑源县| 六安市| 昌邑市| 澄迈县| 丹寨县| 扶绥县| 南京市| 杭锦后旗| 达州市| 东兰县| 襄垣县| 兴业县| 宿州市| 玛曲县| 东乌珠穆沁旗| 奉新县| 长顺县| 彭州市| 万州区| 吴川市| 平原县| 固安县| 宁安市| 洛川县| 云梦县| 望奎县| 靖远县| 宾阳县| 西乡县| 太原市| 遂川县| 共和县| 长泰县| 郯城县| 汕尾市| 嵩明县| 泾源县| 合阳县| 绥德县| 彭阳县| 深水埗区| 台州市| 辽宁省| 定兴县| 黄平县| 建宁县| 广南县| 建宁县| 琼结县| 襄汾县| 丹江口市| 南宁市| 林州市| 望城县| 桐庐县| 光泽县| 阿拉善右旗| 栾城县| 崇州市| 宿州市| 广平县| 含山县| 宁强县| 敦化市| 重庆市| 高雄县| 永和县| 晋江市| 萍乡市| 济阳县| 扶绥县| 比如县| 凤庆县| 西林县| 石城县| 盖州市| 广宗县| 石渠县| 平遥县| 永吉县| 稻城县| 怀安县| 始兴县| 宽城| 沾益县| 天祝| 新昌县| 台安县| 沙雅县| 府谷县| 英德市| 杨浦区| 鄂伦春自治旗| 屏山县| 河曲县| 蕉岭县| 玛纳斯县| 虞城县| 西和县| 通州区| 响水县| 句容市| 盱眙县| 南陵县| 修武县| 泰安市| 明溪县| 廊坊市| 尼玛县| 三门县| 滦南县| 连平县| 长兴县| 莎车县| 枣庄市| 乌恰县| 峡江县| 潜江市| 保康县| 荔波县| 尼勒克县| 绥阳县| 阳高县| 朝阳区| 贵德县| 贞丰县| 汝阳县| 七台河市| 台东县| 荥经县| 永和县| 新乡县| 陆良县| 峨山| 澳门| 柞水县| 吴桥县| 五河县| 连城县| 民县| 晋中市| 五原县| 长治县| 娄烦县| 佛学| 江孜县| 莒南县| 迁安市| 德庆县| 三河市| 荔波县| 阜新市| 县级市| 阿拉善右旗| 新乡市| 封丘县| 新建县| 聊城市| 枣庄市| 郎溪县| 砀山县| 和林格尔县| 正镶白旗| 宜川县| 重庆市| 通化市| 汉源县| 太谷县| 洞口县| 延长县| 祁门县| 宝丰县| 随州市| 南木林县| 潼关县| 丰宁| 诸城市| 绍兴县| 武强县| 同德县| 水富县| 洪湖市| 灵璧县| 山西省| 米泉市| 阳原县| 元谋县| 登封市| 拉萨市| 河东区| 浙江省| 九龙坡区| 江口县| 兴义市| 温宿县| 合作市| 益阳市| 友谊县| 宜良县| 筠连县| 临安市| 灵武市| 德兴市| 庄浪县| 绥滨县| 洪江市| 桂平市| 勐海县| 横山县| 河津市| 崇州市| 思茅市| 黑水县| 新化县| 商丘市| 南城县| 林口县| 江安县| 徐闻县| 东台市| 庆阳市| 固镇县| 宣威市| 阳高县| 福安市| 吴旗县| 健康| 普兰县| 视频| 兴山县| 南乐县| 温州市| 凌源市| 北安市| 蒲城县| 浏阳市| 迁西县| 安顺市| 淮安市| 三亚市| 股票| 林芝县| 汾西县| 铜鼓县| 延长县| 油尖旺区| 宜宾市| 资源县| 洞头县| 靖宇县| 视频| 漳平市| 哈密市| 上虞市| 阿瓦提县| 吉水县| 秦安县| 山西省| 方山县| 内乡县| 玛曲县| 天祝| 新郑市| 上林县| 桑植县| 威远县| 夏河县| 合川市| 广昌县| 富裕县| 林口县| 涞水县| 贡觉县| 修水县| 大宁县| 巢湖市| 祁阳县| 银川市| 嘉善县| 德州市| 崇文区| 城市| 台东市| 黑山县| 襄汾县| 焉耆| 南陵县| 滦平县| 县级市| 海安县| 青海省| 西丰县| 张家界市| 称多县| 闸北区| 吴川市| 石嘴山市| 永和县| 静乐县| 台南县| 斗六市| 泾阳县| 巫山县| 竹溪县| 萝北县| 喀什市| 博白县| 磐安县| 江安县| 大港区| 舞钢市| 临西县| 德昌县| 尖扎县| 鸡西市| 怀化市| 佛教| 油尖旺区| 玉屏| 西安市| 兴安县| 新安县| 铜山县| 密云县| 宾阳县| 义乌市| 伊宁县| 阳朔县| 五寨县| 贡觉县| 阜阳市| 兴义市| 托里县| 通化市| 淮阳县| 临高县| 绥江县| 武威市| 马边| 洪雅县| 南阳市| 泗阳县| 麻阳| 石嘴山市| 凤冈县| 桐城市| 清苑县| 舞阳县| 尼玛县| 宜丰县| 辛集市| 芜湖市| 始兴县| 安塞县| 炉霍县| 如东县| 安溪县| 南陵县| 鞍山市| 霍城县| 华蓥市| 青阳县| 林周县| 平和县| 达州市| 邳州市| 江口县| 长治市| 武城县| 绥阳县| 安平县| 白城市| 上虞市| 邵武市| 梨树县| 吴桥县| 普洱| 定边县| 遵义县| 河南省| 玛纳斯县| 巩义市| 鸡泽县| 大竹县| 镶黄旗| 蓬溪县| 高尔夫| 扬中市| 潜江市| 麻江县| 河西区| 中卫市| 青河县| 通道| 泾阳县| 塘沽区| 资源县| 荣成市| 西藏| 华容县| 乌拉特中旗| 枣强县| 肥城市| 大港区| 隆回县| 台东市| 延吉市| 武宣县| 浑源县| 邹城市| 台东市| 卓资县| 临沭县| 永城市| 确山县| 福建省| 崇义县| 磐石市| 昌图县| 昭苏县| 炉霍县| 平谷区| 尼玛县| 青田县| 巴南区| 玛沁县| 胶州市| 清新县| 名山县| 尖扎县| 南岸区| 孟州市| 利川市| 赣州市| 霍邱县| 榆社县| 凤翔县| 汾阳市| 宜宾县| 永春县| 庄浪县| 建平县| 渑池县| 礼泉县| 京山县| 梁平县| 康定县| 通许县| 枣阳市| 瓮安县| 略阳县| 萨嘎县| 雷波县| 上饶县| 延庆县| 咸宁市| 任丘市| 紫金县| 巴彦县| 垫江县| 乌拉特中旗| 栾城县| 石城县| 北流市| 永平县| 类乌齐县| 祁连县| 措美县| 玉门市| 金塔县| 万盛区| 三亚市| 双牌县| 扎鲁特旗| 环江| 通渭县| 胶南市| 新闻| 安福县| 阳城县| 钦州市| 乌什县| 金坛市| 荣成市| 开封县| 来宾市| 江川县| 江北区| 郸城县| 定襄县| 襄汾县| 天水市| 乐山市| 张家港市| 金塔县| 昌乐县| 黄大仙区| 余庆县| 万荣县| 汤阴县| 陆川县| http://m.couqel.fit http://m.kscfzf.fit http://wap.lyumcs.fit http://www.sunxba.fit http://wap.wozfox.fit http://wap.qoxopa.fit http://www.ccluei.fit http://wap.sjwpvy.fit http://m.dwcfwh.fit http://swmrzl.fit http://www.nolxax.fit http://wap.hpmzbp.fit http://m.jbakcg.fit http://www.ztslhn.fit http://wap.tnwxiv.fit http://m.bm1961losez.fit http://www.vguxqv.fit http://m.gridab.fit