<address id="nhfpd"></address>

                <sub id="nhfpd"></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())
                  相关文章
                  相关标签/搜索
                  何仙姑六肖期期准资料 南溪县| 肇源县| 尉氏县| 丰原市| 连云港市| 阳城县| 丰城市| 平塘县| 襄城县| 珠海市| 灵山县| 施秉县| 广宁县| 来宾市| 五大连池市| 翁源县| 武义县| 盘锦市| 肇东市| 娱乐| 新余市| 苍溪县| 九江县| 汝城县| 漳州市| 南通市| 德保县| 汝州市| 大竹县| 海淀区| 竹山县| 拉孜县| 奈曼旗| 临江市| 石城县| 镇江市| 读书| 吴江市| 和硕县| 定陶县| 磴口县| 郁南县| 琼中| 安国市| 浦北县| 关岭| 独山县| 岳普湖县| 九龙坡区| 邹城市| 吴忠市| 洛南县| 云南省| 仪陇县| 潍坊市| 大同市| 府谷县| 曲靖市| 防城港市| 肥乡县| 和平县| 耿马| 离岛区| 翁牛特旗| 盐津县| 宝坻区| 东乌| 南平市| 武宁县| 长海县| 湄潭县| 莫力| 汉源县| 离岛区| 通化县| 嘉兴市| 永川市| 潼南县| 什邡市| 建水县| 鹤庆县| 甘谷县| 安顺市| 石阡县| 钦州市| 兰西县| 五家渠市| 黎城县| 贵德县| 虹口区| 大渡口区| 原阳县| 临高县| 铜川市| 报价| 来凤县| 八宿县| 岑溪市| 井冈山市| 阳曲县| 毕节市| 怀远县| 伊春市| 都匀市| 苏州市| 咸阳市| 濮阳县| 同江市| 简阳市| 宕昌县| 德令哈市| 盐亭县| 长垣县| 宁国市| 武冈市| 岳阳市| 汶上县| 象山县| 河北省| 错那县| 仙居县| 尖扎县| 岱山县| 苍山县| 华宁县| 伊宁县| 右玉县| 望奎县| 抚州市| 泰州市| 赤峰市| 土默特右旗| 颍上县| 彩票| 阳春市| 连南| 社会| 阿瓦提县| 长治县| 同仁县| 金溪县| 太原市| 沈阳市| 杭州市| 焦作市| 德昌县| 志丹县| 福海县| 都兰县| 雷波县| 章丘市| 阳城县| 平凉市| 公安县| 健康| 寻甸| 迁西县| 长沙县| 巩留县| 浦江县| 阳谷县| 岑溪市| 子长县| 秦安县| 祁连县| 贵州省| 开阳县| 夹江县| 揭西县| 临海市| 三都| 司法| 和平区| 西峡县| 云林县| 洞头县| 攀枝花市| 屏东市| 珲春市| 金堂县| 和田县| 青铜峡市| 仁化县| 会泽县| 罗山县| 鞍山市| 兴海县| 乐山市| 万安县| 永昌县| 湖北省| 勃利县| 会东县| 塘沽区| 无锡市| 云霄县| 清新县| 胶州市| 项城市| 丹江口市| 霍州市| 迭部县| 广东省| 襄樊市| 微博| 溧阳市| 贵南县| 南靖县| 安龙县| 佛教| 潞西市| 景泰县| 余姚市| 永新县| 濮阳市| 上杭县| 隆回县| 延津县| 聊城市| 吉木萨尔县| 瓮安县| 鸡西市| 汕头市| 怀远县| 江孜县| 峡江县| 宝兴县| 边坝县| 丰台区| 乌兰察布市| 盐池县| 和静县| 游戏| 阳信县| 内江市| 丹寨县| 武夷山市| 大关县| 海安县| 巴楚县| 闽侯县| 灵山县| 台北县| 万全县| 双峰县| 横山县| 秦皇岛市| 涞水县| 嘉善县| 大田县| 伊金霍洛旗| 顺昌县| 新巴尔虎右旗| 客服| 惠安县| 邢台市| 新邵县| 汾阳市| 济源市| 千阳县| 吉安市| 金堂县| 集贤县| 武宁县| 德庆县| 高台县| 兰州市| 葫芦岛市| 安国市| 定兴县| 邢台县| 大方县| 大冶市| 东宁县| 吉隆县| 湖口县| 罗平县| 微山县| 五指山市| 鸡泽县| 潮州市| 平泉县| 张家口市| 成安县| 专栏| 琼海市| 怀化市| 湖北省| 龙岩市| 兴山县| 蚌埠市| 鄱阳县| 喀喇沁旗| 盐源县| 乌海市| 祁阳县| 家居| 来安县| 罗定市| 林周县| 法库县| 会昌县| 连平县| 崇文区| 景宁| 潜江市| 横峰县| 望奎县| 东城区| 临泽县| 仙桃市| 安丘市| 临江市| 虞城县| 泰来县| 廉江市| 景洪市| 汉阴县| 佛教| 道孚县| 大关县| 巴塘县| 富源县| 思茅市| 长葛市| 东乡| 博爱县| 东港市| 福州市| 余江县| 方山县| 驻马店市| 绥宁县| 淳化县| 鹰潭市| 墨玉县| 东光县| 济阳县| 津市市| 禹城市| 东乌珠穆沁旗| 桂东县| 宁安市| 游戏| 江陵县| 孟连| 突泉县| 筠连县| 黎城县| 普格县| 寿阳县| 徐闻县| 陆丰市| 花莲县| 滨海县| 井冈山市| 滕州市| 龙岩市| 曲松县| 常德市| 潜江市| 东台市| 天峻县| 横峰县| 金湖县| 鄯善县| 宁都县| 北宁市| 凤台县| 佛冈县| 阿克陶县| 桦川县| 麻江县| 盐亭县| 桂平市| 和平县| 上栗县| 蒙城县| 扎赉特旗| 前郭尔| 双桥区| 崇仁县| 平乡县| 毕节市| 克什克腾旗| 尼玛县| 榆树市| 无棣县| 应城市| 遂平县| 江油市| 宜君县| 新和县| 宝鸡市| 滦平县| 谢通门县| 株洲市| 大渡口区| 电白县| 灌云县| 万全县| 百色市| 凌源市| 玛多县| 济阳县| 得荣县| 疏勒县| 巨鹿县| 旌德县| 乐陵市| 临沂市| 临安市| 调兵山市| 买车| 普安县| 蓝山县| 宁津县| 普兰店市| 太保市| 应用必备| 德阳市| 靖宇县| 儋州市| 清原| 化德县| 苍溪县| 安多县| 连山| 蒙自县| 锦屏县| 邮箱| 武乡县| 襄垣县| 陆良县| 汨罗市| 香河县| 东港市| 韩城市| 建湖县| 温泉县| 邹平县| 喀什市| 明光市| 安顺市| 哈巴河县| 柳林县| 衢州市| 上虞市| 嘉兴市| 宜昌市| 当阳市| 永新县| 城市| 柳州市| 丰县| 桂林市| 边坝县| 保康县| 仙桃市| 安新县| 桂平市| 沙雅县| 穆棱市| 茶陵县| 林周县| 哈密市| 富阳市| 吉安市| 宜黄县| 浦城县| 康保县| 麻阳| 沭阳县| 本溪市| 庄浪县| 茶陵县| 台东县| 普陀区| 河北省| 合肥市| 舞阳县| 会理县| 泾川县| 博野县| 大田县| 蒙阴县| 虞城县| 鸡西市| 连山| 凭祥市| 邹平县| 黎城县| 北京市| 黔西| 北流市| 柘城县| 台北市| 闽侯县| 澎湖县| 南昌市| 蕉岭县| 绥德县| 阿图什市| 沙湾县| 东乌珠穆沁旗| 京山县| 襄城县| 涡阳县| 宁夏| 广德县| 玉山县| 锦州市| 靖远县| 两当县| 仙居县| 龙陵县| 清水河县| 沧源| 临猗县| 饶阳县| 扎赉特旗| 通化县| 如东县| 榆树市| 土默特右旗| 湖南省| 宜城市| 南城县| 乌兰浩特市| 浦城县| 高邑县| 宜良县| 九江市| 阿合奇县| 郧西县| 庆城县| 虹口区| 乐东| 阜新| 库尔勒市| 丹东市| 奉贤区| 泰兴市| 绍兴市| 太康县| 抚州市| 右玉县| 且末县| 芜湖市| 班玛县| 炎陵县| 新宁县| 禄劝| 德庆县| 五家渠市| 无锡市| 石棉县| 香格里拉县| 怀仁县| 孝义市| 稷山县| 镇江市| 如东县| 鸡东县| 富裕县| 玛多县| 淮阳县| 西城区| 祁阳县| 屏东市| 宁国市| 潼关县| 凉城县| 张家界市| 汽车| 凤台县| 华阴市| 临洮县| 阿克苏市| 太仆寺旗| 牡丹江市| 铜鼓县| 长岛县| 宁明县| 蒙城县| 吉木乃县| 兴文县| 张家口市| 汉沽区| 台山市| 中西区| 新建县| 巫山县| 游戏| 顺昌县| 遂川县| 醴陵市| 石门县| 钦州市| 颍上县| 当阳市| 扶沟县| 普兰店市| 南皮县| 甘德县| 大足县| 宣城市| 富源县| 富锦市| 新化县| 牙克石市| 广河县| 抚远县| 荣昌县| 乌鲁木齐市| http://wap.kdcnod.fit http://www.ddwhyv.fit http://bm1961nickz.fit http://m.vrlolo.fit http://m.hefdoj.fit http://wap.jhhugs.fit http://wap.vugwng.fit http://hwoujy.fit http://wap.ertnzz.fit http://geqwvf.fit http://m.mcybrs.fit http://wap.bm1961nickz.fit http://www.bm1961lookz.fit http://www.tarfxo.fit http://m.wjcvqr.fit http://www.wdwnku.fit http://m.fjnfof.fit http://www.tmmvia.fit