PythonDay9

本章内容：

多线程

ssh

主线程，子线程

paramiko模块
stdin标准输入 stdout标准输出 stderr错误输出

import paramiko
ssh1=paramiko.SSHClient()#建立ssh远程对象
#允许没有建立rsa安全证书注册主机
ssh1.set_missing_host_key_policy(paramiko.AutoAddPolicy())
ssh1.connect(hostname='192.168.1.102',port=22,username='root',password='123456')#连接登陆永明和密码
stdin,stdout,sterr=ssh1.exec_command('df')#执行命令
result=stdout.read()#获取命令结果
print(result.decode())
ssh1.close()#关闭

import paramiko
transport=paramiko.Transport(('192.168.1.102',22))#定义实例将地址和端口穿进去
transport.connect(username='root',password='123456')#连接用户名和密码
sftp=paramiko.SFTPClient.from_transport(transport)
sftp.put('xiaohu','/tmp/my.txt')#上传文件
sftp.get('/tmp/my.txt','qiqi')#下载文件
transport.close()

现在通过ssh秘钥连接
公钥 public key
私钥 private key

多线程和多进程
什么是线程
线程是操作系统运算调度的最小单位，他被包含在进程中，在进程的实际运作单位，一个线程指的是进程中一个单一顺序的控制流，一个进程中可以
并发多个线程，每个线程执行不同的任务
每一个程序（进程）是独立的，是不可以互相访问的
线程共享内存空间，进程是独立的
threading
import threading
import time
def run(n):
print("task",n)
time.sleep(2)
t1=threading.Thread(target=run,args=("t1",))
t2=threading.Thread(target=run,args=("t2",))
t1.start()
t2.start()
#线程是并行的
主线程是不等待子线程执行完成的
join（）#等待第一个线程执行结束执行第二个
通过join实现串行
import threading
import time
def run(n):
print("task",n)
time.sleep(2)
print("taso done",n)
t_objs=[]
start_time=time.time()
for i in range(50):
t1=threading.Thread(target=run,args=("t%s"%i,))
t1.start()#子线程
t_objs.append(t1)
for t1 in t_objs:
t1.join()#子线程
print("all is start")#主线程
print("cost",time.time()-start_time)#主线程

threading.current_thread() #证明自己是主线程
print("all is start",threading.current_thread())#主线程
threading.active_count()显示当前线程个数，包含主线程

守护进程
setDaemon(True)#把当前线程设置成守护线程
t1.setDaemon(True)

import threading,time
class MyThread(threading.Thread):
def __init__(self,n):
super(MyThread,self).__init__()
self.n=n
def run(self):
print("run test",self.n)
time.sleep(2)
t1=MyThread("t1")
t2=MyThread("t2")
t1.start()
t1.join()#变成串行，等待第一个执行结果完毕，执行第二个线程
t2.start()

import threading
class MyThread(threading.Thread):
def __init__(self,n):
super(MyThread,self).__init__()
self.n=n
def run(self):
print("run test",self.n)
t1=MyThread("t1")
t2=MyThread("t2")
t1.start()
t2.start()

如果开发多个线程import threading
import time
def run(n):
print("task",n)
time.sleep(2)
for i in range(50):
t1=threading.Thread(target=run,args=("t%s"%i,))
t1.start()


t1.join()等待第一个线程结束后退出

全局解释器锁

线程和线程之间沟通

Rlock递归锁

互斥锁（mutex）
我修改的时候你不能修改
信号量（Semapore）
互斥锁 同时只允许一个线程更改数据，而Semaphore是同时允许一定数量的线程更改数据 ，比如厕所有3个坑，
那最多只允许3个人上厕所，后面的人只能等里面有人出来了才能再进去。
threading.BoundedSemaphore


父线程子线程
import threading
import time
def run(n):#父线程
print("task",n,threading.current_thread())#子线程
time.sleep(2)
print("task done",n,threading.current_thread())
t_objs=[]
for i in range(50):
t1=threading.Thread(target=run,args=("t%s"%i,))
t=t1.start()
t_objs.append(t)
print("--alll",threading.current_thread())#父线程执行

Events 事件
进行线程之间的同步对象