from threading import Event
from threading import Thread
import time
# 調用Event實例化出對象
e = Event()
#
# # 若該方法出現(xiàn)在任務中，則為False，阻塞
# e.wait() # False
# # 若該方法出現(xiàn)在任務中，則將其他線程的False改為True，進入就緒態(tài)和運行態(tài)
# e.set() # True
def light():
 print('紅燈亮...')
 time.sleep(5)
 # 應該發(fā)出信號，告訴其他線程準備執(zhí)行
 e.set() # 將car中的False變?yōu)門rue
 print('綠燈亮...')
def car(name):
 print('正在等紅燈...')
 # 讓所有汽車任務進入阻塞態(tài)
 e.wait() # False
 print(f'{name}正在加速飄逸...')
# 讓一個light線程控制多個car線程
t = Thread(target=light)
t.start()

for i in range(10):
 t = Thread(target=car, args=(f'汽車{i}號', ))
 t.start()

from concurrent.futures import ThreadPoolExecutor
import time
pool = ThreadPoolExecutor(5) # 5代表只能開啟5個進程, 不加默認使用cpu的進程數(shù)
# ThreadPoolExecutor(5) # 5代表只能開啟5個線程
# pool.submit() #異步提交任務， 括號里傳函數(shù)地址
def task():
 print('線程任務開始了...')
 time.sleep(1)
 print('線程任務結束了...')
for line in range(5):
 pool.submit(task)

from concurrent.futures import ThreadPoolExecutor
import time

pool = ThreadPoolExecutor(5) # 5代表只能開啟5個進程, 不加默認使用cpu的進程數(shù)

# ThreadPoolExecutor(5) # 5代表只能開啟5個線程
# pool.submit() #異步提交任務， 括號里傳函數(shù)地址
def task():
 print('線程任務開始了...')
 time.sleep(1)
 print('線程任務結束了...')
 return 123
# 回調函數(shù)
def call_back(res):
 print(type(res))
 res2 = res.result() # 注意：賦值操作不要與接收的res同名
 print(res2)
for line in range(5):
 pool.submit(task).add_done_callback(call_back)

import time

def func1():
 for i in range(10000000):
  i+1

def func2():
 for i in range(10000000):
  i+1
start = time.time()
func1()
func2()
stop = time.time()
print(stop - start) # 1.0312113761901855


# 基于yield實現(xiàn)并發(fā) 在計算密集型的情況下效率更低

def func1():
 while True:
  10000000+1
  yield

def func2():
 g = func1()
 for i in range(10000000):
  i+1
  next(g) # 每次執(zhí)行next相當于切換到func1下面
start = time.time()
func2()
stop = time.time()
print(stop - start) # 1.3294126987457275

import time
from gevent import monkey

monkey.patch_all() # 可以監(jiān)聽該程序下所有的IO操作
from gevent import spawn, joinall # 用于做切換 + 保存狀態(tài)
def func1():
 print('1')
 time.sleep(1) # IO操作
def func2():
 print('2')
 time.sleep(3)
def func3():
 print('3')
 time.sleep(5)
start = time.time()
s1 = spawn(func1)
s2 = spawn(func2)
s3 = spawn(func3)

s1.join() # 發(fā)送信號，相當于等待自己（在單線程的情況下）
s2.join()
s3.join()

# joinall((s1, s2, s3)) # 一個個執(zhí)行很麻煩，可以用joinall把這些全部裝進去

end = time.time()
print(end - start) # 5.006161451339722

from gevent import monkey
from gevent import spawn
import socket

monkey.patch_all()
server = socket.socket()
server.bind(('127.0.0.1', 9999))
server.listen(5)

def task(conn):
 while True:
  try:
   data = conn.recv(1024)
   if len(data) == 0:
    break
   print(data.decode('utf-8'))
   send_data = data.upper()
   conn.send(send_data)

  except Exception:
   break
 conn.close()
def server2():
 while True:
  conn, addr = server.accept()
  print(addr)
  spawn(task, conn)
if __name__ == '__main__':
 s = spawn(server2)
 s.join()

import socket
from threading import Thread, current_thread

def client():
 client = socket.socket()
 client.connect(('127.0.0.1', 9999))

 number = 0
 while True:
  send_data = f'{current_thread().name} {number}'
  client.send(send_data.encode('utf-8'))

  data = client.recv(1024)
  print(data.decode('utf-8'))
  number += 1


for i in range(400):
 t = Thread(target=client)
 t.start()