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

Posted 2020-10-11

一、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 import threading,time
 2 
 3  
 4 
 5 def run1():
 6 
 7     print("grab the first part data")
 8 
 9     lock.acquire()
10 
11     global num
12 
13     num +=1
14 
15     lock.release()
16 
17     return num
18 
19 def run2():
20 
21     print("grab the second part data")
22 
23     lock.acquire()
24 
25     global  num2
26 
27     num2+=1
28 
29     lock.release()
30 
31     return num2
32 
33 def run3():
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 
47  
48 
49  
50 
51 if __name__ == ‘__main__‘:
52 
53  
54 
55     num,num2 = 0,0
56 
57     lock = threading.RLock()
58 
59     for i in range(10):
60 
61         t = threading.Thread(target=run3)
62 
63         t.start()
64 
65  
66 
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 import threading,time
 2 
 3 def run(n):
 4     semaphore.acquire()    #信号量锁
 5     time.sleep(1)
 6     print("run the:",n)
 7     semaphore.release()    #解锁
 8 
 9 
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 import time,threading
 2 
 3 event = threading.Event()
 4 
 5 def lighter():
 6     count=0
 7     event.set()     #设定
 8     while True:
 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=0
15             event.set()
16         else:
17             print("\\033[42;1m绿灯\\033[0m")
18             time.sleep(1)
19         count+=1
20 
21 def car(name):
22     while True:
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 
31 
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 import threading,time
 2 
 3 import queue
 4 
 5 q = queue.Queue(maxsize=10)
 6 
 7 def Producer(name):
 8     count = 1
 9     while True:
10         q.put("骨头%s" % count)
11         print("生产了骨头",count)
12         count +=1
13         time.sleep(0.1)
14 
15 
16 
17 def  Consumer(name):
18     #while q.qsize()>0:
19     while True:
20         print("[%s] 取到[%s] 并且吃了它..." %(name, q.get()))
21         time.sleep(1)
22 
23 
24 
25 p = threading.Thread(target=Producer,args=("Alex",))
26 c = threading.Thread(target=Consumer,args=("ChengRonghua",))
27 c1 = threading.Thread(target=Consumer,args=("王森",))
28 
29 
30 p.start()
31 c.start()
32 c1.start()