Thread实例对象的方法
  # isAlive(): 返回线程是否活动的。
  # getName(): 返回线程名。
  # setName(): 设置线程名。

threading模块提供的一些方法：
  # threading.currentThread(): 返回当前的线程变量。
  # threading.enumerate(): 返回一个包含正在运行的线程的list。正在运行指线程启动后、结束前，不包括启动前和终止后的线程。
  # threading.activeCount(): 返回正在运行的线程数量，与len(threading.enumerate())有相同的结果。

开启线程的方式

# 开启线程的方式一
from threading import Thread


def task(s1):
    print("线程开启了")


if __name__ == '__main__':
    s1 = '线程开启了'
    # args可迭代对象元组只有一个参数的情况需要加","
    p = Thread(target=task, args=(s1,))
    p.start()

# 开启线程的方式二,继承Thread类重新run方法
from threading import Thread


class Task2(Thread):
    def __init__(self, name):
        super().__init__()
        self.name = name

    def run(self):
        # print(self.name)
        print("牛逼")


if __name__ == '__main__':
    t = Task2("Joab")
    t.start()

在主进程下开启进程和线程谁的速度快

import time
from threading import Thread
from multiprocessing import Process
import os


def work():
    time.sleep(2)
    print('hello')


if __name__ == '__main__':
    # 在主进程下开启线程
    start_t = time.time()
    t = Thread(target=work)
    t.start()
    t.join()
    print('主进程开启线程')
    print(time.time() - start_t)
    
    # 在主进程下开启子进程
    start_t = time.time()
    t = Process(target=work)
    t.start()
    t.join()
    print('主进程开启进程')
    print(time.time() - start_t)
    
# 输出
hello
主进程开启线程
2.021684408187866

hello
主进程开启进程
2.234938383102417

# 结论
开启线程速度更快，资源占用小

守护线程

无论是进程还是线程，都遵循：守护xxx会等待主xxx运行完毕后被销毁

from threading import Thread
import time


def sayhi(name):
    print('%s say hello' % name)
    time.sleep(2)


if __name__ == '__main__':
    t = Thread(target=sayhi, args=('Joab',))
    # 声明是守护线程，而不是t.Daemon = True
    t.setDaemon(True)  # 必须在t.start()之前设置
    t.start()
    # 开启的线程是否存活
    print(t.is_alive())
# 输出，因为打印改结果时候主进程未关闭，所以守护线程存活是True
Joab say hello
True

线程锁

三个需要注意的点：
#1.线程抢的是GIL锁，GIL锁相当于执行权限，拿到执行权限后才能拿到互斥锁Lock，其他线程也可以抢到GIL，但如果发现Lock仍然没有被释放则阻塞，即便是拿到执行权限GIL也要立刻交出来

#2.join是等待所有，即整体串行，而锁只是锁住修改共享数据的部分，即部分串行，要想保证数据安全的根本原理在于让并发变成串行，join与互斥锁都可以实现，毫无疑问，互斥锁的部分串行效率要更高

#3. 一定要看本小节最后的GIL与互斥锁的经典分析

from threading import Thread, Lock
import os, time


def work():
    global n
    # 公共数据的操作加锁
    lock.acquire()
    temp = n
    time.sleep(0.1)
    n = temp - 1
    lock.release()


if __name__ == '__main__':
    lock = Lock()
    n = 100
    l = []
    for i in range(100):
        p = Thread(target=work)
        l.append(p)
        p.start()
    for p in l:
        p.join()

    print(n)  # 结果肯定为0，由原来的并发执行变成串行，牺牲了执行效率保证了数据安全

死锁现象与递归锁

所谓死锁： 是指两个或两个以上的进程或线程在执行过程中，因争夺资源而造成的一种互相等待的现象，若无外力作用，它们都将无法推进下去。此时称系统处于死锁状态或系统产生了死锁，这些永远在互相等待的进程称为死锁进程，如下就是死锁

from threading import Thread, Lock
import time

mutexA = Lock()
mutexB = Lock()


class MyThread(Thread):
    def run(self):
        self.func1()
        self.func2()

    def func1(self):
        mutexA.acquire()
        print('%s 拿到A锁' % self.name)

        mutexB.acquire()
        print('%s 拿到B锁' % self.name)
        mutexB.release()

        mutexA.release()

    def func2(self):
        mutexB.acquire()
        print('%s 拿到B锁' % self.name)
        time.sleep(2)

        mutexA.acquire()
        print('%s 拿到A锁' % self.name)
        mutexA.release()

        mutexB.release()


if __name__ == '__main__':
    for i in range(10):
        t = MyThread()
        t.start()

解决方法，递归锁，在Python中为了支持在同一线程中多次请求同一资源，python提供了可重入锁RLock。

这个RLock内部维护着一个Lock和一个counter变量，counter记录了acquire的次数，从而使得资源可以被多次require。直到一个线程所有的acquire都被release，其他的线程才能获得资源。上面的例子如果使用RLock代替Lock，则不会发生死锁：

#一个线程拿到锁，counter加1,该线程内又碰到加锁的情况，则counter继续加1，这期间所有其他线程都只能等待，等待该线程释放所有锁，即counter递减到0为止
mutexA=mutexB=threading.RLock()