进程池和线程池

一.可重复利用的线程

1.队列计数器

 import queue

q = queue.Queue() #创建队列，此时，系统自动开启计数器，计数器为0
q.put('a') #往队列添加数据时，计数器加一，但get不会让计数器减一
print(q.get())
q.task_done() #让队列计数器减一
q.join() #计数器不为0时 就阻塞

2.重复利用线程

import threading
import queue
import time

class Mythread(threading.Thread):
    def __init__(self):
        super().__init__() #继承父类
        self.q = queue.Queue(5)
        self.daemon = True #守护模式
        self.start()

    def run(self):
        while True:#死循环 不断取出任务
            func, args, kwargs = self.q.get()#拆包
            func(*args,**kwargs)#执行任务
            self.q.task_done()

#     用来提交任务并且自动将任务put到队列中去
    def submit(self,func,*args,**kwargs):
        self.q.put((func,args,kwargs)) #put中只能放一个参数 所以这三个作为一个参数放入

    def join(self):
        self.q.join()

def task1():
    time.sleep(2)
    print('task1 done')

def task2():
    time.sleep(2)
    print('task2 done')

t = Mythread()
t.submit(task1)
t.submit(task2)
t.join()

 

 二、线程池的实现

import threading
import queue
import time

class MyThreadPool:
    def __init__(self,n):
        self.q = queue.Queue(5)
        for i in range(n):
            threading.Thread(target=self.task,daemon=True).start()

    def task(self):
        while True:  # 死循环 不断取出任务
            func,args,kwargs = self.q.get()  # 拆包
            func(*args, **kwargs)  # 执行任务
            self.q.task_done()

        #     用来提交任务并且自动将任务put到队列中去
    def submit(self, func, *args, **kwargs):
        self.q.put((func, args, kwargs))  # put中只能放一个参数 所以这三个作为一个参数放入

    def join(self):
        self.q.join()

def task1():
    time.sleep(2)
    print('task1 done')

def task2():
    time.sleep(2)
    print('task2 done')

mtp = MyThreadPool(2)
mtp.submit(task1)
mtp.submit(task2)

mtp.join()

三、内置池

from multiprocessing.pool import ThreadPool #导入线程池
from multiprocessing.pool import Pool #进程池
import time

def task1():
    time.sleep(2)
    print('task1 done')

def task2():
    time.sleep(2)
    print('task2 done')

# tp = ThreadPool(2)#创建含有两个线程的线程池
tp = Pool(2)#创建含有两个进程的进程池
# tp.apply_async(task1)#提交任务
tp.apply_async(task2)
tp.apply_async(task2)
tp.apply_async(task1)

# 如果使用了内置池，不管是进程池还是线程池，都要将这两句写在最后
tp.close()#等所有任务结束关闭线程池
tp.join()#主进程等待进程池先关闭再关闭

四、内置池并发服务器

from multiprocessing.pool import Pool
from multiprocessing.pool import ThreadPool
import socket

server = socket.socket()
server.bind(('127.0.0.1', 8899))
server.listen(5)


def f_recv(con):
    while True:
        data = con.recv(1024)
        print(123)
        if data:
            print(data)
        else:
            con.close()
            break


def f_accept(ser):
    tp = ThreadPool(4)
    while True:
        conn, addr = ser.accept()
        tp.apply_async(f_recv, args=(conn,))


p = Pool(2)
p.apply_async(f_accept, args=(server,))

p.close()
p.join()

连接客户端

import socket

client = socket.socket()
client.connect(('127.0.0.1',8899))  #发送连接请求


# 建立连接之后 就可以发送数据了 必须是字节数据
client.send('hello'.encode())