python 进程，线程，协程篇
- ssh
- 线程
- 进程
- 线程，进程区别
- threading 模块，两种调用方式
- python GIL全局解释器锁(Global Interpreter Lock)
- Join & Daemon
- 线程锁(互斥锁 Mutex)
- RLock 递归锁
- Semaphore 信号量
- Timer
- Events + 红绿灯实例
- queue 队列 +生产者消费者模型
- 泡泡
1, ssh
SSH 为 Secure Shell 的缩写，也即是 安全外壳协议。SSH 为建立在应用层基础上的安全协议。SSH 是目前较可靠，
专为远程登录会话和其他网络服务提供安全性的协议。利用 SSH 协议可以有效防止远程管理过程中的信息泄露问题。
从客户端来看，SSH 提供两种级别的安全验证
第一种级别，基于口令的安全验证
第二种级别，基于秘匙的安全证
ssh 公钥，秘钥
ssh
import paramiko
#创建SSH对象
ssh = paramiko.SSHClient()
#允许连接不再know_hosts文件中的主机
# ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
#连接服务器
ssh.connect(hostname='c1.salt.com',port=22,username='wupeiqi',password=123)
#执行命令
stdin,stdout,stderr = ssh.exec_command('df')
#获取命令结果
result = stdout.read()
#关闭连接
ssh.close()
ssh_sft
import paramiko
#创建SSH对象
ssh = paramiko.SSHClient()
#允许连接不再know_hosts文件中的主机
# ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
#连接服务器
ssh.connect(hostname='c1.salt.com',port=22,username='wupeiqi',password=123)
#执行命令
stdin,stdout,stderr = ssh.exec_command('df')
#获取命令结果
result = stdout.read()
#关闭连接
ssh.close()
ssh_rsaa
import paramiko
private_key = paramiko.RSAKey.from_private_key_file('id_rsa31.txt')
# 创建SSH对象
ssh = paramiko.SSHClient()
#允许连接不在know_hosts 文件中的主机
ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
#连接服务器
ssh.connect(hostname='10.0.0.41',port=52113,username='gongli',pkey=private_key)
#执行命令
stdin,stdout,stderr = ssh.exec_command('df')
result = stdout.read()
print(result.decode())
stdin,stdout2,stderr = ssh.exec_command('ifconfig')
result2 = stdout2.read()
print(result2.decode())
#关闭连接
ssh.close()
2, 线程 threading
线程是操作系统进行运算调度的最小单位。它包含在进程之中，是进程中的实际运作单位，一条线程指的是
进程中一个单一顺序的控制流，一个进程中可以并发多个线程，每条线程并行执行不同的任务。
也可以说是一串指令的集合。
3, 进程 process
qq要以一个整体的形式暴露给操作系统管理，里面包含对各种资源的调用，内存的管理，网络接口的调用等
对各种资源管理的集合，就可以称为 进程
进程 要操作cpu，必须要创建一个线程
4, 进程与线程的区别
0，运行速度没有可比性，线程启动速度快，进程启动速度慢
1，所有在同一个进程里的线程是共享同一块内存空间的
2，同一个进程的线程之间可以直接交流，连个线程想通信，必须通过一个中间代理来实现
3，创建新线程很简单，创建新进程需要对其父进程进行一次克隆
4，一个线程可以控制和操作同一进程里的其他线程，但是进程只能操作子进程
5, Python threading 模块，两种调用方式
直接调用
import threading
import time
def run(n):
print("task",n)
time.sleep(2)
#需要 2 秒
# t1 = threading.Thread(target=run,args=('baobaohui',))
# #args 里面的是要传入的参数，加逗号防止误认为是元组,不然会报错
# t2 = threading.Thread(target=run,args=('t2',))
# t1.start()
# t2.start()
# 需要 4 秒
# run('t1')
# run('t2')
# 计算 50次 并发的时间
start_time = time.time()
t_objs = [] #存线程实例
for i in range(50):
t = threading.Thread(target=run,args=("t-%s"%i,))
# t.setDaemon(True) # 把当前线程设置为守护线程，那么，只要非守护线程部分结束，程序就会退出
t.start()
t_objs.append(t) # 为了不阻塞后面线程的启动，不在这里join，先放到一个列表里
for t in t_objs: #循环线程实例列表，等待所有线程执行完毕
t.join()
print("-----all threads has finished-----",threading.current_thread()) # 主线程 MainThread
print("cost: ",time.time()-start_time)
继承式调用
# 多线程 以类的方式实现
import threading
import time
class MyThread(threading.Thread):
def __init__(self,n):
super(MyThread,self).__init__()
self.n = n
def run(self):
print("running task",self.n)
t1 = MyThread("t1")
t2 = MyThread("t2")
t1.run()
t2.run()
6, python GIL全局解释器锁(Global Interpreter Lock)
在CPython中，全局解释器锁（GIL）是一个互斥锁，它可以防止多个本机线程一次执行Python字节码。
这种锁是必要的，主要是因为CPython的内存管理不是线程安全的。
但是，由于GIL存在，其他功能已经增长，取决于它所强制执行的保证。
7, Join & Daemon 守护进程
有些线程执行后台任务，例如发送keepalive数据包，或执行定期垃圾收集等等。
这些仅在主程序运行时才有用，并且一旦其他非守护程序线程退出就可以将它们终止。
如果没有守护程序线程，您必须跟踪它们，并在程序完全退出之前告诉它们退出。
通过将它们设置为守护程序线程，您可以让它们运行并忘记它们，当程序退出时，任何守护程序线程都会自动终止。
# daemon 守护进程
import threading
import time
def run(n):
print("task",n)
time.sleep(2)
# 计算 50次 并发的时间
start_time = time.time()
t_objs = [] #存线程实例
for i in range(50):
t = threading.Thread(target=run,args=("t-%s"%i,))
t.setDaemon(True) # 把当前线程设置为守护线程，那么，只要非守护线程部分结束，程序就会退出
t.start()
t_objs.append(t) # 为了不阻塞后面线程的启动，不在这里join，先放到一个列表里
for t in t_objs: #循环线程实例列表，等待所有线程执行完毕
t.join()
print("-----all threads has finished-----",threading.current_thread()) # 主线程 MainThread
print("cost: ",time.time()-start_time)
8, 线程锁（互斥锁 Mutex）
一个进程下可以启动多个线程，多个线程共享父进程的内存空间，也就意味着每个线程可以访问同一份数据.
此时，如果多个个线程同时要修改同一份数据，在没有对数据加锁的情况下，很可能在运算过程中出现错误。
# 线程锁，给线程中数据加锁
import threading
import time
def run(n):
lock.acquire() # 这个线程调用时加锁，释放前数据不能被调用
global num
num +=1
time.sleep(1) # 因为线程中只有数据操作，所以加完锁后 会用50s结束程序
lock.release() # 数据操作完毕后释放锁
lock = threading.Lock()
num = 0
t_objs = [] #存线程实例
for i in range(50):
t = threading.Thread(target=run,args=("t-%s" %i ,))
t.start()
t_objs.append(t) #为了不阻塞后面线程的启动，不在这里join，先放到一个列表里
for t in t_objs: #循环线程实例列表，等待所有线程执行完毕
t.join()
print("----------all threads has finished...",threading.current_thread(),threading.active_count())
print("num:",num)
9, RLock 递归锁
说白了就是如果在一个大锁中还要在包含子锁，那么为了防止出现数据及锁的混乱，采用 递归锁可以很好的解决这一问题
他可以在有多个锁的时候，一把钥匙开一道对应的门
# rlock 递归锁
import threading,time
def run1():
print("grab the first part data")
lock.acquire()
global num
num += 1
lock.release()
return num
def run2():
print("grab the second part data")
lock.acquire()
global num2
num2 += 1
lock.release()
return num2
def run3():
lock.acquire()
res = run1()
print("--------between run1 and run2----------")
res2 = run2()
lock.release()
print(res,res2)
num,num2 = 0,0
lock = threading.RLock() #递归锁，有顺序的锁
for i in range(2):
t = threading.Thread(target=run3)
t.start()
while threading.active_count() != 1:
print(threading.active_count())
else:
print("-----all threads done-----")
print(num,num2)
10, Semaphore 信号量
互斥锁同时只允许一个线程更改数据，而Semaphore 是同时允许一定数量的线程更改数据。
比如，厕所有三个坑，那最多只允许3个人上厕所，后面的人只能等里面有人出来了才能再进去。
# Semaphore 信号量 互斥锁同时只允许一个线程更改数据，而Semaphore 是同时允许一定数量的线程更改数据
import threading,time
def run(n):
semaphore.acquire()
time.sleep(1)
print("run the thread: %s\n"%n)
semaphore.release()
if __name__ == '__main__':
semaphore = threading.BoundedSemaphore(5) # 最多允许5 个线程同时运行
for i in range(22):
t = threading.Thread(target=run,args=(i,))
t.start()
while threading.active_count() != 1:
pass #print threading.active_count()
else:
print("------all threads done------")
#print(num)
11, Timer
此类表示仅在经过一定时间后才应运行的操作
与线程一样，通过调用start（）方法启动计时器。
可以通过调用thecancel（）方法停止计时器(在其动作开始之前)。
计时器在执行其操作之前等待的时间间隔可能与用户指定的时间间隔不完全相同。
def hello():
print("hello, world")
t = Timer(30.0, hello)
t.start() # after 30 seconds, "hello, world" will be printed
12, Events + 红绿灯实例
事件是一个简单的同步对象;
该事件代表一个内部标志和线程
可以等待设置标志，或者自己设置或清除标志。
event = threading.Event（）#创建event 对象
event.wait（）＃客户端线程可以等待设置标志
event.set（）#a服务器线程可以设置或重置它
event.clear（）# 清除标志位
如果设置了标志，则wait方法不会执行任何操作。
如果该标志被清除，则等待将被阻塞，直到它再次被设置为止。
任意数量的线程都可以等待同一事件。
红绿灯实例
import time,threading
event = threading.Event() # 创建 event 事件对象
def lighter():
count = 0
event.set() # 先设置绿灯
while True:
if count > 5 and count < 10: #改成红灯
event.clear() # 把标志位清除
print("\033[41;1mred light is on...\033[0m")
elif count > 10:
event.set() # 变绿灯
count = 0
else:
print("\033[42;1mgreen light is on...\033[0m")
time.sleep(1)
count += 1
def car(name):
while True:
if event.is_set(): # 代表绿灯
print("[%s] running..."%name)
time.sleep(1)
else:
print("[%s] sees red light,waiting..."%name)
event.wait()
print("\033[34;1m[%s] green light is on,start going...\033[0m"%name)
light = threading.Thread(target=lighter,)
light.start()
car1 = threading.Thread(target=car,args=("tesla",))
car1.start()
13, queue 队列 +生产者消费者模型
当必须在多个线程之间安全地交换信息时，队列在线程编程中特别有用。
class queue.Queue(maxsize=0) #先入先出
class queue.LifoQueue(maxsize=0) #last in fisrt out
class queue.PriorityQueue(maxsize=0) #存储数据时可设置优先级的队列
Queue.qsize()
Queue.empty() #return True if empty
Queue.full() # return True if full
Queue.put(item, block=True, timeout=None)
Queue.get(block=True, timeout=None)
Queue.get_nowait()
Queue.task_done()
Queue.join() block直到queue被消费完毕
生产者消费者模型
import threading,time
import queue
q = queue.Queue(maxsize=10) # 给队列设置一个最大的容量范围
# 生产者
def Producer(name):
count = 1
while True:
q.put("骨头 %s "%count)
print(" %s 生产了骨头 %d"%(name,count))
count += 1
time.sleep(0.5)
#消费者
def Consumer(name):
#while q.size()>0
while True:
print(" [%s] 取到 [%s] 并且吃了它..."%(name,q.get()))
time.sleep(1)
p = threading.Thread(target=Producer,args=("baobaohui",))
c = threading.Thread(target=Consumer,args=("bao",))
c1 = threading.Thread(target=Consumer,args=("hui",))
p.start()
c.start()
c1.start()
泡泡：
已识乾坤大，犹怜草木青。
长空送鸟印，留幻人与灵。 —— 马一浮
1186
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
