默认情况下主线程会等待子线程结束

t.deamon = Ture　　# 主线程结束，子线程随之结束

守护进程随着主进程代码的执行结束而结束

守护线程会在主线程结束以后等待其他子线程的结束才结束

主进程在执行完自己的代码以后(守护进程结束)不会立即结束，而是等待子进程结束以后，回收子进程资源

主线程必须在其他非守护线程运行完毕以后才能结束(守护进程此时结束)，因为主线程的结束意味着进程的结束，进程整体的资源都将被回收

联想join()

################################################

进程锁并不常用，一般用线程锁

科学家吃面问题(死锁)

GIL锁是加给线程，并不能完全保证数据安全(时间线轮转)

Lock()　　# 互斥锁

Rlock()　　# 递归锁，拿几个钥匙加几把锁，在同一线程可以拿多次，为解决死锁问题

fork_lock() = noodle_lock() = Rlock()

################################################

信号量Semaphore()

事件Event()

import time
import random
from threading import Thread,Event

def connect_db(e):
    count = 0
    while count < 3:
        e.wait(1)   # 等待1秒
        if e.is_set():
            print('连接数据库中...')
            break
        else:
            count += 1
            print('第%s次失败...'%count)
    else:
        raise TimeoutError('数据库连接超时')

def check_web(e):
    time.sleep(random.randint(0,3))
    e.set()

e = Event()
t1 = Thread(target=connect_db,args=(e,))
t2 = Thread(target=check_web,args=(e,))
t1.start()
t2.start()

###############################################

Condition　　# 条件，一种更复杂的锁

c.acquire()

c.release()

c.wait()

c.notify(int)　　# 造一次性钥匙

wait和notify必须都在ac和re之间

from threading import Thread,Condition

def func(con,i):
    con.acquire()
    con.wait()
    print('在第%s个循环里'%i)
    con.release()



con = Condition()
for i in range(10):
    Thread(target=func,args=(con,i)).start()

while True:
    num = int(input('>>>'))
    con.acquire()
    con.notify(num)
    con.release()

###############################################

定时器 Timer

Timer(2,func).start()　　#延时2秒开启