秦皇岛 网站建设,网站开发网页,亲情网络广告推广怎么做,泗泾做网站公司本节内容 主机管理之paramiko模块学习 进程、与线程区别python GIL全局解释器锁线程语法join线程锁之Lock\Rlock\信号量将线程变为守护进程Event事件 queue队列生产者消费者模型Queue队列开发一个线程池进程语法进程间通讯进程池 转载#xff1a; http://www.cnblogs.co…本节内容 主机管理之paramiko模块学习 进程、与线程区别python GIL全局解释器锁线程语法join线程锁之Lock\Rlock\信号量将线程变为守护进程Event事件 queue队列生产者消费者模型Queue队列开发一个线程池进程语法进程间通讯进程池 转载 http://www.cnblogs.com/alex3714/articles/5230609.html paramiko模块学习 SSHClient用于连接远程服务器并执行基本命令 基于用户名密码连接 1 import paramiko2 3 # 创建SSH对象4 ssh paramiko.SSHClient()5 # 允许连接不在know_hosts文件中的主机6 ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())7 # 连接服务器8 ssh.connect(hostnamec1.salt.com, port22, usernamewupeiqi, password123)9
10 # 执行命令
11 stdin, stdout, stderr ssh.exec_command(df)
12 # 获取命令结果
13 result stdout.read()
14
15 # 关闭连接
16 ssh.close() import paramikotransport paramiko.Transport((hostname, 22))
transport.connect(usernamewupeiqi, password123)ssh paramiko.SSHClient()
ssh._transport transportstdin, stdout, stderr ssh.exec_command(df)
print stdout.read()transport.close() SSHClient 封装 Transport 基于公钥密钥连接 1 import paramiko2 3 private_key paramiko.RSAKey.from_private_key_file(/home/auto/.ssh/id_rsa)4 5 # 创建SSH对象6 ssh paramiko.SSHClient()7 # 允许连接不在know_hosts文件中的主机8 ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())9 # 连接服务器
10 ssh.connect(hostnamec1.salt.com, port22, usernamewupeiqi, keyprivate_key)
11
12 # 执行命令
13 stdin, stdout, stderr ssh.exec_command(df)
14 # 获取命令结果
15 result stdout.read()
16
17 # 关闭连接
18 ssh.close() import paramikoprivate_key paramiko.RSAKey.from_private_key_file(/home/auto/.ssh/id_rsa)transport paramiko.Transport((hostname, 22))
transport.connect(usernamewupeiqi, pkeyprivate_key)ssh paramiko.SSHClient()
ssh._transport transportstdin, stdout, stderr ssh.exec_command(df)transport.close() 封装Transport连接 import paramiko
from io import StringIOkey_str -----BEGIN RSA PRIVATE KEY-----
MIIEpQIBAAKCAQEAq7gLsqYArAFco02/55IgNg0r7NXOtEM3qXpb/dabJ5Uyky/8
NEHhFiQ7deHIRIuTW5Zb0kD6h6EBbVlUMBmwJrC2oSzySLU1wZNfH0PE6W6fans
H80whhuc/YgPfjiOVR/gFcqib8Rll5UfYzf5H8uuOnDeIXGCVgyHQSmt8if1e
7hn1MVO1Lrm9Fco8ABI7dyv8/ZEwoSfh2C9rGYgA58LT1FkBRkOePbHD43xNfAYC
tfLvz6LErMnwdOW4sNMEWWAWv1fsTB35PAm5CazfKzmam9n5IQXhmUNcNvmaZtvP
c4f4g59mdsaWNtNaY96UjOfx83Om86gmdkKcnwIDAQABAoIBAQCnDBGFJuv8aA7A
ZkBLeGN815JtOyye7lIS1n2I7En3oImoUWNaJEYwwJ8LmjxMwDCtAkR0XwbvY
cnsKPEtkjb3sAu6I148RmwWsGncSRqUaJrljOypaW9dSGO4Ujjz3/lw1lrxSUh
IqVc0E7kyRW8kP3QCaNBwArYteHreZFFp6XmtKMtXaEA3saJYILxaaXlYkoRi4k8
S2/K8aw3ZMR4tDCOfB4o47JaeiA/e185RK3AmLn9xTDhTdZqTQpv17/YRPcgmwz
zu30fhVXQT/SuI0sObzCO4YGoEwoBX718AWhdLJFoFq1B7k2ZEzXTAtjEXQEWm6
01ndU/jhAasdfasdasdfasdfa3eraszxqwefasdfadasdffsFIfAsjQb4HdkmHuC
OeJrJOdCYvdEeqJJNnF6AbHyYHIECkj0Qq1kEfLOEsqzd5nDbtkKBte6M1trbjl
HtJ2Yb8w6o/q/6Sbj7wf/cW3LIYEdeVCjScozVcQ9R83ea05JQOAr4nAoGBAMaq
UzLJfLNWZ5Qosmir2oHStFlZpxspax/ln7DlWLW4wPB4YJalSVovF2Buo8hr8X65
lnPiE41MG0Z7icEXiFyDBFDCtzx0x/RmaBokLathrFtI81UCx4gQPLaSVNMlvQA
539GsubSrO4LpHRNGg/weZ6EqQOXvHvkUkm2bDDJAoGATytFNxen6GtC0ZT3SRQM
WYfasdf3xbtuykmnluiofasd2sfmjnljkt7khghmghdasSDFGQfgaFoKfaawoYeH
C2XasVUsVviBn8kPSLSVBPX4JUfQmA6h8HsajeVahxN1U9e0nYJ0sYDQFUMTS2t8
RT57WK/0ONwTWHduKnaJECgYEAid/ta8LQC3p82iNAZkpWlGDSD2yb/8rH8NQg
9tjEryFwrbMtfX9qn8srx06B796U3OjifstjJQNmVI0qNlsJpQK8fPwVxRxbJS/
pMbNICrf3sUa4sZgDOFfkeuSlgACh4cVIozDXlR59Z8Y3CoiW0uObEgvMDIfenAj
98pl3ZkCgYEAj/UCSni0dwX4pnKNPm6LUgiS7QvIgM3H9piyt8aipQuzBi5LUKWw
DlQC4Zb73nHgdREtQYYXTu7p27Bl0Gizz1sW2eSgxFU8eThucfVwOXKAXKU5SeI
MbuBfUYQ4if2N/BXn47/ecf3A4KgB37Le5SbLDddwCNxGlBzbpBa0
-----END RSA PRIVATE KEY-----private_key paramiko.RSAKey(file_objStringIO(key_str))
transport paramiko.Transport((10.0.1.40, 22))
transport.connect(usernamewupeiqi, pkeyprivate_key)ssh paramiko.SSHClient()
ssh._transport transportstdin, stdout, stderr ssh.exec_command(df)
result stdout.read()transport.close()print(result) 封装Transport私钥 SFTPClient 用于连接远程服务器并执行上传下载 基于用户名密码上传下载 1 import paramiko2 3 transport paramiko.Transport((hostname,22))4 transport.connect(usernamewupeiqi,password123)5 6 sftp paramiko.SFTPClient.from_transport(transport)7 # 将location.py 上传至服务器 /tmp/test.py8 sftp.put(/tmp/location.py, /tmp/test.py)9 # 将remove_path 下载到本地 local_path
10 sftp.get(remove_path, local_path)
11
12 transport.close() 基于公钥密钥上传下载 1 import paramiko2 3 private_key paramiko.RSAKey.from_private_key_file(/home/auto/.ssh/id_rsa)4 5 transport paramiko.Transport((hostname, 22))6 transport.connect(usernamewupeiqi, pkeyprivate_key )7 8 sftp paramiko.SFTPClient.from_transport(transport)9 # 将location.py 上传至服务器 /tmp/test.py
10 sftp.put(/tmp/location.py, /tmp/test.py)
11 # 将remove_path 下载到本地 local_path
12 sftp.get(remove_path, local_path)
13
14 transport.close() 实例 #!/usr/bin/env python
# -*- coding:utf-8 -*-
import paramiko
import uuidclass Haproxy(object):def __init__(self):self.host 172.16.103.191self.port 22self.username wupeiqiself.pwd 123self.__k Nonedef create_file(self):file_name str(uuid.uuid4())with open(file_name,w) as f:f.write(sb)return file_namedef run(self):self.connect()self.upload()self.rename()self.close()def connect(self):transport paramiko.Transport((self.host,self.port))transport.connect(usernameself.username,passwordself.pwd)self.__transport transportdef close(self):self.__transport.close()def upload(self):# 连接上传file_name self.create_file()sftp paramiko.SFTPClient.from_transport(self.__transport)# 将location.py 上传至服务器 /tmp/test.pysftp.put(file_name, /home/wupeiqi/tttttttttttt.py)def rename(self):ssh paramiko.SSHClient()ssh._transport self.__transport# 执行命令stdin, stdout, stderr ssh.exec_command(mv /home/wupeiqi/tttttttttttt.py /home/wupeiqi/ooooooooo.py)# 获取命令结果result stdout.read()ha Haproxy()
ha.run()Demo View Code 进程与线程 什么是进程(process) 程序并不能单独运行只有将程序装载到内存中系统为它分配资源才能运行而这种执行的程序就称之为进程。程序和进程的区别就在于程序是指令的集合它是进程运行的静态描述文本进程是程序的一次执行活动属于动态概念。 在多道编程中我们允许多个程序同时加载到内存中在操作系统的调度下可以实现并发地执行。这是这样的设计大大提高了CPU的利用率。进程的出现让每个用户感觉到自己独享CPU因此进程就是为了在CPU上实现多道编程而提出的。 有了进程为什么还要线程 进程有很多优点它提供了多道编程让我们感觉我们每个人都拥有自己的CPU和其他资源可以提高计算机的利用率。很多人就不理解了既然进程这么优秀为什么还要线程呢其实仔细观察就会发现进程还是有很多缺陷的主要体现在两点上 进程只能在一个时间干一件事如果想同时干两件事或多件事进程就无能为力了。 进程在执行的过程中如果阻塞例如等待输入整个进程就会挂起即使进程中有些工作不依赖于输入的数据也将无法执行。 例如我们在使用qq聊天 qq做为一个独立进程如果同一时间只能干一件事那他如何实现在同一时刻 即能监听键盘输入、又能监听其它人给你发的消息、同时还能把别人发的消息显示在屏幕上呢你会说操作系统不是有分时么但我的亲分时是指在不同进程间的分时呀 即操作系统处理一会你的qq任务又切换到word文档任务上了每个cpu时间片分给你的qq程序时你的qq还是只能同时干一件事呀。 再直白一点 一个操作系统就像是一个工厂工厂里面有很多个生产车间不同的车间生产不同的产品每个车间就相当于一个进程且你的工厂又穷供电不足同一时间只能给一个车间供电为了能让所有车间都能同时生产你的工厂的电工只能给不同的车间分时供电但是轮到你的qq车间时发现只有一个干活的工人结果生产效率极低为了解决这个问题应该怎么办呢。。。。没错你肯定想到了就是多加几个工人让几个人工人并行工作这每个工人就是线程 什么是线程(thread) 线程是操作系统能够进行运算调度的最小单位。它被包含在进程之中是进程中的实际运作单位。一条线程指的是进程中一个单一顺序的控制流一个进程中可以并发多个线程每条线程并行执行不同的任务 总结 进程: qq 要以一个整体的形式暴露给操作系统管理里面包含对各种资源的调用内存的管理网络接口的调用等。。。对各种资源管理的集合 就可以成为 进程 线程: 是操作系统最小的调度单位 是一串指令的集合 进程与线程的区别 1-线程共享内存空间进程的内存是独立的 2-同一个进程的线程之间可以直接交流两个进程想通信必须通过一个中间代理来实现 3-创建新线程很简单 创建新进程需要对其父进程进行一次克隆 4-一个线程可以控制和操作同一进程里的其他线程但是进程只能操作子进程 Python threading模块 1-线程的调用 2-join等待运行结束 setDaemon守护进程 3-线程锁(互斥锁Mutex) 4-Semaphore(信号量)允许最大允许线程数 5-Events 事件是一个简单的同步对象; 该事件表示一个内部标志和线程可以等待标志设置或设置或清除标志本身。 event threading.Event 客户端线程可以等待标志被设置event.wait 一个服务器线程可以设置或重置它event.setevent.clear如果设置了该标志则wait方法不会执行任何操作。如果标志被清除等待将阻塞直到它再次设置。任何数量的线程可能会等待相同的事件。 通过Event来实现两个或多个线程间的交互下面是一个红绿灯的例子即起动一个线程做交通指挥灯生成几个线程做车辆车辆行驶按红灯停绿灯行的规则。 1 import threading,time2 import random3 def light():4 if not event.isSet():5 event.set() #wait就不阻塞 #绿灯状态6 count 07 while True:8 if count 10:9 print(\033[42;1m--green light on---\033[0m)
10 elif count 13:
11 print(\033[43;1m--yellow light on---\033[0m)
12 elif count 20:
13 if event.isSet():
14 event.clear()
15 print(\033[41;1m--red light on---\033[0m)
16 else:
17 count 0
18 event.set() #打开绿灯
19 time.sleep(1)
20 count 1
21 def car(n):
22 while 1:
23 time.sleep(random.randrange(10))
24 if event.isSet(): #绿灯
25 print(car [%s] is running.. % n)
26 else:
27 print(car [%s] is waiting for the red light.. %n)
28 if __name__ __main__:
29 event threading.Event()
30 Light threading.Thread(targetlight)
31 Light.start()
32 for i in range(3):
33 t threading.Thread(targetcar,args(i,))
34 t.start() queue队列 作用 1-解耦使程序直接实现松耦合 2-提高处理效率 class queue.Queue(maxsize0) #先入先出 class queue.LifoQueue(maxsize0) #last in fisrt out class queue.PriorityQueue(maxsize0) #存储数据时可设置优先级的队列 1 import queue2 3 q queue.PriorityQueue()4 5 q.put((-1,A))6 q.put((3,B))7 q.put((10,C))8 q.put((6,A1))9
10 print(q.get())
11 print(q.get())
12 print(q.get())
13 print(q.get()) View Code 生产者消费者模型 在并发编程中使用生产者和消费者模式能够解决绝大多数并发问题。该模式通过平衡生产线程和消费线程的工作能力来提高程序的整体处理数据的速度。 为什么要使用生产者和消费者模式 在线程世界里生产者就是生产数据的线程消费者就是消费数据的线程。在多线程开发当中如果生产者处理速度很快而消费者处理速度很慢那么生产者就必须等待消费者处理完才能继续生产数据。同样的道理如果消费者的处理能力大于生产者那么消费者就必须等待生产者。为了解决这个问题于是引入了生产者和消费者模式。 什么是生产者消费者模式 生产者消费者模式是通过一个容器来解决生产者和消费者的强耦合问题。生产者和消费者彼此之间不直接通讯而通过阻塞队列来进行通讯所以生产者生产完数据之后不用等待消费者处理直接扔给阻塞队列消费者不找生产者要数据而是直接从阻塞队列里取阻塞队列就相当于一个缓冲区平衡了生产者和消费者的处理能力。 下面来学习一个最基本的生产者消费者模型的例子 1 import threading,time2 3 import queue4 5 q queue.Queue(maxsize10)6 7 def Producer(name):8 count 19 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(targetProducer,args(A1,))
26 c threading.Thread(targetConsumer,args(q1,))
27 c1 threading.Thread(targetConsumer,args(q2,))
28
29
30 p.start()
31 c.start()
32 c1.start() View Code 1 import time,random2 import queue,threading3 q queue.Queue()#线程的queue,实例化4 def Producer(name):5 count 06 while count 20:7 time.sleep(random.randrange(3))8 q.put(count)9 print(Producer %s has produced %s baozi.. %(name, count))
10 count 1
11 def Consumer(name):
12 count 0
13 while count 20:
14 time.sleep(random.randrange(4))
15 if not q.empty():
16 data q.get()
17 print(data)
18 print(\033[32;1mConsumer %s has eat %s baozi...\033[0m %(name, data))
19 else:
20 print(-----no baozi anymore----)
21 count 1
22 p1 threading.Thread(targetProducer, args(A,))
23 c1 threading.Thread(targetConsumer, args(B,))
24 p1.start()
25 c1.start() 多进程multiprocessing 多进程是一个使用类似于线程模块的API来支持产卵过程的包。 多处理包提供本地和远程并发通过使用子进程而不是线程来有效地侧移全局解释器锁。 因此多处理模块允许程序员充分利用给定机器上的多个处理器。 进程间通讯 不同进程间内存是不共享的要想实现两个进程间的数据交换可以用以下方法 Queues 使用方法跟threading里的queue差不多 1 from multiprocessing import Process, Queue2 3 def f(q):4 q.put([42, None, hello])5 6 if __name__ __main__:7 q Queue()8 p Process(targetf, args(q,))9 p.start()
10 print(q.get()) # prints [42, None, hello]
11 p.join() 进程数据共享 进程各自持有一份数据默认无法共享数据 1 from multiprocessing import Process, Manager2 3 def f(d, l):4 d[1] 15 d[2]26 d[3]None7 l.append(1)8 print(l)9
10
11 if __name__ __main__:
12 with Manager() as manager:
13 d manager.dict()
14
15 l manager.list(range(5))
16 p_list []
17 for i in range(3):
18 p Process(targetf, args(d, l))
19 p.start()
20 p_list.append(p)
21 for res in p_list:
22 res.join()
23 print(d)#{1: 1, 3: None, 2: 2}
24 print(l)#[0, 1, 2, 3, 4, 1, 1, 1] 进程同步-进程锁 当创建进程时非使用时共享数据会被拿到子进程中当进程中执行完毕后再赋值给原值。 1 from multiprocessing import Process, Lock2 3 4 def f(l, i):5 l.acquire()6 print(hello world, i)7 l.release()8 9
10 if __name__ __main__:
11 lock Lock()
12
13 for num in range(100):
14 Process(targetf, args(lock, num)).start() 进程锁 进程池 进程池内部维护一个进程序列当使用时则去进程池中获取一个进程如果进程池序列中没有可供使用的进进程那么程序就会等待直到进程池中有可用进程为止。 进程池中有两个方法 applyapply_async 1 from multiprocessing import Process, Pool,freeze_support2 import time3 import os4 5 def Foo(i):6 time.sleep(2)7 print(in process,os.getpid())8 return i 1009
10 def Bar(arg):
11 print(--exec done:, arg,os.getpid())
12
13 if __name__ __main__:
14 #freeze_support()#windows下的要加
15 pool Pool(processes3) #允许进程池同时放入3个进程
16 print(主进程,os.getpid())
17 for i in range(7):
18 pool.apply_async(funcFoo, args(i,), callbackBar) #callback回调,调用bar方法
19 #pool.apply(funcFoo, args(i,)) #串行
20 #pool.apply_async(funcFoo, args(i,)) #串行非阻塞时运行
21 print(end)
22 pool.close()#一定要加上
23 pool.join() #进程池中进程执行完毕后再关闭如果注释那么程序直接关闭。.join() View Code 转载于:https://www.cnblogs.com/liguanqiu/p/6734143.html
