线程队列,线程池和协程

线程的其他方法:

  threading.current_thread() #当前线程对象

  getName() # 获取线程名

  ident  # 获取线程id

    threading.enumerate()   # 当前正在运行的线程对象的一个列表

  threading.active_count()  # 当前正在运行的线程数量

import time
from threading import Thread,current_thread

def f1(n):
    print(f"{n}号线程正在运行")
    print("子线程的名称",current_thread().getName())

if __name__ == ‘__main__‘:
    t = Thread(target=f1,args=(1,),name = ‘123‘)
    t.start()
    print("主线程的名称", current_thread().getName())

  

线程队列:(重点)

  import queue

   先进先出队列:queue.Queue(3)

   先进后出\后进先出队列:queue.LifoQueue(3)

   优先级队列:queue.priorityQueue(3)

  put的数据是一个元组,元组的第一个参数是优先级数字,数字越小优先级越高,越先被get到被取出来,第二个参数是put进去的值,如果说优先级相同,那么值别忘了应该是相同的数据类型,字典不行

import queue
# q = queue.Queue(3)
# q.put(1)
# q.put(2)
# print(q.qsize())
# try :
#     q.put_nowait(3)
# except :
#     print(‘满了‘)
# print(q.full())
#
# print(q.get())
# print(q.get())
# print(q.get())

q = queue.PriorityQueue(3)
q.put((2,‘white‘))
q.put((1,‘卢本伟‘))
q.put((2,‘55开‘))

print(q.get())
print(q.get())
print(q.get())

  

线程池:

  from concurrent.futures import ThreadPoolExecutor,ProcessPoolExecutor

  t = ThreadPoolExecutor(4)  #默认的线程个数是cpu个数 * 5

  p = ProcessPoolExecutor(4)  #默认的进程个数是cpu个数

  t.map(f1,可迭代的对象)  #异步执行

import  time
from concurrent.futures import ThreadPoolExecutor,ProcessPoolExecutor

def f1(n):
    time.sleep(1)
    print(n)

if __name__ == ‘__main__‘:
    t = ThreadPoolExecutor(5)
    t.map(f1,range(10))
    t.shutdown()

    print(‘主程序结束‘)

  

  def f1(n1,n2):

    print(n1,n2)

  t.submit(f1,11,12)  #异步提交任务

  res = t.submit(f1,11,12)

  res.result()  #和get方法一样,如果没有结果,会等待,阻塞程序

   shutdown()  # close+join,锁定线程池,等待线程池中所有已经提交的任务全部执行完毕

import  time
from concurrent.futures import ThreadPoolExecutor,ProcessPoolExecutor

def f1(n,m):
    time.sleep(1)
    print(n)
    return n+m

if __name__ == ‘__main__‘:
    t = ThreadPoolExecutor(5)
    t_lis = []
    for i in range(10):
        ret = t.submit(f1,i,5)
        t_lis.append(ret)
    t.shutdown()
    for i in t_lis:
        print(i.result())

    print(‘主程序结束‘)

  

协程的概念:可以理解为微线程,在遇到io阻塞时,保存当前状态并进行切换,且阻塞时间是并行的. 既节省时间,又提高效率.

  import gevent  #导入模块

  gevent.sleep(1)   # 该方法的阻塞时间可以被识别并执行,如果是time.sleep()是不能识别,且不会节省时间的

  g1 = gevent.spawn(f1)    # 异步提交f1和f2任务

  g2 = gevent.spawn(f2)   # 异步提交f1和f2任务

  gevent.joinall ( [g1,g2] )   # 等待执行完才继续执行     相当于 g1.join() 和 g2.join()

  

import gevent

def f1():
    print(‘1号开启游戏‘)
    gevent.sleep(2)
    print(‘1号吃鸡了‘)

def f2():
    print(‘2号开启游戏‘)
    gevent.sleep(2)
    print(‘2号吃鸡了‘)

g1 = gevent.spawn(f1)    #异步提交f1任务
g2 = gevent.spawn(f2)    #异步提交f2任务

g1.join()
g2.join()       # gevent.joinall([g1,g2])

print("主程序结束")

  

原文地址:https://www.cnblogs.com/gyc-tzx/p/10268835.html

时间: 2024-10-09 05:51:49

线程队列,线程池和协程的相关文章

线程队列、事件以及协程

线程的几个队列 都是从queue这个模块中导入 1.Queue队列(先进先出的队列) from queue import Queue q = Queue(maxsize=3) # 实例化产生队列对象 # maxsize 设置队列里能容纳的最大的数据个数 q.put("first") q.put("second") q.put("third") # 如果队列满了,put会阻塞住,等到空了再放进去 print(q.get()) # first pri

线程进阶之线程队列、线程池和协程

本节目录: 1.线程队列 2.线程池 3.协程 一.线程队列 线程之间的通信我们列表行不行呢,当然行,那么队列和列表有什么区别呢? queue队列 :使用import queue,用法与进程Queue一样 queue is especially useful in threaded programming when information must be exchanged safely between multiple threads. class queue.Queue(maxsize=0)

进程池与线程池、协程、协程实现TCP服务端并发、IO模型

进程池与线程池.协程.协程实现TCP服务端并发.IO模型 一.进程池与线程池 1.线程池 ''' 开进程开线程都需要消耗资源,只不过两者比较的情况下线程消耗的资源比较少 在计算机能够承受范围内最大限度的利用计算机 什么是池? 在保证计算机硬件安全的情况下最大限度的利用计算机 池其实是降低了程序的运行效率,但是保证了计算机硬件的安全 (硬件的发展跟不上软件的速度) ''' from concurrent.futures import ThreadPoolExecutor import time p

Python-线程池、进程池,协程

线程池&进程池 在python2中没有提供,在python3之后才提供 作用:保证程序中最多可以创建的线程的个数 import time from concurrent.futures import ThreadPoolExecutordef task(n1,n2):    time.sleep(1)    print('星空不问赶路人')pool = ThreadPoolExecutor(10) # 创建线程池for i in range(100):    pool.submit(task,i

并发编程 之 线程的队列, 线程池; 以及协程 (四)

线程: 队列:Queue from queue import Queue 特点: 先进先出 自带锁, 数据安全 方法: put() 添加 get() 获取 put_nowait() get_nowait() full() empty() qsize() 和普通的队列用法一样, 详情 请看 进程之队列 栈:LifoQueue from queue import LifoQueue 后进先出 自带锁, 数据安全 优先级队列:PriorityQueue from queue import Priori

python全栈开发 * 线程队列 线程池 协程 * 180731

一.线程队列 队列:1.Queue 先进先出 自带锁 数据安全 from queue import Queue from multiprocessing import Queue (IPC队列)2.LifoQueue后进先出 后进先出 自带锁 数据安全 from queue import LifoQueue lq=LifoQueue(5) lq.put(123) lq.put(666) lq.put(888) lq.put(999) lq.put("love") print(lq.pu

线程队列 线程池 协程

1 . 线程队列 from multiprocessing Queue , JoinableQueue  #进程IPC队列 from queue import Queue  #线程队列  先进先出 from queue import LifoQueue  #后进先出的 方法都是一样的 : put , get , put_nowait , get_nowait , full , empty , qsize 队列 Queue : 先进先出 , 自带锁 , 数据安全 栈 LifoQueue : 后进先

Python 线程----线程方法,线程事件,线程队列,线程池,GIL锁,协程,Greenlet

主要内容: 线程的一些其他方法 线程事件 线程队列 线程池 GIL锁 协程 Greenlet Gevent 一. 线程(threading)的一些其他方法 from threading import Thread import threading import time def work(): time.sleep(1) print("子线程对象>>>", threading.current_thread()) # 子线程对象 print("子线程名称>

线程queue、线程进程池,协程

线程queue import queue q = queue.Queue() #先进先出 q = queue.LifoQueue() #先进后出 t = queue.PriorityQueue() #优先级取数据,通常这个元组的第一个值是int类型 q.put('123') q.put('qweqwe') print(q.get()) print(q.get()) t.put('100', 'tank') t.put('10', 'nick') t.put('1', 'jason') print