线程

线程与进程的关系

　　1，一个进程至少会有一个进程

　　2，线程是不能独立存在的

线程与进程的区别

　　1，进程是计算机的最小资源分配单位

　　2，线程是cpu的最小调度单位

　　3，进程之间的数据是隔离的

　　4，同一个进程内的的线程直接的数据是共享的

GIL锁，全局解释器锁，全局锁

　　cpython才会有

　　同一个进程内在同一个时刻只有有个线程会被CPU调度

在多I/O阻塞的程序中，用多线程

在高计算的程序中，用多进程

线程直接的数据是共享的

from threading import Thread
import time
n=100
def func():
    global n
    n=n-1
t=Thread(target=func).start()
time.sleep(1)
print(n)    
    #99

守护线程

守护线程与守护进程

　　守护进程　　守护进程会随主进程代码的结束而结束（程序的报活）

　　守护线程　　主线程在结束之后，会等待子线程的结束而结束

　　主线程的结束，就意味着主进程的结束

from threading import Thread
def func():
    print("守护线程")
def func1():
    print("子线程")
t=Thread(target=func)
t1=Thread(target=func1)
t.daemon=True
t.start()
t1.start()
print("主进程")
守护线程
子线程
主进程

互斥锁与递归锁

为什么线程中有GIL锁，还要有锁？

　　当在进行 +=，-= 的时候，会数据不安全（要进行取值，计算，赋值三步操作，有可能在做完取值，计算之后就时间片轮转，这时候就没办法赋值，另外的

　　的线程就继续取值）

　　列表的append，pop操作，队列，logging模块的数据是安全的

递归锁   

　　当一个线程在得到一把锁之后，还需要得到另一把锁

　　一个线程的到了一把锁，另一把锁被另外一个线程的到了，就会发生死锁

　　递归锁是解决死锁最快的方法，但不是最好的方法，还是要慢慢换用互斥锁

　　出现死锁不是互斥锁的原因，而是程序员编码时的逻辑问题

信号量      

　　信号量是计数器和锁来实现的

from threading import Thread,Semaphore
import time
def func(s):
    s.acquire()
    time.sleep(1)
    print("hello")
    s.release()
s=Semaphore(3)
for i in range(10):
    t=Thread(target=func,args=(s,)).start()

事件

e=Event()

e.wait()　　如果e.is_set==False将阻塞线程

e.set()　　设置event的值为True

e.clear　　恢复event的值为False

e.is_set()　　返回event的状态值

from threading import Thread,Event
import time
def check(e):
    print("开始检测数据库连接")
    time.sleep(2)
    e.set()
def connect(e):
    time.sleep(1)
    for i in range(3):
        e.wait(1)
        if e.is_set():
            print("数据库连接成功")
            break
        else:print('第{}次数据库连接失败'.format(i+1))
e=Event()
t=Thread(target=connect,args=(e,)).start()
t1=Thread(target=check,args=(e,)).start()

条件

wait()

notify()

wait和notify必须在acquire和release中间使用

eading import Thread,Condition
def func(con,name):
    print("{}等待中".format(name))
    con.acquire()
    con.wait()
    print("{}在游戏中".format(name))
    con.release()
con=Condition()
for i in range(20):
    t=Thread(target=func,args=(con,i))
    t.start()
con.acquire()
con.notify(3)
con.release()

定时器

from threading import Timer
def func():
    print("666")
t=Timer(3,func).start()

队列

Queue　　先进先出

LifoQueue　　栈，后进先出

PriorityQueue　　优先级队列