1.GIL锁.

GIL锁: 全局解释器锁. 就是一个把互斥锁,将并发变成串行,同一时刻只能有一个线程使用共享资源,牺牲效率,保证数据安全.

Ipython: 交互式解释器: 可以不全代码

Jython: java 字节码剩下的一样.

pypy: 动态编译: JAT技术. 技术缺陷,bug.

设置全局解释锁: GIL

1. 保证解释器里面的数据安全.

   当时开发py语言时,只有单核,

2. 强行加锁: 减轻了你开发的人员的负担.

双刃剑: 加了这把锁,带来什么问题?

带来的问题1:

​ 单进程的多线程不能利用多核. 诟病之一.

​ 多进程的多线程可以利用多核.

带来的问题2:

​ 感觉上不能并发的执行问题.???

讨论: 单核处理IO阻塞的多线程,与多核处理IO阻塞的多线程效率差不多.

老师,由于有这个锁,单个进程多线程不能利用多核,为什么不去掉?

不能去掉,源码太多,改不动了.

多核:

总结:

​ 多核的前提下:
​ 如果任务Io密集型: 多线程并发.

​ 如果任务计算密集型: 多进程并发.

2.验证Cpython的并发效率.

1. GIL锁与互斥锁的关系.

   GIL锁:

   

   

   2.进程池线程池.

   '池': 容器, 进程池: 放置进程的一个容器, 线程池: 放置线程的一个容器.

   完成了一个简单的socket通信, 服务端必须与一个客户端交流完毕并且这个客户端断开连接之后,服务端才能接待下一个客户端.....

   import socket
   from threading import Thread
   def communication(conn):
       while 1:
           try:
               from_client_data = conn.recv(1024)  # 阻塞
               print(from_client_data.decode('utf-8'))
   
               to_client_data = input('>>>').strip()
               conn.send(to_client_data.encode('utf-8'))
           except Exception:
               break
       conn.close()
   
   def customer_service():
       server = socket.socket()
       server.bind(('127.0.0.1', 8080))
       server.listen()
       while 1:
           conn,addr = server.accept()  # 阻塞
           print(f'{addr}客户:')
           t = Thread(target=communication,args=(conn,))
           t.start()
       server.close()
   if __name__ == '__main__':
       customer_service()

   客户端:

   import socket
   client = socket.socket()
   client.connect(('127.0.0.1', 8080))
   while 1:
       to_server_data = input('>>>').strip()
       client.send(to_server_data.encode('utf-8'))
       from_server_data = client.recv(1024)
       print(f'客服回信: {from_server_data.decode("utf-8")}')
   client.close()

   线程即使开销小,你的电脑不可以无限的开线程,我们应该对线程(进程)做数量的限制.在计算机的能满足的最大情况下,更多的创建线程(进程).

   线程池好,进程池好?

   多线程,多进程.: IO 计算