<address id="rphpx"><listing id="rphpx"></listing></address>

<address id="rphpx"><dfn id="rphpx"></dfn></address>
<sub id="rphpx"><var id="rphpx"></var></sub>
<address id="rphpx"><dfn id="rphpx"></dfn></address>
    <sub id="rphpx"><var id="rphpx"><ins id="rphpx"></ins></var></sub>
    <sub id="rphpx"><dfn id="rphpx"><ins id="rphpx"></ins></dfn></sub>
      <sub id="rphpx"><var id="rphpx"></var></sub>

      <sub id="rphpx"><var id="rphpx"></var></sub>

        <sub id="rphpx"><var id="rphpx"><ins id="rphpx"></ins></var></sub>

        <thead id="rphpx"><var id="rphpx"><output id="rphpx"></output></var></thead>

        <sub id="rphpx"><listing id="rphpx"></listing></sub>

          <thead id="rphpx"><var id="rphpx"><output id="rphpx"></output></var></thead>
            <address id="rphpx"><dfn id="rphpx"></dfn></address>

            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())
            相关文章
            相关标签/搜索
            白小姐四不像必中一肖+正版+网址930 襄城县| 莒南县| 资阳市| 灯塔市| 拜泉县| 鄂温| 皋兰县| 含山县| 双江| 南昌县| 宜州市| 堆龙德庆县| 休宁县| 连平县| 云浮市| 义乌市| 祁连县| 渭南市| 祁东县| 刚察县| 太仓市| 当阳市| 崇明县| 永兴县| 巩义市| 鄄城县| 林甸县| 潼关县| 宁都县| 那曲县| 鹰潭市| 东宁县| 台中县| 响水县| 白山市| 溧阳市| 沅江市| 濮阳县| 马关县| 长子县| 海城市| 长海县| 孝义市| 昌江| 乐亭县| 彭州市| 宝山区| 普洱| 苍山县| 沙坪坝区| 兖州市| 桓仁| 丽江市| 阳泉市| 彩票| 彭泽县| 安义县| 青阳县| 高阳县| 仁怀市| 北海市| 廊坊市| 监利县| 墨玉县| 梅河口市| 谢通门县| 长岛县| 射洪县| 枣庄市| 绍兴市| 任丘市| 且末县| 灵山县| 二连浩特市| 革吉县| 沂源县| 台中市| 胶南市| 萨迦县| 涿州市| 虎林市| 扬中市| 白山市| 安化县| 青神县| 岑巩县| 湄潭县| 丹江口市| 石城县| 永年县| 汉阴县| 郯城县| 阿克苏市| 华蓥市| 正定县| 顺昌县| 水富县| 阿勒泰市| 綦江县| 将乐县| 山阴县| 榆林市| 利辛县| 西安市| 东乌| 水富县| 南宫市| 长岛县| 开封县| 广元市| 中江县| 广安市| 贡嘎县| 阳原县| 镇宁| 卫辉市| 宁国市| 宣化县| 德钦县| 政和县| 河间市| 平定县| 宁明县| 呼伦贝尔市| 泾阳县| 威宁| 荣成市| 平顶山市| 东光县| 定结县| 昭通市| 武冈市| 黄山市| 连南| 宝坻区| 崇信县| 建德市| 阆中市| 堆龙德庆县| 沭阳县| 彭泽县| 天门市| 成都市| 田林县| 莒南县| 昔阳县| 莱芜市| 顺平县| 内江市| 盖州市| 荣昌县| 西乌| 阿克| 奈曼旗| 安宁市| 康保县| 孟津县| 鹤庆县| 罗甸县| 申扎县| 玉田县| 绩溪县| 木里| 邵武市| 长宁区| 前郭尔| 韶山市| 肇源县| 民和| 普宁市| 黄大仙区| 和政县| 抚顺市| 清新县| 永川市| 临沧市| 镇宁| 丹凤县| 藁城市| 静乐县| 合江县| 云霄县| 镇雄县| 咸宁市| 嘉荫县| 湾仔区| 南靖县| 沙坪坝区| 沙洋县| 理塘县| 拜城县| 禄劝| 红原县| 镇远县| 新邵县| 桐柏县| 松原市| 故城县| 广饶县| 东乡| 怀仁县| 漳平市| 攀枝花市| 博湖县| 永新县| 泸定县| 渭南市| 拉孜县| 玛沁县| 扬州市| 嘉善县| 区。| 东乌| 福泉市| 锦州市| 金堂县| 和田县| 从化市| 景谷| 长治市| 芜湖县| 丰都县| 景宁| 大新县| 平舆县| 崇义县| 乌拉特后旗| 滨州市| 新巴尔虎右旗| 来宾市| 屏南县| 铜川市| 阳城县| 弥渡县| 芮城县| 博爱县| 怀化市| 建始县| 教育| 灌阳县| 富裕县| 临猗县| 太保市| 南江县| 遂川县| 岢岚县| 定南县| 深水埗区| 满洲里市| 达州市| 额敏县| 东源县| 林周县| 平遥县| 巴林左旗| 右玉县| 平阳县| 兴义市| 岳普湖县| 凤凰县| 鄄城县| 科技| 荆门市| 孝义市| 靖边县| 准格尔旗| 湘潭县| 花莲市| 九江市| 甘孜县| 锡林浩特市| 临武县| 青海省| 南开区| 富平县| 南江县| 祁门县| 原平市| 汶川县| 宿松县| 马尔康县| 杂多县| 宝清县| 宁河县| 高淳县| 无棣县| 绥德县| 化隆| 罗源县| 淮北市| 寿光市| 永德县| 岳阳市| 甘南县| 峨山| 潜山县| 方正县| 南开区| 老河口市| 南江县| 云阳县| 汶川县| 阳原县| 翁源县| 盐津县| 紫阳县| 沿河| 周至县| 皋兰县| 曲阳县| 南皮县| 伊金霍洛旗| 辽阳市| 永胜县| 饶河县| 富民县| 灵丘县| 安徽省| 南汇区| 嵊泗县| 日喀则市| 个旧市| 信宜市| 临泉县| 静安区| 巴里| 宁德市| 侯马市| 永昌县| 乃东县| 辉南县| 洪湖市| 图木舒克市| 内黄县| 呈贡县| 永德县| 疏附县| 大埔区| 三原县| 施秉县| 广丰县| 绥棱县| 连山| 枣阳市| 喀喇沁旗| 罗甸县| 磴口县| 藁城市| 蓝山县| 河北区| 平阳县| 饶平县| 区。| 韩城市| 普格县| 延安市| 仁怀市| 个旧市| 中西区| 油尖旺区| 旺苍县| 苏州市| 长寿区| 来安县| 宁南县| 延庆县| 顺昌县| 梅州市| 普定县| 铜川市| 天峻县| 青浦区| 凌源市| 苍南县| 敦煌市| 中方县| 调兵山市| 大邑县| 敖汉旗| 中山市| 民丰县| 黄浦区| 马尔康县| 北安市| 万州区| 塔城市| 大余县| 齐齐哈尔市| 滕州市| 屏南县| 永济市| 绵阳市| 东阳市| 天镇县| 肥乡县| 安岳县| 普陀区| 梁山县| 南华县| 二手房| 卫辉市| 三穗县| 仪陇县| 汕尾市| 离岛区| 德兴市| 义乌市| 大田县| 太谷县| 根河市| 永宁县| 库车县| 临安市| 聂拉木县| 兴国县| 广宗县| 洛阳市| 白河县| 辽宁省| 德保县| 长武县| 吉林省| 庆元县| 常州市| 遵化市| 马尔康县| 商丘市| 阿尔山市| 隆德县| 泌阳县| 库伦旗| 鱼台县| 静海县| 新安县| 甘洛县| 沈阳市| 平远县| 文昌市| 云安县| 炉霍县| 城口县| 广州市| 隆回县| 公主岭市| 比如县| 阳信县| 河东区| 雷山县| 平陆县| 蕉岭县| 卢龙县| 平陆县| 蕉岭县| 平利县| 佛学| 岳普湖县| 武邑县| 东乌珠穆沁旗| 石首市| 兰溪市| 呼和浩特市| 神池县| 永昌县| 威宁| 松滋市| 扎兰屯市| 高要市| 镇巴县| 长海县| 宁德市| 陆良县| 凤山市| 昌黎县| 太仆寺旗| 密云县| 马公市| 庄浪县| 防城港市| 荆门市| 伊金霍洛旗| 吐鲁番市| 南投市| 南宁市| 应用必备| 临邑县| 赤水市| 精河县| 凉城县| 武义县| 漳州市| 衡南县| 内黄县| 肇庆市| 松阳县| 青铜峡市| 孟津县| 襄垣县| 金川县| 萝北县| 城固县| 大悟县| 平利县| 鞍山市| 成武县| 韶关市| 龙川县| 陆河县| 蒲城县| 陇川县| 富宁县| 宁陵县| 德兴市| 巴里| 常宁市| 买车| 黄浦区| 弥勒县| 杭州市| 五指山市| 奉贤区| 始兴县| 黑水县| 麻江县| 富平县| 顺义区| 柳林县| 大宁县| 和顺县| 武强县| 敦煌市| 成都市| 温州市| 临洮县| 施甸县| 正定县| 惠来县| 沧源| 调兵山市| 宁明县| 鹿泉市| 武陟县| 米易县| 砚山县| 共和县| 米泉市| 泸水县| 南岸区| 亳州市| 伊金霍洛旗| 朝阳区| 石河子市| 临沧市| 永和县| 西华县| 平泉县| 崇明县| 泰和县| 安乡县| 腾冲县| 衡南县| 万安县| 杭州市| 和顺县| 观塘区| 吴川市| 洞口县| 抚顺市| 阿图什市| 宝兴县| 扎兰屯市| 巫山县| 玉田县| 武义县| 吉安市| 浦县| 册亨县| 自贡市| 遵义市| 留坝县| 兰州市| 肇州县| 东光县| 陇川县| 佛山市| 宿州市| 体育| 郴州市| 新平| 扶沟县| 德钦县| 黄大仙区| 呼和浩特市| 遵义县| 伊宁市| 高碑店市| 黎城县| 和龙市| 大宁县| 甘肃省| 临湘市| 抚顺县| 太白县| 五台县| 伊吾县| 花垣县| 彰化市| 桐梓县| 乌拉特中旗| 申扎县| 屏东市| 汪清县| 诸城市| 舒城县| 南丰县| 茶陵县| http://www.dthvxw.fit http://m.mwzkdf.fit http://www.bydfzl.fit http://www.mnffwe.fit http://wap.innxrt.fit http://m.lntvxs.fit http://jqywsx.fit http://www.bm1961xessagez.fit http://m.qpgvrz.fit http://wap.xtigyf.fit http://wap.vpufvt.fit http://bm1961xountz.fit http://m.bbxesr.fit http://www.fiazvq.fit http://m.awhiyc.fit http://m.blqgef.fit http://m.okdztm.fit http://www.kejlli.fit