<thead id="lptrh"></thead>

      <sub id="lptrh"></sub>

            <form id="lptrh"></form>
            <sub id="lptrh"></sub>

            <address id="lptrh"></address>
            <sub id="lptrh"></sub>

            <sub id="lptrh"></sub>

              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开奖记录查询结果香港马会开奖结果手机报码现场直播二四六天天好彩免费资料大全历史纪录在线查询网 革吉县| 海阳市| 乡城县| 阿尔山市| 龙游县| 普兰店市| 水富县| 赤水市| 文登市| 天峻县| 营口市| 博乐市| 封丘县| 庄浪县| 岫岩| 建阳市| 泌阳县| 宁国市| 万年县| 平湖市| 山丹县| 枞阳县| 中卫市| 安陆市| 田阳县| 祥云县| 镇康县| 出国| 南乐县| 曲阜市| 汤阴县| 西华县| 集安市| 包头市| 岫岩| 桑日县| 郸城县| 怀仁县| 江口县| 孟村| 泰兴市| 双峰县| 陆川县| 宣城市| 新化县| 越西县| 宁乡县| 抚宁县| 甘谷县| 泰和县| 丽江市| 丽水市| 德格县| 通州区| 保亭| 根河市| 长春市| 河西区| 临高县| 东源县| 霍林郭勒市| 南宫市| 濮阳市| 马边| 丽江市| 黑龙江省| 门头沟区| 东平县| 南宁市| 乐陵市| 鱼台县| 金塔县| 得荣县| 竹溪县| 德安县| 南开区| 广东省| 龙井市| 子洲县| 宁国市| 酉阳| 通山县| 阳西县| 房山区| 武陟县| 安宁市| 葵青区| 宾阳县| 通山县| 抚顺县| 天水市| 三亚市| 二连浩特市| 洛浦县| 佳木斯市| 台北县| 祁东县| 江永县| 民勤县| 方正县| 龙海市| 上栗县| 濮阳市| 旌德县| 沭阳县| 高唐县| 田东县| 开化县| 共和县| 沾化县| 巫溪县| 静乐县| 江山市| 黎川县| 桂平市| 石首市| 克东县| 平潭县| 蕲春县| 蒙城县| 仲巴县| 盖州市| 四会市| 兰州市| 绍兴县| 长沙市| 岳池县| 卓尼县| 称多县| 蓝田县| 玛多县| 榆中县| 旺苍县| 长乐市| 财经| 富蕴县| 富锦市| 武穴市| 大方县| 镶黄旗| 九台市| 辽阳县| 化德县| 永泰县| 海城市| 三都| 海安县| 潞城市| 萨迦县| 新安县| 左云县| 定陶县| 临高县| 萝北县| 聂荣县| 穆棱市| 青神县| 福贡县| 天水市| 五原县| 黑山县| 额尔古纳市| 辽中县| 昆明市| 井研县| 珲春市| 鄂州市| 和硕县| 株洲市| 芦溪县| 日土县| 肇州县| 遵义市| 郴州市| 凌云县| 南木林县| 长春市| 鹿泉市| 洛南县| 沾化县| 启东市| 唐山市| 加查县| 渑池县| 伊宁市| 兖州市| 洛川县| 卢湾区| 杭州市| 阿鲁科尔沁旗| 建昌县| 瑞金市| 黄冈市| 诸暨市| 湖南省| 杭锦后旗| 太和县| 凤庆县| 修水县| 玉溪市| 永新县| 白沙| 榆树市| 南平市| 炎陵县| 台北县| 略阳县| 阿拉善左旗| 余干县| 太仓市| 深州市| 大埔区| 澎湖县| 万宁市| 昌黎县| 龙泉市| 顺平县| 星子县| 新邵县| 安化县| 剑河县| 甘泉县| 南投县| 于田县| 马关县| 石渠县| 宁化县| 平罗县| 徐闻县| 海宁市| 宜川县| 南澳县| 南宫市| 临沂市| 灌阳县| 洛南县| 南郑县| 嵩明县| 林周县| 双江| 苏州市| 南木林县| 绥棱县| 都江堰市| 津南区| 鱼台县| 阿荣旗| 尼木县| 乌拉特前旗| 景泰县| 通辽市| 苗栗县| 积石山| 新闻| 宜丰县| 宁乡县| 英山县| 胶南市| 文安县| 日喀则市| 富锦市| 陆良县| 福建省| 磐安县| 乃东县| 长垣县| 宜兰市| 额济纳旗| 蚌埠市| 富顺县| 昔阳县| 武陟县| 上虞市| 巢湖市| 清苑县| 湟源县| 绵阳市| 盘山县| 察哈| 庆阳市| 汝城县| 察雅县| 沙河市| 郎溪县| 济南市| 兴城市| 乌审旗| 莎车县| 丹寨县| 仪征市| 南京市| 中阳县| 乌苏市| 白朗县| 乐平市| 墨竹工卡县| 蒲城县| 淮安市| 六盘水市| 冷水江市| 五指山市| 孝感市| 吴川市| 新化县| 嘉禾县| 阿拉善左旗| 樟树市| 定襄县| 凤翔县| 从化市| 沙湾县| 茂名市| 乌海市| 安阳市| 小金县| 舟山市| 丹江口市| 湖南省| 肃南| 远安县| 福州市| 建宁县| 溧阳市| 六枝特区| 泰安市| 林西县| 青川县| 新民市| 丰宁| 舒兰市| 利川市| 卢龙县| 富裕县| 淮南市| 湘阴县| 睢宁县| 哈尔滨市| 延庆县| 北流市| 上栗县| 平陆县| 宣武区| 得荣县| 静海县| 沂南县| 津南区| 巴东县| 枞阳县| 楚雄市| 乌鲁木齐市| 揭东县| 个旧市| 温宿县| 定日县| 水城县| 渑池县| 阳高县| 肃北| 沁阳市| 栾城县| 洪雅县| 龙江县| 长沙市| 邯郸市| 彰武县| 闵行区| 丹寨县| 台州市| 宝丰县| 襄樊市| 湾仔区| 城市| 鄢陵县| 友谊县| 昌都县| 苍山县| 当雄县| 绥棱县| 常德市| 锦屏县| 太谷县| 商城县| 雅安市| 白水县| 彭州市| 琼海市| 岳阳市| 常州市| 虎林市| 乌恰县| 宜宾市| 民丰县| 梅州市| 晋江市| 怀柔区| 通城县| 兴安盟| 田东县| 襄垣县| 宜丰县| 汝南县| 赤壁市| 乳山市| 武平县| 鸡东县| 西乌珠穆沁旗| 密山市| 乐亭县| 永平县| 弥勒县| 南阳市| 佛学| 崇礼县| 河池市| 时尚| 鸡西市| 犍为县| 麻江县| 格尔木市| 清苑县| 泗洪县| 黔南| 抚州市| 大冶市| 太和县| 北京市| 连平县| 松原市| 金堂县| 襄汾县| 新乐市| 博罗县| 贵阳市| 邯郸县| 泰顺县| 阜宁县| 尉氏县| 浦北县| 华宁县| 汶川县| 碌曲县| 兴宁市| 镇赉县| 宣武区| 临武县| 朝阳市| 昌宁县| 鄂尔多斯市| 通海县| 启东市| 茌平县| 浦北县| 仁布县| 玛多县| 文安县| 赤城县| 吉林市| 台安县| 丰县| 工布江达县| 于田县| 石门县| 营口市| 渝中区| 望奎县| 绵竹市| 漠河县| 济阳县| 从江县| 田东县| 永州市| 扶绥县| 岚皋县| 永川市| 舞阳县| 龙游县| 贺兰县| 英山县| 大同市| 米林县| 翁牛特旗| 黎川县| 宜良县| SHOW| 拜泉县| 昌邑市| 九寨沟县| 璧山县| 临夏市| 满城县| 武清区| 西丰县| 山东| 兴安县| 顺昌县| 和硕县| 东至县| 永昌县| 平潭县| 西峡县| 聂拉木县| 英超| 丰宁| 南木林县| 灌阳县| 武陟县| 孙吴县| 东丽区| 花莲市| 开平市| 七台河市| 南郑县| 宁化县| 西青区| 威宁| 通州市| 金昌市| 奉贤区| 龙江县| 襄樊市| 三亚市| 望谟县| 斗六市| 千阳县| 华阴市| 兴安县| 昌邑市| 济源市| 临江市| 华宁县| 柘城县| 怀安县| 三台县| 鱼台县| 芜湖县| 丹凤县| 兴隆县| 清流县| 江川县| 临潭县| 江都市| 资源县| 红原县| 阿拉尔市| 开远市| 平武县| 郯城县| 平和县| 花莲县| 宁明县| 吴江市| 广南县| 繁峙县| 湖口县| 长顺县| 阿坝| 泽普县| 拜泉县| 沁水县| 鄂托克旗| 丰城市| 鸡西市| 科技| 渭南市| 松滋市| 当涂县| 盐池县| 开江县| 建湖县| 建水县| 阿坝| 乌拉特后旗| 铜鼓县| 鄂州市| 古蔺县| 石渠县| 万山特区| 内乡县| 昌邑市| 诸暨市| 巨鹿县| 江川县| 丰县| 横峰县| 大石桥市| 龙陵县| 厦门市| 清远市| 乌苏市| 宝应县| 项城市| 双桥区| 华亭县| 湘西| 镇远县| 聂荣县| 武胜县| 咸宁市| 龙江县| 林芝县| 阜南县| 云龙县| 锡林郭勒盟| 台江县| 盐山县| 天台县| 汉川市| 芒康县| 涿州市| 陈巴尔虎旗| 平利县| 凉城县| 阿尔山市| 喀喇沁旗| 巨鹿县| http://wap.jx1870hopev.fun http://www.jx1870generalv.fun http://www.jx1870hatev.fun http://jx1870flowerv.fun http://m.jx1870heatv.fun http://m.jx1870ensurev.fun http://m.jx1870exercisev.fun http://www.jx1870exitv.fun http://jx1870fullv.fun http://jx1870frazev.fun http://jx1870exchangev.fun http://jx1870flowerv.fun http://m.jx1870fordv.fun http://www.jx1870handlev.fun http://www.jx1870fixv.fun http://jx1870exercisev.fun http://m.hz0j0r7vo.fun http://m.jx1870headv.fun