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())
          相关文章
          相关标签/搜索
          三十码期期必中√资料今晚六给彩开奖结果,白小姐中特玄机,六开彩开奖现场直播,2017开奖记录开奖结果,开马现场直播,马报免费资料2017大全 塘沽区| 临泉县| 桦甸市| 绵阳市| 房山区| 年辖:市辖区| 宁南县| 龙游县| 广河县| 东至县| 得荣县| 泰安市| 施秉县| 天津市| 庄浪县| 佛山市| 东阳市| 乌审旗| 侯马市| 林芝县| 诸暨市| 乌兰浩特市| 肃南| 长岛县| 金溪县| 瓮安县| 晋中市| 当涂县| 岳阳县| 江津市| 册亨县| 山东省| 海兴县| 岳普湖县| 崇州市| 福清市| 那曲县| 长宁区| 绵阳市| 托里县| 桓台县| 虞城县| 广州市| 梓潼县| 澄迈县| 新疆| 兴宁市| 邹城市| 铜鼓县| 广平县| 龙州县| 乌兰浩特市| 本溪| 怀来县| 孝感市| 罗江县| 沁源县| 凌云县| 龙川县| 宜昌市| 湖北省| 应城市| 五台县| 贵德县| 永胜县| 东平县| 富蕴县| 旌德县| 弥勒县| 新安县| 柳州市| 玛曲县| 迁西县| 涞水县| 商都县| 深水埗区| 武乡县| 九寨沟县| 云南省| 年辖:市辖区| 深水埗区| 常宁市| 双辽市| 稻城县| 莱阳市| 清水县| 神池县| 万荣县| 龙南县| 昆明市| 西林县| 拉萨市| 息烽县| 徐闻县| 海安县| 昌黎县| 安西县| 都昌县| 凤翔县| 镇江市| 平乐县| 吉木乃县| 铜陵市| 南雄市| 鲁甸县| 志丹县| 贵德县| 太白县| 邵阳市| 海盐县| 宝山区| 基隆市| 宜宾市| 阜新市| 上林县| 石楼县| 上蔡县| 金沙县| 耿马| 军事| 陕西省| 托克逊县| 日土县| 德江县| 项城市| 张家港市| 沙湾县| 卫辉市| 吴忠市| 盱眙县| 清镇市| 锡林浩特市| 凯里市| 体育| 平安县| 留坝县| 志丹县| 伊宁市| 旬阳县| 中牟县| 长海县| 思茅市| 垫江县| 濮阳县| 北辰区| 瑞昌市| 潞西市| 青田县| 凤冈县| 澳门| 滦平县| 平湖市| 台山市| 马山县| 齐河县| 吉林省| 泾川县| 南陵县| 镇原县| 金门县| 凤翔县| 大方县| 长岭县| 临邑县| 旺苍县| 曲水县| 万全县| 平山县| 星座| 赫章县| 蒲江县| 利川市| 景宁| 永丰县| 昌江| 通化县| 泾阳县| 金华市| 普格县| 阿合奇县| 资溪县| 隆昌县| 邛崃市| 康定县| 班戈县| 西吉县| 盐津县| 潮州市| 勃利县| 镇巴县| 阜南县| 壤塘县| 镶黄旗| 汕尾市| 宜兰县| 河北区| 大石桥市| 鄂伦春自治旗| 长顺县| 石门县| 庆元县| 嵊州市| 沁水县| 石屏县| 无棣县| 延边| 闽侯县| 山丹县| 漳州市| 凤翔县| 嘉善县| 忻城县| 思茅市| 平利县| 五峰| 广南县| 水城县| 柳州市| 保靖县| 洞口县| 湖南省| 休宁县| 维西| 淮北市| 潮州市| 岳普湖县| 田林县| 罗平县| 麦盖提县| 商都县| 深泽县| 沽源县| 南宫市| 永清县| 石家庄市| 尼勒克县| 黎平县| 德化县| 怀柔区| 武城县| 璧山县| 西藏| 松江区| 柘城县| 贵港市| 弥勒县| 贡山| 海淀区| 江源县| 潜山县| 临猗县| 神池县| 志丹县| 德州市| 济阳县| 阿拉尔市| 井研县| 房山区| 锡林郭勒盟| 晋宁县| 平罗县| 左云县| 三门县| 齐齐哈尔市| 江安县| 沾益县| 黔西县| 通许县| 汪清县| 陇川县| 伊春市| 宝兴县| 峡江县| 桃园市| 莒南县| 贵港市| 玛纳斯县| 新密市| 共和县| 高邑县| 卢龙县| 永靖县| 苍溪县| 许昌县| 满洲里市| 红河县| 梁山县| 凌源市| 吐鲁番市| 巨野县| 芦山县| 望都县| 土默特左旗| 长宁县| 澄城县| 涿州市| 阳曲县| 平谷区| 甘泉县| 南漳县| 满城县| 晴隆县| 讷河市| 永靖县| 东海县| 冷水江市| 手游| 东明县| 贡觉县| 鄂托克前旗| 井研县| 綦江县| 通海县| 团风县| 镇平县| 万载县| 玉环县| 奎屯市| 淮阳县| 河津市| 梅州市| 图木舒克市| 荔浦县| 离岛区| 枣强县| 盘锦市| 乐平市| 郑州市| http://3g.yqo7j8rl8v.fun http://3g.yqo0j4rl2v.fun http://3g.yqo5j5rl1v.fun http://3g.bo2020results.fun http://3g.bo2020dresss.fun http://3g.gz1980regardc.fun http://3g.yqo8j3rl9v.fun http://3g.bo2020jacks.fun http://3g.gz1980plotc.fun http://3g.yqo2j4rl0v.fun http://3g.bo2020airs.fun http://3g.yqo4j6rl1v.fun http://3g.gz1980winec.fun http://3g.yqo6j3rl8v.fun http://3g.bo2020adventures.fun http://3g.gz1980learnc.fun http://3g.yqo3j0rl1v.fun http://3g.gz1980rangec.fun