计算密集型和 io 密集型项目的使用场景分析和代码演示



from threading import Thread

from multiprocessing import Process

import time

计算密集型

def work1():

    res=0

    for i in range(100000000): #1+8个0

        res*=i

if __name__ == '__main__':

    t_list = []

    start = time.time()

    for i in range(4):

        # t = Thread(target=work1)

        t = Process(target=work1)

        t_list.append(t)

        t.start()

    for t in t_list:

        t.join()

    end = time.time()

    # print('多线程',end-start) # 多线程 15.413789510726929

    print('多进程',end-start) # 多进程 4.711405515670776

# io密集型

def work1():

    x = 1+1

    time.sleep(5)

if __name__ == '__main__':

    t_list = []

    start = time.time()

    for i in range(4):

        t = Thread(target=work1)

        # t = Process(target=work1)

        t_list.append(t)

        t.start()

    for t in t_list:

        t.join()

    end = time.time()

    print('多线程',end-start) #  多线程 5.002625942230225

    # print('多进程',end-start) # 多进程 5.660863399505615

在Cpython解释器中有一把GIL锁(全局解释器锁)，GIl锁本质是一把互斥锁。

导致了同一个进程下,同一时间只能运行一个线程,无法利用多核优势.

同一个进程下多个线程只能实现并发不能实现并行.

为什么要有GIL?

因为cpython自带的垃圾回收机制不是线程安全的,所以要有GIL锁.

导致了同一个进程下,同一时间只能运行一个线程,无法利用多核优势.

分析：

我们有四个任务需要处理，处理方式肯定是要玩出并发的效果，解决方案可以是：

方案一：开启四个进程

方案二：一个进程下，开启四个线程

计算密集型 推荐使用多进程

 每个都要计算10s

 多线程

 在同一时刻只有一个线程会被执行,也就意味着每个10s都不能省,分开每个都要计算10s,共40.ns

 多进程

 可以并行的执行多个线程,10s多一点，开启进程的时间

io密集型 推荐多线程

4个任务每个任务90%大部分时间都在io.

每个任务io了10s 执行用0.5s

多线程

可以实现并发,每个线程io的时间不咋占用cpu, 10s 加 4个任务的计算时间

多进程

可以实现并行,10s加 1个任务执行的时间+开进程的时间

递归锁内容如下：

from threading import Thread,RLock

# 递归锁 在同一个线程内可以被多次acquire

# 如何释放 内部相当于维护了一个计数器 也就是说同一个线程 acquire了几次就要release几次

mutex1 = RLock()

mutex2 = mutex1

import time

class father(Thread):

    def run(self):

        self.task1()

        self.task2()

    def task1(self):

        mutex1.acquire()

        print(f'{self.name} 抢到了 锁1 ')

        mutex2.acquire()

        print(f'{self.name} 抢到了 锁2 ')

        mutex2.release()

        print(f'{self.name} 释放了 锁2 ')

        mutex1.release()

        print(f'{self.name} 释放了 锁1 ')

    def task2(self):

        mutex2.acquire()

        print(f'{self.name} 抢到了 锁2 ')

        time.sleep(1)

        mutex1.acquire()

        print(f'{self.name} 抢到了 锁1 ')

        mutex1.release()

        print(f'{self.name} 释放了 锁1 ')

        mutex2.release()

        print(f'{self.name} 释放了 锁2 ')

if __name__ == '__main__':

    for i in range(3):

        t = father()

        t.start()
巴特西

计算密集型和 io 密集型项目的使用场景分析和代码演示

最新文章

热门文章
