线程池,协程

线程的其他方法: 

  Threading.current_thread() #当前线程对象
  GetName() 获取线程名
  Ident 获取线程id
  Threading.Enumerate() #当前正在运行的线程对象的一个列表
  Threading.active_count() #当前正在运行的线程数量

  

 1 import time
 2 import threading
 3 from threading import Thread,current_thread
 4 def fn(n):
 5     time.sleep(1)
 6     print(‘子线程名称:‘,current_thread().getName())
 7     print(‘%s线程任务‘%n)
 8 def f2(n):
 9     time.sleep(1)
10     print(‘子线程名称:‘,current_thread().getName())
11     print(‘%s线程任务‘%n)
12 if __name__ == ‘__main__‘:
13     t1 = Thread(target=fn,args=(1,))
14     t2 = Thread(target=f2,args=(2,))
15     t1.start()
16     t2.start()
17     print(‘主线程名称:‘,current_thread().getName())
18     print(‘主线程ID:‘,current_thread().ident)
19     print(current_thread())
20     print(threading.enumerate())
21     print(threading.active_count())

线程队列:

种类:
  Import queue
  先进先出队列:queue.Queue(3)
  先进后出\后进先出队列:queue.LifoQueue(3)
  优先级队列:queue.priorityQueue(3)   Put的数据是一个元组,元组的第一个参数是优先级数字,数字越小优先级越高,
                    越先被get到被取出来,第二个参数是put进去的值,如果说优先级相同,那么值别忘了
                    应该是相同的数据类型,字典不行

方法:
  q.put() 进
  q.put_nowait()不阻塞的进,超出队列长度会报错 Exception
  q.qsize() 查看当前队列长度
  q.full() 查看当前队列是否满了,返回True或返回False

  q.get() 取
  q.get_nowait() 不阻塞的取,超出队列长度会报错 Exception
  q.empty() 查看当前队列是否空了,返回True或返回False

 1 import queue
 2 q = queue.Queue(4)
 3 q.put(1)
 4 q.put(2)
 5 q.put(3)
 6 print(q.qsize())
 7 q.put(4)
 8 print(q.full())
 9 try:
10     q.put_nowait(1)
11 except Exception:
12     print(‘队列满了‘)
13 print(q.get())
14 print(q.get())
15 print(q.get())
16 print(q.get())
17 print(q.empty())
18 try:
19     q.get_nowait()
20 except Exception:
21     print(‘队列空了‘)
22
23 import queue
24 q = queue.LifoQueue(4)
25 q.put(1)
26 q.put(2)
27 q.put(3)
28 q.put(4)
29 print(q.get())
30 print(q.get())
31 print(q.get())
32 print(q.get())
33
34 import queue
35 q = queue.PriorityQueue(3)
36 q.put((3,‘123‘))
37 q.put((5,[1,2,3]))
38 q.put((8,(1,2,3,)))
39 print(q.get())
40 print(q.get())
41 print(q.get())

线程池:

  submit #异步提交任务
  result #和get方法一样,如果没有结果,会等待,阻塞程序
  shutdown #主线程等待所有提交给线程池的任务,全部执行完毕 close + join


import time,threading,geventfrom gevent import monkey;monkey.patch_all()def f1():    print(‘第一次f1‘)    print(threading.current_thread().getName())    gevent.sleep(1)    time.sleep(1)    print(‘第二次f1‘)def f2():    print(‘第一次f2‘)    print(threading.current_thread().getName())    gevent.sleep(1)    time.sleep(2)    print(‘第二次f2‘)s = time.time()g1 = gevent.spawn(f1)      #异步提交任务g2 = gevent.spawn(f2)gevent.joinall([g1,g2])    #相当于g1 跟 g2 都执行了join方法e = time.time()print(‘执行时间:‘,e-s)print(‘主程序结束‘)
 

线程池回调函数: from conncurrent.futures import ThreadPoolExecutor,ProcessPoolExecutor

1 from concurrent.futures import ThreadPoolExecutor,ProcessPoolExecutor
2 def f1(n,s):
3     return n + s
4 def f2(n):
5     print(‘回调函数>>>‘,n.result())
6 if __name__ == ‘__main__‘:
7     t = ThreadPoolExecutor(4)  #这里可以更改为ProcessPoolExecutor使用
8     res = t.submit(f1,11,12).add_done_callback(f2)   #将f1中的值回调给f2    

多线程实现socket

 1 #服务端
 2 import threading
 3 import socket
 4 server=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
 5 server.bind((‘127.0.0.1‘,8080))
 6 server.listen(5)
 7 def action(conn):
 8     while True:
 9         data=conn.recv(1024)
10         print(data.decode(‘utf-8‘))
11         msg = input(‘服务端输入:‘) #在多线程里面可以使用input输入内容,那么就可以实现客户端和服务端的聊天了,多进程不能输入
12         conn.send(msg.encode(‘utf-8‘))
13
14 if __name__ == ‘__main__‘:
15
16     while True:
17         conn,addr=server.accept()
18         p=threading.Thread(target=action,args=(conn,))
19         p.start()
 1 #客户端
 2 import socket
 3 client=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
 4 client.connect((‘127.0.0.1‘,8080))
 5 while True:
 6     msg=input(‘>>: ‘).strip()
 7     if not msg:continue
 8
 9     client.send(msg.encode(‘utf-8‘))
10     data=client.recv(1024)
11     print(data.decode(‘utf-8‘))

原文地址:https://www.cnblogs.com/Godisgirl/p/10269246.html

时间: 2024-10-01 02:05:23

线程池,协程的相关文章

进程池线程池 协程

socket服务端实现并发 服务端需要满足以下3点: 1 固定的ip和port 2 24小时提供服务 3 能够实现并发 多线程实现并发: 服务端: import socket from threading import Thread import os server = socket.socket() server.bind(('127.0.0.1',8080)) server.listen(5) #半连接池 def communicate(conn): while True: try: dat

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 : 后进先

进程池/线程池/协程

导入进程池线程池模块@@ from concurrent import ProcessPoolExecutor,ThreadPoolExecutor 同步提交,异步提交@@ from concurrent import ProcessPoolExecutor,ThreadPoolExecutorimport osdef foo(name): print('进程%s,进程号为%s'%(name,os.getpid())) return os.getpid() if __nmae__=='__mai

线程池+协程+gevent模块

提交任务的两种方式: 同步调用:提交完一个任务之后,就在原地等待,等待任务完完整整地运行完毕拿到结果后,再执行下一行代码,会导致任务是串行执行的 异步调用:提交完一个任务之后,不在原地等待,而是直接执行下一行代码,会导致任务是并发执行的 p.shutdown(wait=True)关闭进程池的入口,并且在原地等待进程池内所有任务运行完毕 异步调用:提交完一个任务之后,不在原地等待,而是直接执行下一行代码,会导致任务是并发执行的,结果:futrue对象会在任务运行完毕后自动传给回调函数 在线程下实现

Python 中的进程、线程、协程、同步、异步、回调

进程和线程究竟是什么东西?传统网络服务模型是如何工作的?协程和线程的关系和区别有哪些?IO过程在什么时间发生? 在刚刚结束的 PyCon2014 上海站,来自七牛云存储的 Python 高级工程师许智翔带来了关于 Python 的分享<Python中的进程.线程.协程.同步.异步.回调>. 一.上下文切换技术 简述 在进一步之前,让我们先回顾一下各种上下文切换技术. 不过首先说明一点术语.当我们说"上下文"的时候,指的是程序在执行中的一个状态.通常我们会用调用栈来表示这个状

Python—进程、线程、协程

一.线程 线程是操作系统能够进行运算调度的最小单位.它被包含在进程之中,是进程中的实际运作单位.一条线程指的是进程中一个单一顺序的控制流,一个进程中可以并发多个线程,每条线程并行执行不同的任务 方法: start            线程准备就绪,等待CPU调度 setName      设置线程名称 getName      获取线程名称 setDaemon   把一个主进程设置为Daemon线程后,主线程执行过程中,后台线程也在进行,主线程执行完毕后,后台线程不论有没执行完成,都会停止 j

Python之路(十八):进程,线程,协程

python基础之进程.线程.协程 引子 进程 线程(优先阅读) 协程 进程 概念:就是一个程序在一个数据集上的一次动态执行过程(本质上来讲,就是运行中的程序(代指运行过程),程序不运行就不是进程)    抽象概念 组成:  1.程序:我们编写的程序用来描述进程要完成哪些功能以及如何完成  2.数据集:数据集则是程序在执行过程中所需要使用的资源  3.进程控制块:进程控制块用来记录进程的外部特征,描述进程的执行变化过程,系统可以利用它来控制和管理进程,它是系统感知进程存在的唯一标志. 阐释:进程

CPU的最小执行单位是线程,协程不需要qt支持...直接用现成的协程库就行了

协程也就在I/O操作上才有优势,Qt事件循环,本事很多I/O已经是异步了,利用好异步(虽然都说异步有点反人类思维).因为CPU的执行最小单位是线程,协程也只是在其之上又调度而已. 我的意思是利用好异步的优势.协程是程序级别的调度,对于CPU执行来说,没任何优势的. CPU的最小执行单位是线程,单线程里十万个协程,也就一个在工作,利用不了并行优势.对于高运算的程序,协程除了增加调度开销并没有优势的.对于I/O操作较多的程序才有用,因为I/O太慢.而对应I/O操作,异步相对与协程开销更小,效率也更高