使用函数创建多线程

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()

常用函数

函数名称	函数作用
t.start()	启动子线程
t.join()	阻塞子线程，等待子线程结束
t.is_alive()	判断状态，执行返回True
t.daemon	这只线程是否随主线程退出
t.name	设置线程名称

锁机制使用

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()