标签：引入   连接   加锁   阻塞   成功   多个   感知   targe   时间   

线程队列

FIFO队列

# 1 FIFO队列 queue 先进先出 特殊参数 block=True, timeout=None
import queue
# q=queue.Queue(3)
# q.put(666)
# q.put(777)
# q.put(888)
# print(q.get())
# print(q.get())
# print(q.get())

LIFO 栈

# LIFO 栈. 先进后出 特殊参数 block=True, timeout=None
import queue
# q=queue.LifoQueue(3)
# q.put(666)
# q.put(777)
# q.put(888)
# print(q.get())
# print(q.get())
# print(q.get())

优先级队列

# 优先级对列 需要元组的形式,(int,数据) int 代表优先级,数字越低,优先级越高. get先去重要的
import queue
q=queue.PriorityQueue(3)
q.put((10,'拉级消息'))
q.put((-10,'重要消息'))
q.put((5,'一般消息'))
print(q.get())
print(q.get())
print(q.get())

事件Event

并发的执行某个任务 .多线程多进程,几乎同时执行.

一个线程执行到中间时通知另一个线程开始执行.

属性

# event = Event()  # 默认是False
# event.set()  # 改成了True
# event.wait()  #　轮询检测event是否为True,当其为True,继续下一行代码. 阻塞.
# event.wait(1)
# 设置超时时间,如果1s中以内,event改成True,代码继续执行.
# 设置超时时间,如果超过1s中,event没做改变,代码继续执行.

第一版没用 Event

# 引入 
import time
from threading import Thread
from threading import current_thread
flag = False
def task():
    print(f'{current_thread().name} 检测服务器是否正常开启....')
    time.sleep(3)
    global flag
    flag = True

def task1():
    while 1:
        time.sleep(1)
        print(f'{current_thread().name} 正在尝试连接服务器.....')
        if flag:
            print('连接成功')
            return

if __name__ == '__main__':
    for i in range(4):
        t=Thread(target=task,)
        t.start()
    t4=Thread(target=task1,)
    t4.start()

第2版用了 Event

import time
from threading import Thread
from threading import current_thread
from threading import Event
def task():
    print(f'{current_thread().name} 检测服务器是否正常开启....')
    time.sleep(3)
    event.set()

def task1():
    while 1:
        time.sleep(1)
        print(f'{current_thread().name} 正在尝试连接服务器.....')
        event.wait()
        print(f'{current_thread().name} 连接成功')

if __name__ == '__main__':
    event = Event()
    for i in range(4):
        t=Thread(target=task,)
        t.start()
    t4=Thread(target=task1,)
    t4.start()

协程的初识

一个线程实现并发.

并发,并行,串行:

串行: 多个任务执行时,第一个任务从开始执行,遇到了IO等待,等待IO阻塞结束之后,继续执行下一个任务.

并行: 多核,多个线程或者进程同时执行. 4个cpu,同时执行4个任务.

并发: 多个任务看起来是同时执行, cpu在多个任务之间来回切换(遇到IO阻塞,计算密集型执行时间过长).

并发的本质:

1. 遇到IO阻塞,计算密集型执行时间过长 切换.
2. 保持原来的状态.

一个线程实现并发.

多进程: 操作系统控制 多个进程的多个任务切换 + 保持状态.

多线程: 操作系统控制 多个线程的多个任务切换 + 保持状态.

协程: 程序控制 一个线程的多个任务的切换以及保持状态.

协程: 微并发, 处理任务不宜过多.

协程它会调度cpu,如果协程管控的任务中,遇到阻塞,它会快速的(比操作系统快)切换到另一个任务,并且能将上一个任务挂起(保持状态,),让操作系统以为cpu一直在工作.

之前我们学过协程?yield 就是一个协程,

协程

协程的优点 :

#1. 协程的切换开销更小，属于程序级别的切换，操作系统完全感知不到，因而更加轻量级
#2. 单线程内就可以实现并发的效果，最大限度地利用cpu
#3. 修改共享数据不需加锁

队列 事件 协程

标签：引入   连接   加锁   阻塞   成功   多个   感知   targe   时间   

原文地址：https://www.cnblogs.com/saoqiang/p/11415408.html