python---import paramiko模块---多线程---多进程

import paramiko

#模拟ssh连接linux主机

ssh = paramiko.SSHClient()

ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())

ssh.connect(hostname='192.168.1.141',port=22,username='root',password='123456')

while True:

    stdin,stdout,stderr = ssh.exec_command(input('==>:').strip())

    res = stdout.read().decode('gbk')+stderr.read().decode('gbk')

    print(res)

 

 

通过paramiko模块连接主机上传

hostname='192.168.1.141'

port = 22

username = 'root'

password = '123456'

t=paramiko.Transport((hostname,port))

t.connect(username=username,password=password)

sftp = paramiko.SFTPClient.from_transport(t)

sftp.put(r'C:\Users\yy\Desktop\test','/root/c.txt')

sftp.close()

 

通过paramiko模块连接主机下载

hostname = '192.168.1.141'

port = 22

username = 'root'

password = '123456'

t=paramiko.Transport((hostname,port))

t.connect(username=username,password=password)

sftp = paramiko.SFTPClient.from_transport(t)

sftp.get('/root/test', r'C:\Users\yy\Desktop\test')

sftp.close()

 

 

线程和进程

'''

1.线程是最小的调度单位

2.进程是最小的管理单元

3.一个进程必须至少一个线程

4.没有线程，进程也就不复存在

'''

多线程特点：

python线程特点

线程的并发是利用cpu上下文的切换（是并发，不是并行）

多线程执行的顺序是无序的

import threading

import time

def test1(n):

    time.sleep(1)

    print('task', n)

t1 = threading.Thread(target=test1,args=(1,))

t1.start()

for i in range(10):

    t = threading.Thread(target=test1,args=('t-%s' % i,))

    t.start()

 

 

g = 0

def test1():

    global g

    for i in range(1000000):

        g += 1

    print(g)

def test2():

    global g

    for i in range(1000000):

        g += 1

    print(g)

t1 = threading.Thread(target=test1)

t2 = threading.Thread(target=test2)

t1.start()                    执行结果说明一个线程没有执行完毕就被CPU踢出来了

t2.start()                    没有赋值，而另一个进程处理完毕，完成赋值，当第二次处理的时候接着第一次处理的位置 继续处理。 所以所得结果小于2百万                                   

                                

 

线程是继承在进程里的，没有进程就没有线程

GIL全局解释器锁

lock = threading.Lock()

global_num = 0

def test1():

    global global_num

    lock.acquire()

    for i in range(1000000):

        global_num += 1

    lock.release()

def test2():

    global global_num

    lock.acquire()

    for i in range(1000000):

        global_num += 1

    lock.release()

t1 = threading.Thread(target=test1)

t2 = threading.Thread(target=test2)

t1.start()

t2.start()

t1.join()

t2.join()

print(global_num)

 

在IO密集型的代码里，适合用多线程

 

 

一个程序运行起来之后，代码+用到的资源称之为进程，它是操作系统分配资源的基本单位，

不仅可以通过线程完成多任务，进程也是可以的

进程之间是相互独立的

cpu密集的时候适合用多进程

import multiprocessing

import time

g = 0

def test1(n):

    time.sleep(1)

    global g

    for i in range(10):

        g += 1

    print(g)

def test2(n):

    time.sleep(1)

    global g

    for i in range(10):

        g += 1

    print(g)

test1(1)

test2(2)

if __name__ == '__main__':

    p1 = multiprocessing.Process(target=test1,args=(1,))

    p2 = multiprocessing.Process(target=test2,args=(2,))

    p1.start()

    p2.start()

 

 

进程池

import multiprocessing

from multiprocessing import Pool

import time

import threading

g_num = 0

def test1(n):

    for i in range(n):

        time.sleep(1)

        print('test1', i)

def test2(n):

    for i in range(n):

        time.sleep(1)

        print('test2', i)

def test3(n):

    for i in range(n):

        time.sleep(1)

        print('test3', i)

def test4(n):

    for i in range(n):

        time.sleep(1)

        print('test4', i)

 

if __name__ == '__main__':

    pool = Pool(1)#把进程声明出来括号里不写东西说明无限制，如果写数字，就是最大的进程数

    pool.apply_async(test1,(10,))#用pool去调用函数test1，参数为10格式为(10,)

    pool.apply_async(test2,(10,))#用pool去调用函数test2，参数为10格式为(10,)

    pool.apply_async(test3,(10,))#用pool去调用函数test3，参数为10格式为(10,)

    pool.apply_async(test4,(10,))#用pool去调用函数test4，参数为10格式为(10,)

    pool.close()  # close必须在join的前面

    pool.join()