进程池与线程池

线程queue

import queue
q = queue.Queue()#先进先出
q.put('123')    # +1
q.put('qweqwe') #+1
print(q.get())
print(q.get())
# q.task_done() # -1
q.task_done() # -1 
q.join()  ## 会卡在这 如果两个q.task_done()不会卡住

import queue
q = queue.LifoQueue()# 先进后出（堆栈）
q.put('123')    # +1
q.put('qweqwe') #+1
print(q.get())
print(q.get())
q.task_done() # -1
q.task_done() # -1
q.join()  ## 会卡在这 如果两个q.task_done()不会卡住

线程定时器

from threading import Timer
def task():
    print('线程执行了')
    print('线程结束了')
t = Timer(4,task) # 过了4s后开启了一个线程  Timer(时间,函数)
t.start()

线程池与进程池

'''
进程池线程池:
    池的功能限制进程数或线程数.
    什么时候限制?
    当并发的任务数量远远大于计算机所能承受的范围,即无法一次性开启过多的任务数量
    我就应该考虑去限制我进程数或线程数,从保证服务器不崩.


'''


from concurrent.futures import ProcessPoolExecutor,ThreadPoolExecutor
from threading import currentThread
from multiprocessing import current_process
import time

def task(i):
    print(f'{currentThread().name} 在执行任务 {i}')
    # print(f'进程 {current_process().name} 在执行任务 {i}')
    time.sleep(1)
    return i**2

if __name__ == '__main__':
    pool = ThreadPoolExecutor(4) # 池子里只有4个线程
    # pool = ProcessPoolExecutor(4) # 池子里只有4个线程
    fu_list = []
    for i in range(20):
        # pool.submit(task,i) # task任务要做20次,4个线程负责做这个事
        future = pool.submit(task,i) # task任务要做20次,4个进程负责做这个事
        # print(future.result()) # 如果没有结果一直等待拿到结果,导致了所有的任务都在串行
        fu_list.append(future) ## 结果都放在列表中(并行)
    pool.shutdown() # 关闭了池的入口,会等待所有的任务执行完,结束阻塞.
    for fu in fu_list:
        print(fu.result())

通过回调函数优化程序实现与结果并行

from concurrent.futures import ProcessPoolExecutor,ThreadPoolExecutor
from threading import currentThread
from multiprocessing import current_process
import time

def task(i):
    print(f'{currentThread().name} 在执行任务 {i}')
    # print(f'进程 {current_process().name} 在执行任务 {i}')
    time.sleep(1)
    return i**2
def parse(future):
    # 处理拿到的结果
    print(future.result())
if __name__ == '__main__':
    pool = ThreadPoolExecutor(4) # 池子里只有4个线程
    # pool = ProcessPoolExecutor(4) # 池子里只有4个线程
    fu_list = []
    for i in range(20):
        # pool.submit(task,i) # task任务要做20次,4个线程负责做这个事
        future = pool.submit(task,i) # task任务要做20次,4个进程负责做这个事
        future.add_done_callback(parse) (*****) add_done_callback(回调函数)
        # 为当前任务绑定了一个函数,在当前任务执行结束的时候会触发这个函数,
        # 会把future对象作为参数传给函数
        # 这个称之为回调函数,处理完了回来就调用这个函数.
        # print(future.result()) # 如果没有结果一直等待拿到结果,导致了所有的任务都在串行
    # pool.shutdown() # 关闭了池的入口,会等待所有的任务执行完,结束阻塞.
    # for fu in fu_list:
    #     print(fu.result())

socket多线程通信

##server(服务端)
import socket
from threading import Thread,currentThread

def client_demo():
    client=socket.socket(socket.AF_INET,socket.SOCK_STREAM)

    client.connect(('127.0.0.1',8081))
    while True:
        msg = f'{currentThread().name}'
        if len(msg) == 0: continue
        client.send(msg.encode('utf-8'))
        feedback = client.recv(1024)
        print(feedback.decode('utf-8'))
if __name__ == '__main__':
    for i in range(20):
        t = Thread(target=client_demo)
        t.start()



##client(客户端)
import socket
from threading import Thread
def talk(conn):
    while True:
        try:
            msg=conn.recv(1024)
            if len(msg) == 0:break
            conn.send(msg.upper())
        except ConnectionResetError:
            print('客户端关闭了一个链接')
            break
    conn.close()

def sever_demo():
    server=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
    server.bind(('127.0.0.1',8081))
    server.listen(5)

    while True:
        conn,addr=server.accept()
        t = Thread(target=talk,args=(conn,))
        t.start()

if __name__ == '__main__':
    sever_demo()