Python：多线程入门——多路加速，了解多线程基本原理

devos__

已于 2023-07-17 10:06:06 修改

阅读量281

点赞数 2

分类专栏：笔记 python 文章标签： python 多线程

于 2021-08-10 18:35:20 首次发布

本文链接：https://blog.csdn.net/qq_31262473/article/details/119576357

版权

笔记同时被 2 个专栏收录

6 篇文章 0 订阅

订阅专栏

python

3 篇文章 0 订阅

订阅专栏

这是崔庆才老师的《52讲轻松搞定网络爬虫》课程相关笔记。

以下的代码段运行前请先执行此代码

import threading
import time

Thread类直接创建子线程

通过构造函数，再传递此函数给 threading.Thread（target,args) 实现多线程，其中target是目标函数，args是目标函数的参数列表。

## 这里是构造函数
def target(second):
    print(f'Threading {threading.current_thread().name} is running') ### 线程的名字我们通过 threading.current_thread().name 来获取出来，
                                                                     ### 主线程的话，其值就是 MainThread，子线程的话，其值就是 Thread-*。
    print(f'Threading {threading.current_thread().name} is sleep {second}s')
    time.sleep(second)
    print(f'Threading {threading.current_thread().name} is ended')

## 主线程开始
print(f'Threading {threading.current_thread().name} is running')
for i in [1,5]:
    t = threading.Thread(target=target,args=[i])
    t.start()
    t.join()                                                         ### 这里的作用是子线程运行结束之前主线程不能提前运行结束，
                                                                     ### 主进程等待子进程运行结束后自己才可以运行结束。
                                                                     ### 主进程等待子进程结束才结束的行为叫阻塞。
print(f'Threading {threading.current_thread().name} is ended')

Threading MainThread is running
Threading Thread-6 is running
Threading Thread-6 is sleep 1s
Threading Thread-6 is ended
Threading Thread-7 is running
Threading Thread-7 is sleep 5s
Threading Thread-7 is ended
Threading MainThread is ended

守护进程

一个线程被设置为守护线程，这意味着，如果主线程结束了而该守护线程还没有运行完，那么它将会被强制结束。

设置守护进程的方法

方法一：可以通过 setDaemon(True) 方法来将某个线程设置为守护线程。
方法二：通过 threading.Thread (target,args,daemon=True) 来实现将某个线程设置为守护进程。

## 这里是构造函数
def target(second):
    print(f'Threading {threading.current_thread().name} is running')
    print(f'Threading {threading.current_thread().name} sleep {second}s')
    time.sleep(second)
    print(f'Threading {threading.current_thread().name} is ended')
    
# ## 方法一:
# print(f'Threading {threading.current_thread().name} is running')
# t1 = threading.Thread(target=target, args=[2])
# t1.start()
# t2 = threading.Thread(target=target, args=[5])
# t2.setDaemon(True)                           ### 将t2设置为守护进程，它会随着主进程结束而结束。
# t2.start()
# print(f'Threading {threading.current_thread().name} is ended')

## 方法二:
print(f'Threading {threading.current_thread().name} is running')
t1 = threading.Thread(target=target, args=[2])
t1.start()
t2 = threading.Thread(target=target, args=[5],daemon=True)     ### 将t2设置为守护进程，它会随着主进程结束而结束。
t2.start()
print(f'Threading {threading.current_thread().name} is ended')

Threading MainThread is running
Threading Thread-15 is running
Threading Thread-15 sleep 2s
Threading Thread-16 is running
Threading Thread-16 sleep 5s
Threading MainThread is ended
Threading Thread-15 is ended
Threading Thread-16 is ended

继承 Thread类创建子线程

MyThread是一个继承 threading 的类，线程需要实现的方法写在run方法里

## 这是个继承了Thread的类
class MyThread(threading.Thread):
    def __init__(self, second):
        threading.Thread.__init__(self)
        self.second = second
    def run(self):
        print(f'Threading {threading.current_thread().name} is running')
        print(f'Threading {threading.current_thread().name} sleep {self.second}s')
        time.sleep(self.second)
        print(f'Threading {threading.current_thread().name} is ended')

## 主线程开始
print(f'Threading {threading.current_thread().name} is running')
threads = []                    #### 用于存放MyThread的一个list
for i in [1, 5]:
    thread = MyThread(i)
    threads.append(thread)      #### list什么都可以存，包括实例化类对象
    thread.start()
for thread in threads:
    thread.join()
print(f'Threading {threading.current_thread().name} is ended')

Threading MainThread is running
Threading Thread-6 is running
Threading Thread-6 sleep 1s
Threading Thread-7 is running
Threading Thread-7 sleep 5s
Threading Thread-6 is ended
Threading Thread-7 is ended
Threading MainThread is ended

互斥锁

线程之间是可以共享资源的，但是有些共享资源不能够同时多个线程访问的，比如，打印机，打印机一时间只能有一个线程占着。**怎么样利用多个线程轮流对一个全局变量进行加法处理呢？**这个时候需要设置互斥锁才会没问题的，下面分别列举了没设置互斥锁和设置了互斥锁的结果。

### 比如在一个进程中，有一个全局变量 count 用来计数，现在我们声明多个线程，
### 每个线程运行时都给 count 加 1，让我们来看看效果如何。
### 这里设置了1000尺循环，按常理说最终结果是1000。

# count = 0

# class MyThread(threading.Thread):
#     def __init__(self):
#         threading.Thread.__init__(self)
#     def run(self):
#         global count
#         temp = count + 1
#         time.sleep(0.001)
#         count = temp

# threads = []
# for _ in range(1000):
#     thread = MyThread()
#     thread.start()
#     threads.append(thread)

# for thread in threads:
#     thread.join()
# print(f'Final count: {count}')

### 以上运行结果不可能是1000的，因为多个线程几乎是同时执行的，
### 一个时间点的 count 会被多个线程拿来加，但线程返回 count 的值时候返回的值是同一个值，
### 也就是说加了多次相等于只加一次，所以结果肯定偏小

### 此时互斥锁就派上用场了
### 互斥锁能够严格限制资源同一时间只能一个线程访问。
### 当那个线程访问完了，才能够被另一个线程访问。

count = 0

class MyThread(threading.Thread):
    def __init__(self):
        threading.Thread.__init__(self)
    def run(self):           #### 在 run方法里面，获取 count 前先加锁，修改完 count 之后再释放锁，
                             #### 这样多个线程就不会同时获取和修改 count 的值了
        global count
        lock.acquire()       #### 关锁，公共资源禁止其他线程访问。
        temp = count + 1
        time.sleep(0.001)
        count = temp
        lock.release()       #### 开锁，刚完事后，公共资源允许其他人访问。

lock = threading.Lock()      #### 这里声明了一个 lock 对象，其实就是 threading.Lock 的一个实例
threads = []
for _ in range(1000):
    thread = MyThread()
    thread.start()
    threads.append(thread)
for thread in threads:
    thread.join()
print(f'Final count: {count}')