定时器、线程queue、进程池和线程池

1.定时器

指定n秒后，执行任务

from threading import Timer,current_thread
import os


def hello():
    print("%s hello, world"%os.getpid())
    print("%s hello, world"%current_thread().name)


t = Timer(3, hello)
t.start()  # after 1 seconds, "hello, world" will be printed
print(os.getpid())
print(current_thread())

# 12376
# <_MainThread(MainThread, started 12008)>
# 12376 hello, world
# Thread-1 hello, world

 

2.线程queue

2.1 先进先出

import queue

q=queue.Queue()
q.put('first')
q.put('second')
q.put('third')

print(q.get())
print(q.get())
print(q.get())
'''
结果(先进先出):
first
second
third
'''

 

2.2 后进先出

import queue

q=queue.LifoQueue()
q.put('first')
q.put('second')
q.put('third')

print(q.get())
print(q.get())
print(q.get())
'''
结果(后进先出):
third
second
first
'''

 

2.3 优先级队列（开了会员就要先出来）

存储数据时可以设置优先级队列。数字越小（可以为负数），优先级越高，取出来的是一个元组形式。

里面put什么值就取出来什么值，只是优先级的问题。

import queue

q=queue.PriorityQueue()
#put进入一个元组,元组的第一个元素是优先级(通常是数字,也可以是非数字之间的比较),数字越小优先级越高
q.put((20,'a'))
q.put((10,'b'))
q.put((30,'c'))

print(q.get())
print(q.get())
print(q.get())
'''
结果(数字越小优先级越高,优先级高的优先出队):
(10, 'b')
(20, 'a')
(30, 'c')
'''

 

3.进程池和线程池

'''
1、什么时候用池：
    池的功能是限制启动的进程数或线程数，
    什么时候应该限制？？？
    当并发的任务数远远超过了计算机的承受能力时，即无法一次性开启过多的进程数或线程数时
    就应该用池的概念将开启的进程数或线程数限制在计算机可承受的范围内

2、同步vs异步
    同步、异步指的是提交任务的两种方式

    同步：提交完任务后就在原地等待，直到任务运行完毕后拿到任务的返回值，再继续运行下一行代码
    异步：提交完任务（绑定一个回调函数）后根本就不在原地等待，直接运行下一行代码，等到任务有
    返回值后会自动触发回调函数

'''
 concurrent.futures 高度封装的异步调用接口
 ProcessPoolExecutor 进程池 提供异步调用
 ThreadPoolExecutor  线程池 提供异步调用

from socket import *

sever = socket(AF_INET,SOCK_STREAM)
sever.bind(("127.0.0.1",8080))
sever.listen(5)
# 无法实现并发，建立一个连接，进入通信循环，直到通信循环结束
while True:
    conn,addr = sever.accept()
    while True:
        try:
            data = conn.recv(1024)
            if len(data) == 0:break
            conn.send(data.upper())
        except ConnectionResetError:
            break
    sever.close()


from socket import *

sever = socket(AF_INET,SOCK_STREAM)
sever.bind(("127.0.0.1",8080))
sever.listen(5)
def task(conn):
    while True:
        try:
            data = conn.recv(1024)
            if len(data) == 0: break
            conn.send(data.upper())
        except ConnectionResetError:
            break
    sever.close()
# 还是实现不了并发，只能实现串行
while True:
    conn,addr = sever.accept()
    task(conn)

from socket import *
from threading import Thread

sever = socket(AF_INET,SOCK_STREAM)
sever.bind(("127.0.0.1",8080))
sever.listen(5)
def task(conn):
    while True:
        try:
            data = conn.recv(1024)
            if len(data) == 0: break
            conn.send(data.upper())
        except ConnectionResetError:
            break
    sever.close()

# 启动一个子线程干通信的活
# 每建立一个连接就开启一个子线程，交给子线程干通信的活，可以实现并发
while True:
    conn,addr = sever.accept()

    t = Thread(target=task,args=(conn,))
    t.start()

from socket import *
from threading import Thread

def task(conn):
    while True:
        try:
            data = conn.recv(1024)
            if len(data) == 0: break
            conn.send(data.upper())
        except ConnectionResetError:
            break
    sever.close()

# 将while循环放到函数下面，可以往里面传入ip，port和半连接池的最大限制数
# 这样做是已经实现并发了，但是如果有很多的客户请求，需要不停的建立线程数，电脑肯定是有上限的。
# python中的线程是操作系统的原生线程，需要操作系统来调度，同时开启太多线程，操作系统调度不过来。
# 限制线程数不是为了提高效率，是高并发情况下不得已而为之
def sever_func(ip,port,backlog = 5):
    while True:
        sever = socket(AF_INET,SOCK_STREAM)
        sever.bind((ip, port))
        sever.listen(backlog)
        print("start-------")
        conn,addr = sever.accept()

        t = Thread(target=task,args=(conn,))
        t.start()

if __name__ == '__main__':
    sever_func("127.0.0.1",8080)

 

同步

同步：提交完任务后就在原地等待，直到任务运行完毕后拿到任务的返回值，再继续运行下一行代码
同步调用并不是真正意义上的串行，只是他的取值方式让程序变成了串行的工作方式。

from concurrent.futures import ProcessPoolExecutor,ThreadPoolExecutor
import time
import os


def task(n):
    print("%s is running"%os.getpid())
    time.sleep(5)
    return n**2

# 默认是cpu的个数
# 如果直接在提交任务后拿到返回值就变成同步了
if __name__ == '__main__':
    pool = ProcessPoolExecutor(4)
    l = []
    for i in range(1,10):
        future = pool.submit(task,i)
        l.append(future)
        # print(future)
        # print(future.result())
    pool.shutdown(wait=True)
    for m in l:
        print(m.result())

 

异步　

异步：提交完任务（绑定一个回调函数）后根本就不在原地等待，直接运行下一行代码，等到任务有

返回值后会自动触发回调函数
回调函数：parse会在futrue有返回值时立刻触发，并且将future当作参数传给parse

from concurrent.futures import ProcessPoolExecutor,ThreadPoolExecutor
from threading import current_thread
import os
import time
import random

def task(n):
    print('%s run...' %current_thread().name)
    time.sleep(5)
    return n**2

def parse(future):
    time.sleep(1)
    res=future.result()
    print('%s 处理了 %s' %(current_thread().name,res))

if __name__ == '__main__':
    pool=ThreadPoolExecutor(4)
    start=time.time()
    for i in range(1,5):
        future=pool.submit(task,i)
        future.add_done_callback(parse) # parse会在futrue有返回值时立刻触发，并且将future当作参数传给parse
    pool.shutdown(wait=True)
    stop=time.time()
    print('主',current_thread().name,(stop - start))