在Python3中，Python提供了一个内置模块 threading.Thread，可以很方便地让我们创建多线程。

本文目录

• 函数创建多线程
• 使用类创建多线程
• 常用函数
• 锁机制
• GIL全局锁
• 线程间通讯机制

使用函数创建多线程

threading.Thread() 一般接收两个参数：(target= ,args=(,) )

• 线程函数名：要放置线程让其后台执行的函数，由我们自已定义，注意不要加()；
• 线程函数的参数：线程函数名所需的参数，以元组的形式传入。若不需要参数，可以不指定。

code举例

import time
from threading import Thread


def run(strings):
    for i in range(10):
        print(strings)
        time.sleep(10)
        print(strings)


if __name__ == '__main__':
    a = Thread(target=run, args=('python',))
    b = Thread(target=run, args=('c',))
    c = Thread(target=run, args=('go',))
    a.start()
    b.start()
    c.start()

使用类进行多线程创建

首先，我们要自定义一个类，对于这个类有两点要求

• 必须继承 threading.Thread 这个父类；
• 必须覆写 run 方法。

class MyThread(Thread):
    def __init__(self,strings):
        super().__init__()
        self.strings = strings

    def run(self):
        for i in range(10):
            print(self.strings)

if __name__ == '__main__':
    thread_a = MyThread('hhh')
    thread_b = MyThread('bbb')
    thread_a.start()
    thread_b.start()

常用函数

锁机制使用

lock使用

import threading

# 生成锁对象，全局唯一
lock = threading.Lock()

# 获取锁。未获取到会阻塞程序，直到获取到锁才会往下执行
lock.acquire()

# 释放锁，归回倘，其他人可以拿去用了
lock.release()

lock.acquire() 和 lock.release()必须成对出现。否则就有可能造成死锁
可以使用 上下问管理器来使用

import threading

lock = threading.Lock()
with lock:
    # 这里写自己的代码
    pass

锁实例

def job1():
    global n, lock
    # 获取锁
    lock.acquire()
    for i in range(10):
        n += 1
        print('job1', n)
    lock.release()


def job2():
    global n, lock
    # 获取锁
    lock.acquire()
    for i in range(10):
        n += 10
        print('job2', n)
    lock.release()

n = 0
# 生成锁对象
lock = threading.Lock()

t1 = threading.Thread(target=job1)
t2 = threading.Thread(target=job2)
t1.start()
t2.start()

可重入锁（RLOCK）

有时候在同一个线程中，我们可能会多次请求同一资源（就是，获取同一锁钥匙），俗称锁嵌套。同一线程第二次获取锁时，发现锁已经被同一线程的人拿走了，会发生死锁。

那么如何解决这个问题呢。

threading模块除了提供Lock锁之外，还提供了一种可重入锁RLock，专门来处理这个问题。

import threading

def main():
    n = 0
    # 生成可重入锁对象
    lock = threading.RLock()
    with lock:
        for i in range(10):
            n += 1
            with lock:
                print(n)

t1 = threading.Thread(target=main)
t1.start()

GIL 全局锁概念

任何Python线程执行前，必须先获得GIL锁，然后，每执行100条字节码，解释器就自动释放GIL锁，让别的线程有机会执行。这个GIL全局锁实际上把所有线程的执行代码都给上了锁，所以，多线程在Python中只能交替执行，即使100个线程跑在100核CPU上，也只能用到1个核。

GIL并不是Python的特性，它是在实现Python解析器(CPython)时所引入的一个概念。而Python解释器，并不是只有CPython，除它之外，还有PyPy，Psyco，JPython，IronPython等。