（笔记整理）Python 多线程

Python 的多线程使用的threading模块

通过使用threading.Thread创建一个新的线程

==
#如果子线程开启以后,后面的代码就会直接执行了,不会等子线程执行完
#只要子线程内的函数执行完,那么子线程就结束
#开启是.start开启我们的周期
#只要子线程不死,主线程一都在==

以下是最基本的多线程使用，包含传参。

# coding=utf-8
import threading
from time import sleep


def sing(name):
    for i in range(3):
        print("正在唱:%s...%d" % (name, i))
        sleep(1)


def dance(name, age):
    for i in range(3):
        print("%s正在跳舞,年龄：%d ... %d" % (name, age, i))
        sleep(1)


if __name__ == '__main__':
    print('---开始---')
    # 传参必须要是一个元组，可以使用args=或者kwargs=
    t1 = threading.Thread(target=sing, args=("我爱你祖国",))
    t2 = threading.Thread(target=dance, args=("小蒋", 18))
    t1.start()
    t2.start()

也可以创建多线程类，复写threading.Thread方法

# coding=utf-8
import threading
from time import sleep


# 复写多线程就是复写其run()方法
# 如果需要传入参数，就复写__init__()方法，但需注意，还要复写threading.Thread.__init__(self)
class MySing(threading.Thread):
    def __init__(self, name):
        threading.Thread.__init__(self)
        self.name = name

    def run(self):
        for i in range(3):
            print("正在唱:%s...%d" % (self.name, i))
            sleep(1)


class MyDance(threading.Thread):
    def __init__(self, name, age):
        threading.Thread.__init__(self)
        self.name = name
        self.age = age

    def run(self):
        for i in range(3):
            print("%s正在跳舞,年龄：%d ... %d" % (self.name, self.age, i))
            sleep(1)


def main():
    print('---开始---')
    t1 = MySing("我爱我的祖国")
    t2 = MyDance("小蒋", 18)
    t1.start()
    t2.start()


if __name__ == '__main__':
    main()

线程共享全局变量，由于cpu的切换可能会导致数据在某些时候产生丢失，因此需要进行加锁操作

threading模块中定义了Lock类，可以方便的处理锁定：

创建锁
mutex = threading.Lock()

#锁定
mutex.acquire()

释放
mutex.release()
注意，锁的范围应该是尽量小的进行保护数据的计算，因为锁产生等待，如果锁的范围过大，就会浪费很多时间，合理考虑锁的范围

使用互斥锁完成2个线程对同一个全局变量各加100万次的操作

# coding=utf-8
# 两个线程修改同一个全局变量
# 定义一个修改变量的方法
# 定义第二个修改变量的方法


# 全局变量
import threading

import time

# 创建一个锁
lock = threading.Lock()
# lock2 = threading.Lock()  #使用锁用同一把，保护2个线程共享的一个变量，两把锁就没有锁的意义了。
num = 0


# 这个写数据1
def write1():
    global num
    for temp in range(1000000):
        # 上锁
        lock.acquire()
        num += 1
        # 解锁
        lock.release()


# 这个写数据2
def write2():
    global num
    for temp in range(1000000):
        # 上锁
        lock.acquire()
        num += 1
        # 解锁
        lock.release()


def main():
    """我们创建两个子线程去修改同一个变量"""
    threading.Thread(target=write1).start()
    threading.Thread(target=write2).start()

    time.sleep(10)  # 保证我们的子线程执行完

    print(num)


if __name__ == '__main__':
    main()

使用锁需要注意，锁只能有一把，谁有锁谁才能操作。当然，使用锁还需要在代码中考虑不要产生死锁，在可能产生死锁的地方提前解锁。

**

让线程等待与不等待直接退出

**

Python多线程与多进程中join()方法的效果是相同的。

首先需要明确几个概念：

知识点一：
当一个进程启动之后，会默认产生一个主线程，因为线程是程序执行流的最小单元，当设置多线程时，主线程会创建多个子线程，在python中，默认情况下（其实就是setDaemon(False)），主线程执行完自己的任务以后，就退出了，此时子线程会继续执行自己的任务，直到自己的任务结束，例子见下面一。

知识点二：
当我们使用setDaemon(True)方法，设置子线程为守护线程时，主线程一旦执行结束，则全部线程全部被终止执行，可能出现的情况就是，子线程的任务还没有完全执行结束，就被迫停止，例子见下面二。

知识点三：
此时join的作用就凸显出来了，join所完成的工作就是线程同步，即主线程任务结束之后，进入阻塞状态，一直等待其他的子线程执行结束之后，主线程在终止，例子见下面三。

def main():
	th = []
	for i in range(5):
		th.append(threading.Thread(target=test_func,args=(arg1,arg2))
	for t in th:
		t.setDaemon(True)
		t.start()
	for t in th:
		t.join() # 这里如果没有join则主线程结束就整体结束，加个join就是让主线程阻塞等待子线程全部结束再结束整个程序

知识点四：
join有一个timeout参数：

当设置守护线程时，含义是主线程对于子线程等待timeout的时间将会杀死该子线程，最后退出程序。所以说，如果有10个子线程，全部的等待时间就是每个timeout的累加和。简单的来说，就是给每个子线程一个timeout的时间，让他去执行，时间一到，不管任务有没有完成，直接杀死。
没有设置守护线程时setDaemon(False)，主线程将会等待timeout的累加和这样的一段时间，时间一到，主线程结束，但是并没有杀死子线程，子线程依然可以继续执行，直到子线程全部结束，程序退出。