背景#

在网上搜集到的多线程资料都是一些概念介绍，而没有真实的案例告诉读者怎么真实来使用，下面就一个真实的使用场景来介绍多线程。

以下为一些概念引用：

在非python环境中，单核情况下，同时只能有一个任务执行。多核时可以支持多个线程同时执行。但是在python中，无论有多少个核同时只能执行一个线程。究其原因，这就是由于GIL（全局解释器）的存在导致的。

GIL的全称是全局解释器，来源是python设计之初的考虑，为了数据安全所做的决定。某个线程想要执行，必须先拿到GIL，我们可以把GIL看做是“通行证”，并且在一个python进程之中，GIL只有一个，拿不到通行证的线程，就不允许进入CPU执行。GIL只在cpython中才有，因为cpython调用的是c语言的原生线程，所以他不能直接操作cpu，而只能利用GIL保证同一时间只能有一个线程拿到数据。

python针对不同类型的代码执行效率也是不同的： 1、CPU密集型代码（各种循环处理、计算等），在这种情况下，由于计算工作多，ticks技术很快就会达到阀值，然后触发GIL的释放与再竞争（多个线程来回切换当然是需要消耗资源的），所以python下的多线程对CPU密集型代码并不友好。 2、IO密集型代码（文件处理、网络爬虫等设计文件读写操作），多线程能够有效提升效率（单线程下有IO操作会进行IO等待，造成不必要的时间浪费，而开启多线程能在线程A等待时，自动切换到线程B，可以不浪费CPU的资源，从而能提升程序的执行效率）。所以python的多线程对IO密集型代码比较友好。

主要要看任务的类型，我们把任务分为I/O密集型和计算密集型，而多线程在切换中又分为 I/O切换 和 时间切换（一个线程执行一段时间后，再切换到另外一个线程）。如果任务属于是I/O密集型，若不采用多线程，我们在进行I/O操作时，势必要等待前面一个I/O任务完成，后面的I/O任务才能进行，在这个等待的过程中，CPU处于等待状态，这时如果采用多线程的话，刚好可以切换到进行另一个I/O任务。这样就刚好可以充分利用CPU避免CPU处于闲置状态，提高效率。但是如果多线程任务都是计算型，CPU会一直在进行工作，直到一定的时间后采取多线程时间切换的方式进行切换线程，此时CPU一直处于工作状态，此种情况下并不能提高性能，相反在切换多线程任务时，可能还会造成时间和资源的浪费，导致效能下降。这就是造成上面两种多线程结果不能的解释。

结论：I/O密集型任务，建议采取多线程；对于计算密集型任务，python此时就不适用了。

现实需求#

为了解决读取文件、写入文件的I/O密集型任务，现在需要三个线程：
1、读取文件数据的线程-----读线程
2、对读取文件数据进行操作的线程-----数据处理线程
3、把处理结果再写入文件的线程-----写线程
这样就可以解决读取数据等待，写入数据等待的过程

数据准备#

建立number.txt，里面放置1~50数字，每行一个 numbet.txt 目的：从number.txt每次读取一行数据，对数据进行处理后，再写入number_write.txt（程序自动建立）

代码#

1
# -*- coding:UTF-8 -*-
2
# @Time : 2020/7/19 15:38
3
# @File : 多线程案例.py
4
# @Software: PyCharm
5
# @Platform: Win10
6
# @Author: data_duo
7

8
import threading
9
import os
10
import time
11
import queue
12

13

14
def read_txt(path_file_txt):
15
    with open(path_file_txt, 'r') as file:
16
        while True:
17
            data = file.readline().strip()
18
            if data:
19
                while True:  # 确保读取的数据一定存入workQueue_read队列,防止队列满了放不下
20
                    if not workQueue_read.full():
21
                        workQueue_read.put(data)
22
                        print(
23
                            'read_txt线程给workQueue_read队列存入：{} \n'.format(data),
24
                            end='',
25
                            flush=True)
26
                        break
27
                    else:
28
                        pass
29
            else:
30
                print('退出read_txt线程', end='\n', flush=True)
31
                break
32

33

34
def handle():
35
    count = 0
36
    while True:
37
        if not workQueue_read.empty():
38
            data = workQueue_read.get()
39
            print(
40
                'handle线程从workQueue_read队列获取：{} \n'.format(data),
41
                end='',
42
                flush=True)
43
            data = int(data) + 1
44
            data = str(data - 1)
45
            time.sleep(1)
46
            count = 0  # 需要重置
47

48
            while True:  # 确保数据存入workQueue_write 队列,防止队列满了放不下
49
                if not workQueue_write.full():
50
                    workQueue_write.put(data)
51
                    print(
52
                        'handle线程给workQueue_write队列存入：{} \n'.format(data),
53
                        end='',
54
                        flush=True)
55
                    break
56
                else:
57
                    pass
58
        else:
59
            if count < 5:  # 等待workQueue_read队列有数据，一共5次等待机会
60
                count += 1
61
                time.sleep(1)
62
                pass
63
            else:
64
                if thread_read.is_alive():
65
                    pass
66
                    count = 0  # 需要重置，再次计时
67
                else:
68
                    print('退出handle线程 \n', end='', flush=True)
69
                    break
70

71

72
def write_txt(path_file_txt):
73
    count = 0
74
    with open(path_file_txt, 'w+') as file:
75
        while True:
76
            if not workQueue_write.empty():
77
                data = workQueue_write.get()
78
                print(
79
                    'write_txt线程从workQueue_write队列获取：{} \n'.format(data),
80
                    end='',
81
                    flush=True)
82
                file.write(data)
83
                file.write('\n')
84
                print('write_txt线程写入数据：{} \n'.format(data), end='', flush=True)
85
                count = 0  # 需要重置，再次计时
86
            else:
87
                if count < 5:  # 确保handle线程处理完毕，把数据存入workQueue_write队列
88
                    count += 1
89
                    time.sleep(1)
90
                    pass
91
                else:
92
                    if thread_handle.is_alive():
93
                        pass
94
                        count = 0  # 需要重置，再次计时
95
                    else:
96
                        print('退出写线程 \n', end='', flush=True)
97
                        break
98

99

100
if __name__ == "__main__":
101
    threads = []
102

103
    workQueue_read = queue.Queue(20)
104
    workQueue_write = queue.Queue(20)
105

106
    print('原来总线程数为：{} \n'.format(threading.active_count()), end='', flush=True)
107

108
    # 创建读取线程
109
    thread_read = threading.Thread(target=read_txt, args=('number.txt',))
110
    thread_read.start()
111
    threads.append(thread_read)
112
    print(
113
        '启动读取线程后，总线程数为：{} \n'.format(
114
            threading.active_count()),
115
        end='',
116
        flush=True)
117

118
    # 创建操作线程
119
    thread_handle = threading.Thread(target=handle)
120
    thread_handle.start()
121
    threads.append(thread_handle)
122
    print(
123
        '启动操作线程后，总线程数为：{} \n'.format(
124
            threading.active_count()),
125
        end='',
126
        flush=True)
127

128
    # 创建写入线程
129
    thread_write = threading.Thread(
130
        target=write_txt, args=(
131
            'number_write.txt',))
132
    thread_write.start()
133
    threads.append(thread_write)
134
    print(
135
        '启动写入线程后，总线程数为：{} \n'.format(
136
            threading.active_count()),
137
        end='',
138
        flush=True)
139

140
    # 等待所有线程完成
141
    for t in threads:
142
        t.join()
143

144
    print('退出主线程')

运行结果：

1
原来总线程数为：1
2
启动读取线程后，总线程数为：2
3
read_txt线程给workQueue_read队列存入：1
4
启动操作线程后，总线程数为：3
5
read_txt线程给workQueue_read队列存入：2
6
read_txt线程给workQueue_read队列存入：3
7
...
8
read_txt线程给workQueue_read队列存入：20
9
启动写入线程后，总线程数为：4
10
handle线程从workQueue_read队列获取：1
11
read_txt线程给workQueue_read队列存入：21
12
handle线程给workQueue_write队列存入：1
13
handle线程从workQueue_read队列获取：2
14
read_txt线程给workQueue_read队列存入：22
15
write_txt线程从workQueue_write队列获取：1
16
write_txt线程写入数据：1
17
handle线程给workQueue_write队列存入：2
18
handle线程从workQueue_read队列获取：3
19
...
20
read_txt线程给workQueue_read队列存入：50
21
退出read_txt线程
22
write_txt线程从workQueue_write队列获取：29
23
...
24
handle线程给workQueue_write队列存入：50
25
write_txt线程从workQueue_write队列获取：50
26
write_txt线程写入数据：50
27
退出handle线程
28
退出写线程
29
退出主线程

历时相关文章#

以上是自己实践中遇到的一些问题，分享出来供大家参考学习，欢迎关注微信公众号：DataShare ，不定期分享干货