线程

线程与进程的关系

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

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

线程与进程的区别

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

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

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

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

GIL锁,全局解释器锁,全局锁

  cpython才会有

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

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

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

线程直接的数据是共享的

 1 from threading import Thread
 2 import time
 3 n=100
 4 def func():
 5     global n
 6     n=n-1
 7 t=Thread(target=func).start()
 8 time.sleep(1)
 9 print(n)    
10     #99
View Code

守护线程

守护线程与守护进程

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

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

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

 1 from threading import Thread
 2 def func():
 3     print("守护线程")
 4 def func1():
 5     print("子线程")
 6 t=Thread(target=func)
 7 t1=Thread(target=func1)
 8 t.daemon=True
 9 t.start()
10 t1.start()
11 print("主进程")
12 守护线程
13 子线程
14 主进程
View Code

互斥锁与递归锁

为什么线程中有GIL锁,还要有锁?

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

  的线程就继续取值)

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

递归锁   

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

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

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

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

信号量      

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

 1 from threading import Thread,Semaphore
 2 import time
 3 def func(s):
 4     s.acquire()
 5     time.sleep(1)
 6     print("hello")
 7     s.release()
 8 s=Semaphore(3)
 9 for i in range(10):
10     t=Thread(target=func,args=(s,)).start()
View Code

事件

e=Event()

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

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

e.clear  恢复event的值为False

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

 1 from threading import Thread,Event
 2 import time
 3 def check(e):
 4     print("开始检测数据库连接")
 5     time.sleep(2)
 6     e.set()
 7 def connect(e):
 8     time.sleep(1)
 9     for i in range(3):
10         e.wait(1)
11         if e.is_set():
12             print("数据库连接成功")
13             break
14         else:print('第{}次数据库连接失败'.format(i+1))
15 e=Event()
16 t=Thread(target=connect,args=(e,)).start()
17 t1=Thread(target=check,args=(e,)).start()
View Code

条件

wait()

notify()

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

 1 eading import Thread,Condition
 2 def func(con,name):
 3     print("{}等待中".format(name))
 4     con.acquire()
 5     con.wait()
 6     print("{}在游戏中".format(name))
 7     con.release()
 8 con=Condition()
 9 for i in range(20):
10     t=Thread(target=func,args=(con,i))
11     t.start()
12 con.acquire()
13 con.notify(3)
14 con.release()
View Code

 

定时器

1 from threading import Timer
2 def func():
3     print("666")
4 t=Timer(3,func).start()
View Code

 

队列

Queue  先进先出

LifoQueue  栈,后进先出

PriorityQueue  优先级队列

  

posted @ 2018-09-25 17:57  若兮ruoxi  阅读(98)  评论(0编辑  收藏  举报