为什么Python中的多线程是伪并发，但在高IO下能做到并发呢_python 假并发

首先来了解一下什么是计算密集型和IO密集型

CPU密集型也叫计算密集型，指的是系统的硬盘、内存性能相对CPU要好很多，此时，系统运作大部分的状况是CPU Loading 100%，CPU要读/写I/O(硬盘/内存)，I/O在很短的时间就可以完成，而CPU还有许多运算要处理，CPU Loading很高。简单说就是CPU的执行时间占程序运行的大部分时间，小部分时间进行磁盘读写.

IO密集型指的是系统的CPU性能相对硬盘、内存要好很多，此时，系统运作，大部分的状况是CPU在等I/O (硬盘/内存) 的读/写操作，此时CPU Loading并不高。I/O bound的程序一般在达到性能极限时，CPU占用率仍然较低。简单说就是CPU的执行时间占程序运行的小部分时间,大部分时间都在进行磁盘读写.

再来看下面几段代码

注意看下面两段计算密集型代码：

# 创建100个threads，每个thread计算一次a的数值

import threading
import time

def run():
    a = 100*100+1000/12/3+24+13


if __name__ == '__main__':

    start_time = time.time()

    print('这是主线程：', threading.current_thread().name)
    thread_list = []
    for i in range(100):
        t = threading.Thread(target=run)
        thread_list.append(t)

    for t in thread_list:
        t.start()

    for t in thread_list:
        t.join()

    # for i in range(100):
    #     run()

    print('主线程结束了！' , threading.current_thread().name)
    print('一共用时：', time.time()-start_time)
    
# 用时：0.012382984161376953
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

# 只用一个主线程跑100次计算a的数值

import threading
import time

def run():
    a = 100*100+1000/12/3+24+13


if __name__ == '__main__':

    start_time = time.time()

    print('这是主线程：', threading.current_thread().name)
    thread_list = []
    # for i in range(100):
    #     t = threading.Thread(target=run)
    #     thread_list.append(t)
    #
    # for t in thread_list:
    #     t.start()
    #
    # for t in thread_list:
    #     t.join()

    for i in range(100):
        run()

    print('主线程结束了！' , threading.current_thread().name)
    print('一共用时：', time.time()-start_time)
  
# 用时：1.9788742065429688e-05
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

可见：Python中的多线程是伪并发，当不是I/O密集型时，单线程的运行速度比多线程快多了，由上可见，差了将近1000倍

再看下面这段I/O密集型代码

# 创建100个线程，每一个线程睡两秒 

import threading
import time

def run():
    time.sleep(2)
# 每一个线程在执行time.sleep(2)后就中断，保护现场，CPU再去执行第2个线程，以此往复，直到第一个线程睡醒了CPU再去执行第一个线程，所以I/O很高

if __name__ == '__main__':

    start_time = time.time()

    print('这是主线程：', threading.current_thread().name)
    thread_list = []
    for i in range(100):
        t = threading.Thread(target=run)
        thread_list.append(t)

    for t in thread_list:
        t.start()

    for t in thread_list:
        t.join()



    print('主线程结束了！' , threading.current_thread().name)
    print('一共用时：', time.time()-start_time)
    
# 用时 2.0149500370025635
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

可见，在I/O密集型下，Python中的多线程可以做到并发。