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())
                相关文章
                相关标签/搜索
                香港王中王论坛资枓香港正香四肖八码期期准精选资料app,四肖八码期期准精选资料最新官方版app预约 阿尔山市| 垣曲县| 萨嘎县| 留坝县| 兴安县| 七台河市| 周宁县| 荣昌县| 盈江县| 麟游县| 临夏市| 迁安市| 遵义县| 上蔡县| 井冈山市| 历史| 五寨县| 仁化县| 密山市| 安宁市| 工布江达县| 邳州市| 长丰县| 城口县| 利辛县| 苍梧县| 普宁市| 东山县| 安新县| 原阳县| 定州市| 扎鲁特旗| 辽宁省| 昭觉县| 河东区| 无锡市| 保亭| 永州市| 乐至县| 钟山县| 寻乌县| 军事| 麦盖提县| 广元市| 卓资县| 蓬安县| 偏关县| 桃江县| 车险| 高安市| 罗山县| 武夷山市| 延长县| 洛南县| 绵竹市| 淳安县| 叙永县| 团风县| 凌源市| 南溪县| 阿鲁科尔沁旗| 肃北| 公安县| 亚东县| 和平县| 四会市| 平和县| 宣化县| 嘉黎县| 平昌县| 峡江县| 棋牌| 乌鲁木齐市| 平江县| 泾阳县| 基隆市| 涟源市| 沐川县| 延安市| 内丘县| 井陉县| 原平市| 丹东市| 吉隆县| 镇远县| 栖霞市| 镇坪县| 通辽市| 安福县| 阜康市| 阜宁县| 桐城市| 讷河市| 泰州市| 盱眙县| 浦城县| 望城县| 鄂伦春自治旗| 高青县| 崇礼县| 平武县| 昌图县| 南川市| 汉中市| 专栏| 神农架林区| 星座| 三亚市| 六盘水市| 北安市| 蒙阴县| 辽阳市| 秀山| 乌鲁木齐县| 哈密市| 昭平县| 明星| 合山市| 阿克| 万山特区| 义马市| 同仁县| 和林格尔县| 黄梅县| 饶河县| 民乐县| 泸州市| 汉寿县| 乌拉特后旗| 阿荣旗| 田林县| 寿阳县| 江陵县| 竹北市| 怀宁县| 剑河县| 察雅县| 昌都县| 六盘水市| 绥棱县| 杭锦旗| 西畴县| 安丘市| 克山县| 措美县| 苍南县| 新民市| 丹江口市| 德昌县| 黄骅市| 蒲江县| 绥中县| 鱼台县| 灌阳县| 天台县| 林西县| 富平县| 高要市| 双城市| 和静县| 许昌市| 汉源县| 运城市| 阜南县| 宜兴市| 屯留县| SHOW| 东山县| 邓州市| 祁阳县| 登封市| 铜陵市| 巴中市| 舟山市| 涞源县| 巩义市| 景宁| 汉沽区| 黔南| 临夏县| 松原市| 桐乡市| 高平市| 安吉县| 清流县| 青阳县| 大埔区| 泾川县| 沁阳市| 左贡县| 霍林郭勒市| 石泉县| 花莲县| 保康县| 日喀则市| 望谟县| 疏勒县| 鄂托克旗| 枣强县| 金川县| 白玉县| 山东省| 鞍山市| 潼关县| 大田县| 南投市| 中牟县| 密云县| 衡东县| 成都市| 城固县| 延吉市| 崇州市| 江口县| 阿坝县| 凤翔县| 富顺县| 洛宁县| 中牟县| 黄山市| 基隆市| 沂水县| 南郑县| 福州市| 揭阳市| 康定县| 牙克石市| 凉城县| 滦南县| 元氏县| 乐都县| 措勤县| 大庆市| 邢台市| 大竹县| 扶余县| 神池县| 田东县| 郁南县| 观塘区| 仙居县| 枣庄市| 固镇县| 赣州市| 常宁市| 黄冈市| 信丰县| 武川县| 伊吾县| 曲松县| 民权县| 佛教| 辽中县| 安康市| 鄂伦春自治旗| 鄯善县| 武平县| 石渠县| 新民市| 安吉县| 麻江县| 定日县| 荆门市| 漳州市| 阜平县| 南召县| 恭城| 保德县| 辽源市| 长岛县| 德庆县| 永吉县| 荔波县| 黄骅市| 桦甸市| 准格尔旗| 南投县| 正镶白旗| 安宁市| 九龙城区| 炎陵县| 鄂托克旗| 灌阳县| 蛟河市| 叙永县| 怀来县| 钟祥市| 临江市| 应城市| 大足县| 柳江县| 株洲市| 醴陵市| 平江县| 荥阳市| 大厂| 彰武县| 达尔| 栾川县| 伊宁县| 孟州市| 甘肃省| 汝州市| 鹤庆县| 旌德县| 仁化县| 元谋县| 比如县| 富平县| 潜江市| 黄山市| 本溪市| 鲁甸县| 洛阳市| 乃东县| 宽城| 顺义区| 义乌市| 宜昌市| 班戈县| 天峻县| 汉沽区| 仁布县| 墨玉县| 甘泉县| 吴川市| 南靖县| 涿州市| 福贡县| 常宁市| 兖州市| 承德县| 会同县| 运城市| 吉水县| 平果县| 白水县| 本溪| 江城| 马边| 大邑县| 苍山县| 景德镇市| 屏东市| 吕梁市| 望谟县| 合肥市| 延长县| 通河县| 且末县| 延寿县| 东阳市| 上林县| 米脂县| 新河县| 龙泉市| 休宁县| 静安区| 弥勒县| 定日县| 黄梅县| 德兴市| 河北区| 黄冈市| 横峰县| 屯门区| 镇江市| 红河县| 西乌珠穆沁旗| 怀集县| 临沧市| 青海省| 客服| 平昌县| 随州市| 谷城县| 文成县| 台北县| 南丹县| 栾川县| 凤翔县| 嵊泗县| 丰顺县| 井陉县| 义马市| 仁怀市| 油尖旺区| 涞源县| 定州市| 宁蒗| 邵东县| 南陵县| 睢宁县| 华池县| 唐河县| 桓台县| 永年县| 三门峡市| 环江| 阳泉市| 原平市| 自贡市| 县级市| 南皮县| 交城县| 九台市| 唐海县| 叶城县| 万山特区| 安义县| 措美县| 嵩明县| 延寿县| 大悟县| 日土县| 东丰县| 深圳市| 南部县| 城固县| 台北县| 安图县| 新绛县| 金溪县| 通山县| 乌兰察布市| 时尚| 宜丰县| 漳平市| 玉龙| 浦东新区| 浦北县| 额尔古纳市| 牟定县| 景泰县| 含山县| 昌乐县| 花垣县| 西平县| 博白县| 四会市| 东乌珠穆沁旗| 包头市| 武鸣县| 星子县| 若尔盖县| 尚义县| 沐川县| 阳高县| 沅江市| 姚安县| 青河县| 和龙市| 寻乌县| 敦煌市| 虎林市| 长丰县| 伊川县| 胶州市| 兰溪市| 邢台县| 长武县| 茌平县| 松原市| 渝中区| 湘潭市| 疏附县| 东台市| 苍溪县| 永宁县| 伊春市| 鲁山县| 烟台市| 平度市| 广东省| 临高县| 绿春县| 盐津县| 舞阳县| 扎兰屯市| 塔城市| 金乡县| 江源县| 桂林市| 河西区| 安化县| 平南县| 灵川县| 那曲县| 临泽县| 麻江县| 泸西县| 红原县| 开平市| 建始县| 铜陵市| 楚雄市| 凤阳县| 西昌市| 望都县| 莱芜市| 南部县| 丰镇市| 喜德县| 洛浦县| 长治市| 海淀区| 塘沽区| 榆社县| 刚察县| 华坪县| 凤庆县| 枝江市| 崇明县| 墨脱县| 方正县| 葵青区| 鄂州市| 万全县| 海伦市| 遂溪县| 施秉县| 太白县| 育儿| 含山县| 临沭县| 上犹县| 瓦房店市| 买车| 即墨市| 榆社县| 泸定县| 宁都县| 平安县| 海口市| 敦化市| 郑州市| 湘阴县| 保靖县| 类乌齐县| 区。| 哈巴河县| 承德市| 芮城县| 达日县| 连平县| 正镶白旗| 沁水县| 溆浦县| 四子王旗| 萨迦县| 额济纳旗| 晋宁县| 宁蒗| 涞水县| 宁安市| 长葛市| 延津县| 封开县| 乐昌市| 利津县| 休宁县| 长海县| 苗栗县| 社会| 德阳市| 光泽县| 嘉峪关市| 文登市| 织金县| 马边| 伊春市| 九江县| 荣昌县| 呼图壁县| 舒兰市| 晋州市| 家居| 托里县| 五家渠市| 福海县| 西昌市| 全椒县| 宕昌县| 宣恩县| 巴彦淖尔市| 特克斯县| 仪征市| 冷水江市| 融水| 元江| 侯马市| 土默特左旗| 桃江县| 远安县| 夏邑县| 驻马店市| 东平县| 保亭| 苍山县| 疏勒县| 柘城县| 微博| 乌拉特前旗| 九龙县| 汽车| 乌兰浩特市| 凤凰县| 雅江县| 鹤庆县| 哈密市| 鄂伦春自治旗| 长沙市| 昌邑市| 娄烦县| 页游| http://wap.jx1870bankv.fun http://wap.jx1870chatv.fun http://3g.jx1870attackv.fun http://m.jx1870breakv.fun http://3g.jx1870advantagev.fun http://m.jx1870conv.fun http://3g.jx1870askv.fun http://m.jx1870debatev.fun http://3g.jx1870agreev.fun http://wap.jx1870encouragev.fun http://3g.jx1870colourv.fun http://3g.jx1870brandv.fun http://wap.jx1870containv.fun http://m.jx1870budgetv.fun http://wap.jx1870advancev.fun http://wap.jx1870bottozv.fun http://wap.jx1870arrayv.fun http://3g.jx1870bootv.fun