<address id="bjbhz"><dfn id="bjbhz"><output id="bjbhz"></output></dfn></address><address id="bjbhz"><dfn id="bjbhz"></dfn></address>
        <address id="bjbhz"><dfn id="bjbhz"></dfn></address>

        <sub id="bjbhz"><var id="bjbhz"><mark id="bjbhz"></mark></var></sub>
          <sub id="bjbhz"><var id="bjbhz"></var></sub>
          <sub id="bjbhz"><var id="bjbhz"><ins id="bjbhz"></ins></var></sub>

          <address id="bjbhz"><var id="bjbhz"></var></address>
          <address id="bjbhz"><dfn id="bjbhz"></dfn></address>

          <address id="bjbhz"><listing id="bjbhz"><ins id="bjbhz"></ins></listing></address>

            <thead id="bjbhz"></thead>

          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())
          相关文章
          相关标签/搜索
          管家婆香港2018年资料四肖期期准铁算盘4887开奖结果四肖三期内必出刘伯温6374cm刘伯温168最快开奖现场开马开奖结果天天彩票 上思县| 白河县| 会宁县| 阳朔县| 宁陕县| 瑞昌市| 凤山县| 丰城市| 伊金霍洛旗| 旌德县| 弋阳县| 金寨县| 昌图县| 林芝县| 阳东县| 墨江| 从江县| 登封市| 车致| 三明市| 颍上县| 长丰县| 长春市| 视频| 元氏县| 当阳市| 尚志市| 永川市| 福贡县| 芮城县| 静安区| 益阳市| 拜城县| 平谷区| 红桥区| 海原县| 雷山县| 沾化县| 科尔| 上杭县| 胶南市| 建昌县| 阿图什市| 永川市| 台湾省| 象山县| 松江区| 定安县| 英吉沙县| 林州市| 孟州市| 大冶市| 宜阳县| 漳州市| 甘南县| 布拖县| 江阴市| 德格县| 和林格尔县| 清水县| 巢湖市| 始兴县| 陕西省| 衡南县| 衡阳市| 广南县| 织金县| 婺源县| 苏尼特右旗| 密云县| 株洲市| 满洲里市| 广丰县| 河北区| 江北区| 昔阳县| 沅陵县| 涟源市| 岑巩县| 伊宁县| 蓝田县| 丹凤县| 新源县| 镇巴县| 吴川市| 吉安县| 广灵县| 台中市| 泗洪县| 彰化市| 漳平市| 洛扎县| 兴化市| 渝北区| 施甸县| 时尚| 建始县| 威海市| 镇坪县| 剑川县| 改则县| 宝清县| 阳高县| 青神县| 石楼县| 平果县| 慈溪市| 宜良县| 鄂托克旗| 大同市| 宣城市| 双峰县| 平罗县| 屏边| 日土县| 册亨县| 沁阳市| 绩溪县| 昆山市| 天镇县| 扎囊县| 永康市| 库车县| 阳西县| 营口市| 郑州市| 张北县| 封丘县| 罗平县| 务川| 济阳县| 浦北县| 禹州市| 全椒县| 虎林市| 太仓市| 大埔区| 金阳县| 池州市| 张家港市| 宜城市| 河东区| 同江市| 常德市| 瑞丽市| 博湖县| 长海县| 舟山市| 秭归县| 梅州市| 开封市| 拜泉县| 阜南县| 白朗县| 正镶白旗| 盐津县| 金乡县| 额尔古纳市| 新源县| 张家港市| 永嘉县| 饶平县| 迁安市| 彰武县| 邵武市| 昌乐县| 京山县| 丹棱县| 沛县| 阳谷县| 津南区| 同心县| 宁都县| 汽车| 乌审旗| 高唐县| 边坝县| 佛教| 翁源县| 武汉市| 鹿邑县| 双峰县| 改则县| 湖北省| 黑山县| 酒泉市| 鹿邑县| 静海县| 合山市| 赞皇县| 双流县| 图们市| 南皮县| 德安县| 丰都县| 剑河县| 阿坝| 蓬安县| 普安县| 高陵县| 天门市| 连江县| 永济市| 延边| 宁波市| 高陵县| 仪征市| 龙陵县| 彭泽县| 深圳市| 宕昌县| 石首市| 苗栗县| 广汉市| 新龙县| 宜阳县| 巩义市| 平阴县| 磐石市| 呼和浩特市| 鹤壁市| 临江市| 丹寨县| 西林县| 逊克县| 墨竹工卡县| 衡阳市| 墨脱县| 饶阳县| 清丰县| 金川县| 怀来县| 缙云县| 建宁县| 莱芜市| 长乐市| 靖州| 闵行区| 云龙县| 四会市| 安塞县| 宁国市| 贵州省| 上高县| 广宁县| 天水市| 湖州市| 名山县| 吴忠市| 祁连县| 九龙城区| 河北省| 和静县| 安宁市| 永川市| 闽清县| 行唐县| 宣汉县| 岢岚县| 瓮安县| 治县。| 宝应县| 察雅县| 屯留县| 鹤峰县| 江孜县| 修文县| 南投县| 焉耆| 白山市| 古田县| 桦甸市| 沙湾县| 青神县| 监利县| 承德市| 华池县| 依安县| 溆浦县| 临高县| 太谷县| 内黄县| 泾阳县| 盐池县| 阿瓦提县| 内丘县| 绥棱县| 绩溪县| 青田县| 北安市| 特克斯县| 九龙县| 枣庄市| 商都县| 施甸县| 河东区| 清镇市| 深州市| 内黄县| 罗平县| 曲麻莱县| 克拉玛依市| 齐齐哈尔市| 神农架林区| 洛阳市| 舞阳县| 信丰县| 睢宁县| 宁国市| 衡东县| 新宁县| 鄂尔多斯市| 安多县| 新邵县| 尼玛县| 垣曲县| 榆树市| 仙居县| 宜章县| 定边县| 保定市| 南京市| 安阳县| 建平县| 阿合奇县| 鹤庆县| 石阡县| 金华市| 江城| 徐闻县| 抚顺县| 东方市| 南康市| 阜城县| 商水县| 宜川县| 长子县| 辽阳市| 额尔古纳市| 崇义县| 蕉岭县| 霍林郭勒市| 响水县| 盘锦市| 台东县| 类乌齐县| 邹城市| 威海市| 崇礼县| 那坡县| 神池县| 许昌市| 江北区| 合阳县| 浮山县| 兴国县| 普陀区| 望江县| 许昌县| 吉林市| 察哈| 舞钢市| 察哈| 乐清市| 健康| 岳西县| 岗巴县| 穆棱市| 萨迦县| 化德县| 武汉市| 乃东县| 旬阳县| 宁武县| 成都市| 嵩明县| 陇南市| 汉阴县| 长沙县| 鲁山县| 蓬溪县| 徐闻县| 长海县| 天水市| 利川市| 略阳县| 平度市| 化隆| 石家庄市| 如皋市| 河源市| 阿瓦提县| 尚义县| 韶山市| 修文县| 连山| 资源县| 临武县| 东阿县| 永康市| 伊宁市| 三亚市| 张家港市| 景洪市| 涡阳县| 精河县| 平武县| 盐池县| 霸州市| 鄂州市| 大关县| 丰都县| 札达县| 广南县| 石屏县| 贡嘎县| 三原县| 大埔县| 安溪县| 台南县| 安阳县| 攀枝花市| 闽清县| 晴隆县| 临汾市| 仙游县| 许昌县| 揭西县| 金塔县| 大理市| 昭觉县| 陇南市| 镇远县| 洪湖市| 长兴县| 迁安市| 凤冈县| 连城县| 灵川县| 沧源| 临汾市| 漳州市| 北流市| 龙里县| 屏东市| 五台县| 沈阳市| 怀远县| 绥化市| 客服| 德庆县| 万安县| 武义县| 山阴县| 岗巴县| 潼南县| 云和县| 建宁县| 于田县| 安丘市| 禄劝| 手游| 霍邱县| 忻城县| 稻城县| 潢川县| 无棣县| 永城市| 建始县| 平乐县| 恩平市| 嘉兴市| 抚顺县| 墨江| 沂源县| 潞城市| 祁东县| 托克托县| 普安县| 临安市| 岑巩县| 伊宁县| 灵石县| 张家港市| 太湖县| 寿光市| 荆门市| 奉新县| 汪清县| 靖州| 东乡县| 晋中市| 志丹县| 泰和县| 泊头市| 梁平县| 安达市| 隆安县| 扶风县| 肃宁县| 博白县| 库车县| 南宫市| 抚顺县| 南通市| 东台市| 友谊县| 肥西县| 七台河市| 高碑店市| 马边| 武胜县| 无为县| 左贡县| 林周县| 柳河县| 蓬溪县| 兴和县| 蕲春县| 红原县| 闻喜县| 漳浦县| 英山县| 长寿区| 兴宁市| 南木林县| 嘉峪关市| 于田县| 梅州市| 福安市| 化德县| 上林县| 漠河县| 宣汉县| 浑源县| 江都市| 游戏| 永和县| 台州市| 冕宁县| 论坛| 保定市| 饶平县| 凤冈县| 宕昌县| 博客| 普安县| 梓潼县| 桃江县| 桓台县| 额尔古纳市| 宽甸| 招远市| 吉木乃县| 道孚县| 喀喇沁旗| 耒阳市| 丹凤县| 桃园市| 乌拉特中旗| 莱阳市| 新安县| 定安县| 通渭县| 广元市| 嘉善县| 图片| 垫江县| 光山县| 莫力| 马山县| 海口市| 抚顺县| 平塘县| 崇礼县| 洪雅县| 湾仔区| 乌苏市| 长海县| 武义县| 洛南县| 内黄县| 龙泉市| 扬中市| 东港市| 永清县| 东乡族自治县| 科尔| 峡江县| 台北市| 崇阳县| 治多县| 卢龙县| 信丰县| 镇远县| 新闻| 木里| 陈巴尔虎旗| 九江县| 年辖:市辖区| 西藏| 巩留县| 长沙市| 嘉兴市| 大丰市| 兴安盟| 曲松县| 衡阳市| 象山县| 宜良县| 察哈| 松江区| 荣昌县| 科技| 土默特左旗| http://www.wtntrt.fit http://www.mzuzqs.fit http://m.fjdsdo.fit http://kekdkp.fit http://m.locduf.fit http://www.cliaes.fit http://giiiod.fit http://www.ndncva.fit http://wap.amoktr.fit http://m.pccwmm.fit http://oqqkty.fit http://www.sdlrot.fit http://wap.alpujc.fit http://m.nqlgry.fit http://ybnspu.fit http://www.wmccrv.fit http://www.jmipms.fit http://wap.bm1961lockz.fit