生产者消费者python信号量_python学习——day9（ssh,线程和进程，信号量，队列，生产者消费者模型） Alex地址：http://www.cnblogs.com/alex3714/art...-CSDN博客

本文链接：https://blog.csdn.net/weixin_31001069/article/details/113720870

本文详细介绍了Python中模拟SSH连接、线程与进程的区别、线程锁、信号量锁（Semaphore）以及信号量（Event）的使用，并通过实例展示了它们在并发控制中的应用。此外，还提到了队列在生产者消费者模型中的作用，展示了如何利用队列实现解耦和提高效率。

摘要由CSDN通过智能技术生成

一、python上模拟ssh

1.ssh,ssh_ftp

pass

2.ssh 密钥

pass

二、线程，进程

定义：

进程: 是对各种资源管理的集合，qq 要以一个整体的形式暴露给操作系统管理，里面包含对各种资源的调用，内存的管理，网络接口的调用等

线程: 是操作系统最小的调度单位，是一串指令的集合。

进程要想操作CPU，就必须要创建一个线程(进程中至少包含一个线程)

区别：

1.线程共享内存空间(共享数据等)，进程的内存空间是独立的

2.同一进程的线程之间可以相互交流，2个进程之间的交流必须通过一个中间代理

3.线程可以操作和控制其他线程(同一进程下)，进程只能操作和控制子进程。

对主线程的更改可能会影响到其他线程的工作，对父进程的更改(除非关闭)不会影响子进程。(子进程还可以派生子进程)

各种锁

1.线程锁(我就瞎几把写了一下，具体代码看这：http://www.cnblogs.com/alex3714/articles/5230609.html)

2.递归锁(了解就行，一般用不到)

说白了就是在一个大锁中还要再包含子锁

1 importthreading,time2

5 defrun1():6

7 print("grab the first part data")8

9 lock.acquire()10

11 globalnum12

13 num +=1

15 lock.release()16

17 returnnum18

19 defrun2():20

21 print("grab the second part data")22

23 lock.acquire()24

25 globalnum226

27 num2+=1

29 lock.release()30

31 returnnum232

33 defrun3():34

35 lock.acquire()36

37 res =run1()38

39 print(‘--------between run1 and run2-----‘)40

41 res2 =run2()42

43 lock.release()44

45 print(res,res2)46

51 if __name__ == ‘__main__‘:52

55 num,num2 =0,056

57 lock =threading.RLock()58

59 for i in range(10):60

61 t = threading.Thread(target=run3)62

63 t.start()64

67 while threading.active_count() != 1:68

69 print(threading.active_count())70

71 else:72

73 print(‘----all threads done---‘)74

75 print(num,num2)

3.信号量锁(Semaphore)

互斥锁同时只允许一个线程更改数据，而Semaphore是同时允许一定数量的线程更改数据，比如厕所有3个坑，那最多只允许3个人上厕所，后面的人只能等里面有人出来了才能再进去。

1 importthreading,time2

3 defrun(n):4 semaphore.acquire() #信号量锁

5 time.sleep(1)6 print("run the:",n)7 semaphore.release() #解锁

10 if __name__==‘__main__‘:11 semaphore=threading.BoundedSemaphore(5) #设定只有5个坑

12 for i in range(20):13 t=threading.Thread(target=run,args=(i,))14 t.start()15

16 while threading.active_count()!=1:17 pass

18 else:19 print(‘123‘)

信号量(event)

信号量只有设定(event.set())和没设定(event.clear())两种

event.wait()　　#等待设定

event.is_set()　　#判断是否设定

红绿灯例子

1 importtime,threading2

3 event =threading.Event()4

5 deflighter():6 count=07 event.set() #设定

8 whileTrue:9 if count<10 and count>=5:10 event.clear() #清除设定

11 print("\033[41;1m红灯\033[0m")12 time.sleep(1)13 elif count>10:14 count=015 event.set()16 else:17 print("\033[42;1m绿灯\033[0m")18 time.sleep(1)19 count+=1

21 defcar(name):22 whileTrue:23 if event.is_set(): #判断是否设定

24 print("\033[32;1m[%s] run...\033[0m"%name)25 time.sleep(1)26 else:27 print(‘\033[31;1m [%s] stop...‘%name)28 event.wait() #等待设定

29 print(‘\033[33;1m [%s]走咯‘%name)30

32 light=threading.Thread(target=lighter,)33

34 light.start()35

36 car1=threading.Thread(target=car,args=(‘Tesla‘,))37

38 car1.start()

未完待续

三、队列(queue)

队列的好处(作用)：解耦，提高效率。

生产者消费者模型(很简单，没啥可说的)

1 importthreading,time2

3 importqueue4

5 q = queue.Queue(maxsize=10)6

7 defProducer(name):8 count = 1

9 whileTrue:10 q.put("骨头%s" %count)11 print("生产了骨头",count)12 count +=1

13 time.sleep(0.1)14

17 defConsumer(name):18 #while q.qsize()>0:

19 whileTrue:20 print("[%s] 取到[%s] 并且吃了它..." %(name, q.get()))21 time.sleep(1)22

25 p = threading.Thread(target=Producer,args=("Alex",))26 c = threading.Thread(target=Consumer,args=("ChengRonghua",))27 c1 = threading.Thread(target=Consumer,args=("王森",))28

30 p.start()31 c.start()32 c1.start()

原文：http://www.cnblogs.com/x54256/p/7684106.html