GIL 与线程池进程池

1、什么是GIL(这是Cpython解释器)
    GIL本质就是一把互斥锁,那既然是互斥锁,原理都一样,都是让多个并发线程同一时间只能
    有一个执行
    即:有了GIL的存在,同一进程内的多个线程同一时刻只能有一个在运行,意味着在Cpython中
        一个进程下的多个线程无法实现并行===》意味着无法利用多核优势
        但不影响并发的实现

    GIL可以被比喻成执行权限,同一进程下的所以线程 要想执行都需要先抢执行权限

2、为何要有GIL
    因为Cpython解释器自带垃圾回收机制不是线程安全的

3、如何用

    GIL vs 自定义互斥锁
        GIL相当于执行权限,会在任务无法执行的情况,被强行释放
        自定义互斥锁即便是无法执行,也不会自动释放

4、有两种并发解决方案:
    多进程:计算密集型
    多线程:IO密集型


#计算密集型用Process进程
from multiprocessing import Process
from threading import Thread
import os,time
def work():
    res=0
    for i in range(200000):
        res*=i

if __name__ == '__main__':
    l=[]
    print(os.cpu_count())#本机为四核
    start=time.time()
    for i in range(1,5):
        p=Process(target=work)
        l.append(p)
        p.start()
    for n in l:
        n.join()
    stop=time.time()  # 进程运行时间远小于线程运行时间
    print('run time is %s'%(stop-start))

IO密集型

from threading import Thread
import os,time
def work():
    time.sleep(5)
if __name__ == '__main__':
    start=time.time()
    p1=Thread(target=work)
    p2=Thread(target=work)
    p3=Thread(target=work)
    p4=Thread(target=work)
    p1.start()
    p2.start()
    p3.start()
    p4.start()
    p1.join()
    p2.join()
    p3.join()
    p4.join()
    stop=time.time()
    print('run time is %s'%(stop-start))
    #为io密集型时,用线程效率高

定时器
from threading import Timer,current_thread
def task(x):
    print('%s run>>>>'%x)
    print(current_thread().name)
if __name__ == '__main__':
    t=Timer(3,task,args=(10,))
    t.start()
    print('主')
    会在等待3秒后执行程序

线程queue

import queue

1队列:先进先出
q=queue.Queue(3) 线程队列
q.put(1)
q.get()

2堆栈:先进后出
q=queue.LifoQueue()

3.优先级队列:优先级高先出来,数字越小,优先级越高
q=queue.PriorityQueue()
q.put((3,'data'))
q.put((-10,'data2'))元组的形式,可以为负数,优先出来


进程池与线程池

1,什么时候用池:
池的功能是限制启动的进程数或者线程数

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

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

同步;提交完任务后就在原地等待,直到任务运行完毕后拿到任务
的返回值,才继续运行下一行代码

异步:提交完任务(绑定一个回调函数)后根本不在原地等待,直接
运行下一行代码,等到任务有返回值后会自动触发回调函数执行


from  concurrent.futures import ProcessPoolExecutor,ThreadPoolExecutor
from threading import current_thread
import os,time,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会在future有返回值时立刻
        触发,并且将future当做参数传给parse
    pool.shutdown(wait=True)默认为True,关闭池入口 ,等待运行完毕
    stop=time.time()
    print('zhu ',current_thread().name,(stop-start))
    #回调函数在用并发进程时是由主进程一个一个运行
    #而多线程下回调函数由线程并发运行



实现多线程并发的套接字

服务端
from socket import *
from threading import Thread

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

def server(ip,port,backlog=5):
    server = socket(AF_INET, SOCK_STREAM)
    server.bind((ip, port))
    server.listen(backlog)

    print('starting...')
    while True:
        conn, addr = server.accept()

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

if __name__ == '__main__':
    server('127.0.0.1',8080)

客户端
from socket import *
import os

client=socket(AF_INET,SOCK_STREAM)
client.connect(('127.0.0.1',8080))

while True:
    msg='%s say hello' %os.getpid()
    client.send(msg.encode('utf-8'))
    data=client.recv(1024)
    print(data.decode('utf-8'))
<think>好的,用户想了解线程池进程池的区别对比。首先,我需要回忆一下线程和进程的基本概念,以及它们在Python中的具体实现。记得线程是操作系统调度的最小单位,而进程是资源分配的最小单位。不过Python由于GIL的存在,线程在CPU密集型任务中可能效率不高,这时候可能需要用进程池来充分利用多核CPU。 接下来,用户的问题是关于线程池进程池的区别,所以需要从资源开销、并发能力、适用场景、数据通信、创建限制等方面来对比。根据之前看到的引用资料,比如引用[3]提到线程池在Python中因为GIL的问题,无法充分利用多核处理器,而进程池可以。同时引用[2]提到不能无限开进程或线程,所以用池来管理。 还需要考虑资源开销,进程的创建和销毁比线程更消耗资源,所以进程池适合处理计算密集型任务,而线程池适合IO密集型任务,比如Selenium的自动化测试,这里引用[3]有提到线程池在IO等待上可能并不显著提升性能,但可能还是比单线程好。 数据共享方面,线程之间共享内存,而进程之间需要IPC机制,比如队列或者管道,这可能影响编程复杂度。引用[4]中的代码示例展示了线程池的使用,但进程池的代码结构类似,只是用ProcessPoolExecutor。 另外,创建限制方面,系统对进程数有限制,而线程数虽然理论上可以更多,但过多也会导致切换开销。引用[2]提到不能无限开进程或线程,所以池的大小需要合理设置。 然后要总结对比表格,让用户更清晰。最后生成相关问题,比如如何选择线程池进程池,或者Python中GIL的影响,或者进程池的数据共享方式。确保问题覆盖用户可能进一步想知道的内容。 需要确保回答结构清晰,分点说明,引用正确的资料。比如引用[3]说明GIL的影响,引用[2]说明池的限制,引用[4]的代码示例说明API相似性。同时注意用户可能对性能差异和应用场景特别感兴趣,所以这部分要详细说明。</think>### 线程池进程池的对比分析 #### 1. **资源开销** - **线程池**:线程是轻量级的执行单元,共享同一进程的内存空间,创建和切换开销小[^3]。 - **进程池**:进程是独立的资源分配单元,创建和销毁需要更多系统资源,且内存空间相互隔离[^2]。 #### 2. **并发能力** - **线程池**:在Python中受全局解释器锁(GIL)限制,同一时间仅有一个线程执行字节码,多线程无法充分利用多核CPU。 - **进程池**:每个进程有独立的GIL,可并行利用多核CPU,适合CPU密集型任务。 #### 3. **适用场景** - **线程池**:适合IO密集型任务(如网络请求、文件读写)或外部设备交互(如Selenium自动化测试)。 - **进程池**:适合CPU密集型任务(如数学计算、图像处理)[^2]。 #### 4. **数据通信** - **线程池**:线程共享内存,可直接读写全局变量,但需注意线程安全问题。 - **进程池**:进程间通信需通过IPC机制(如管道、队列),数据传递效率较低[^2]。 #### 5. **创建限制** - **线程池**:可创建较多线程(受内存限制),但线程数过多会导致上下文切换开销。 - **进程池**:进程数量通常受CPU核心数限制,过多进程会显著降低性能。 #### 6. **Python实现** - **API统一性**:Python中`concurrent.futures`模块提供统一的`ThreadPoolExecutor`(线程池)和`ProcessPoolExecutor`(进程池)接口[^1][^4]。 - **代码示例对比**: ```python # 线程池示例 from concurrent.futures import ThreadPoolExecutor with ThreadPoolExecutor(5) as executor: results = executor.map(task, args_list) # 进程池示例 from concurrent.futures import ProcessPoolExecutor with ProcessPoolExecutor(4) as executor: # 通常设置为CPU核心数 results = executor.map(task, args_list) ``` --- ### **对比总结表格** | 对比维度 | 线程池 | 进程池 | |----------------|---------------------------------|---------------------------------| | **资源开销** | 低(共享内存) | 高(独立内存) | | **并发能力** | 受GIL限制(伪并行) | 真并行(多核利用) | | **适用场景** | IO密集型任务 | CPU密集型任务 | | **数据通信** | 直接共享内存 | 需IPC机制(如队列) | | **创建数量** | 较多(受内存限制) | 较少(受CPU核心数限制) | | **编程复杂度** | 需处理线程安全 | 需处理进程间通信 | ---
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值