python之多线程1

太过爱你忘了你带给我的痛 2022-05-11 04:10 160阅读 0赞

# 一. 创建线程 #

1.python管理线程的模块

1)**\_thread**  
\_thread.start\_new\_thread(function,args\[,kwargs\]) 的第一个参数是线程函数，第二个参数时传递给线程函数的参数，它必须是tuple类型，kwargs是可选参数。

import _thread     ###_thread创建多线程
        import time
        
        def job(name):
            print("这是一个需要执行的任务")
        
            print(name, time.ctime())
            time.sleep(10)
        if __name__ == "__main__":
            # 创建多个线程, 但是没有开始执行任务；
            _thread.start_new_thread(job,('thread1', ))
            _thread.start_new_thread(job,('thread2', ))
            while True:
                pass

![在这里插入图片描述][70]  
2） **threading**（常用）

#### Thread对象 ####

主要方法： threading.Thread( target=None, name=None, args=(), kwargs=\{\},)

//target是将被run()方法调用的可调用对象。默认为None，表示不调用任何东西。

//name是线程的名字。

//args是给调用目标的参数元组。默认为()。

//kwargs是给调用目标的关键字参数的一个字典。默认为\{\}

start()　　开始执行线程

run()　　//定义线程功能

join(timeout=None)　　//直至启动的线程之前一直挂起，除非给出timeout时间，否则一直阻塞

gerName()　　//返回线程名

#### Threading模块主要函数 ####

threading.active\_count()　　//返回当前处于alive状态的Thread对象的个数。返回的数目等于enumerate()返回的列表的长度。

threading.current\_thread()　　//返回当前的Thread对象，对应于调用者控制的线程。

threading.get\_ident()　　//返回当前线程的’线程标识符’。它是一个非零的整数。它的价值没有直接的意义。

threading.enumerate()　　//返回当前活着的Thread对象的列表。该列表包括守护线程、由current\_thread()创建的虚假线程对象和主线程。它不包括已终止的线程和尚未开始的线程。

threading.main\_thread()　　//返回主 Thread 对象。在正常情况下，主线程是从 Python 解释器中启动的线程。

import threading
    import time
    
    def job(name):
        print("这是一个需要执行的任务: %s" %(name))
        # 激活的线程个数
        print("当前线程的个数:", threading.active_count())
        # 打印当前线程的详细信息
        print("当前线程信息:", threading.current_thread())
        print(time.ctime())
        time.sleep(10)
    
        print(name, time.ctime())
    
    if __name__ == "__main__":
    
        # 创建多个线程
        t1 = threading.Thread(target=job, name='job1', args=("job1-name",))
        t1.start()
        t2 = threading.Thread(target=job, name='job2', args=("job2-name",))
        t2.start()

![在这里插入图片描述][70 1]

# 二.多线程的join方法 #

join所完成的工作就是线程同步，即主线程任务结束之后，进入阻塞状态，一直等待其他的子线程执行结束之后，主线程再终止

例：使用线程与不使用线程运行程序用时比较  
1.不使用多线程

import time
    
    def music(name):
        for i in range(2):
            print("正在听音乐%s" %(name))
            time.sleep(1)
    def code(name):
        for i in range(2):
            print("正在编写代码%s" %(name))
            time.sleep(2)
    if __name__ == '__main__':
        start_time = time.time()
        music("中国梦")
        code("爬虫")
        print("花费时间: %s" %(time.time()-start_time))

![在这里插入图片描述][70 2]  
2，使用多线程

import threading
    import time
    
    def music(name):
        for i in range(2):
            print("正在听音乐%s" %(name))
            time.sleep(1)
    
    def code(name):
        for i in range(2):
            print("正在编写代码%s" %(name))
            time.sleep(2)
    
    if __name__ == '__main__':
        start_time = time.time()
        # music("中国梦")
        # code("爬虫")
    
        t1 = threading.Thread(target=music, args=("中国梦",))
        t2 = threading.Thread(target=code, args=("爬虫", ))
    
        t1.start()
        t2.start()
    
        # 等待所有的子线程执行结束之后， 继续执行主线程的内容;
        t1.join()
        t2.join()
    
        print("花费时间: %s" %(time.time()-start_time))

![在这里插入图片描述][70 3]  
上面是不使用join方法的結果  
![在这里插入图片描述][70 4]

# 三.设置守护线程（setDaemon） #

使用setDaemon(True)方法，设置子线程为守护线程时，主线程一旦执行结束，则全部线程全部被终止执行，可能出现的情况就是，子线程的任务还没有完全执行结束，就被迫停止 import threading import time

# 任务1：
    def music(name):
        for i in range(2):
            print("正在听音乐%s" %(name))
            time.sleep(1)
    # 任务2：
    def code(name):
        for i in range(2):
            print("正在编写代码%s" %(name))
            time.sleep(2)
    
    if __name__ == '__main__':
        start_time = time.time()
        # music("中国梦")
        # code("爬虫")
    
        t1 = threading.Thread(target=music, args=("中国梦",))
        t2 = threading.Thread(target=code, args=("爬虫", ))
    
        # 将t1线程生命为守护线程, 如果设置为True, 子线程启动， 当主线程执行结束， 子线程也结束
        # 设置setDaemon必须在启动线程之前进行设置;
        t1.setDaemon(True)
        t2.setDaemon(True)
        t1.start()
        t2.start()
    
        # 等待所有的子线程执行结束之后， 继续执行主线程的内容;
        # t1.join()
        # t2.join()
    
        print("花费时间: %s" %(time.time()-start_time))

![在这里插入图片描述][70 5]

# 四.多線程的使用 #

1,多線程批量管理主機

import threading
    import  paramiko
    from paramiko.ssh_exception import NoValidConnectionsError, AuthenticationException
    
    
    def connect(cmd, hostname, port=22, user='root'):
    
        client = paramiko.SSHClient()
    
        private_key = paramiko.RSAKey.from_private_key_file('id_rsa')
    
        client.set_missing_host_key_policy(paramiko.AutoAddPolicy())
        try:
            client.connect(hostname=hostname,
                           port=port,
                           username=user,
                           pkey=private_key
                          )
    
            stdin, stdout, stderr = client.exec_command(cmd)
        except NoValidConnectionsError as e:
            print("%s连接失败" %(hostname))
        except AuthenticationException as e:
            print("%s密码错误" %(hostname))
        else:
            # print("%s连接成功" %(hostname))
    
            result = stdout.read().decode('utf-8')
            print("%s连接成功%s" %(hostname,result))
        finally:
    
            client.close()
    
    threads = []
    for count in range(254):
        host = '172.25.254.%s' % (count + 1)
        t = threading.Thread(target=connect,args=('uname',host))
        threads.append(t)
        t.start()
    
    __=[thread.join() for thread in threads]
    print("任务执行结束")

![在这里插入图片描述][70 6]  
2.獲取Ip地理位置

import json
    import threading
    from urllib.request import urlopen
    
    import time
    
    
    def job(ip):
        url = "http://ip.taobao.com/service/getIpInfo.php?ip=%s" % (ip)
        text = urlopen(url).read().decode('utf-8')
    
        d = json.loads(text)['data']
        country = d['country']
        city = d['city']
        print("%s:" %(ip), country, city)
    def has_many_thread():
        start_time = time.time()
        threads = []
        ips = ['172.25.254.250', '8.8.8.8',
               '172.25.254.250', '8.8.8.8',
               '172.25.254.250', '8.8.8.8' ]
        for ip in ips:
    
            t = threading.Thread(target=job, args=(ip, ))
            threads.append(t)
    
            t.start()
    
        [thread.join() for thread in threads]
        print("Success, 多线程运行的时间:%s" %(time.time()-start_time))
    def has_no_thread():
        start_time = time.time()
        ips = ['172.25.254.250', '8.8.8.8',
               '172.25.254.250', '8.8.8.8',
               '172.25.254.250', '8.8.8.8']
        for ip in ips:
            job(ip)
        print("Success, 非多线程运行的时间:%s" % (time.time() - start_time))
    if __name__ == '__main__':
        has_many_thread()
        has_no_thread()

![在这里插入图片描述][70 7]

[70]: /images/20220511/2adf550b16f7400b8164923c1b40c284.png
[70 1]: /images/20220511/7be38c7af5024e0a82b658efa76de685.png
[70 2]: /images/20220511/f5431a1131fc4711a16563aa040503e2.png
[70 3]: /images/20220511/425f39881dfa43339fcb5dd452e781e5.png
[70 4]: /images/20220511/afe787039d5c4c098222341b4300f0f0.png
[70 5]: /images/20220511/a26e121b178647338841acdfdac46e91.png
[70 6]: /images/20220511/57fe16b15faf43c28aa6eed7dfa6d8c3.png
[70 7]: /images/20220511/78796fd01ddf45a786a6d0968ceec6a6.png