python之多线程1

一. 创建线程

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

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()

二.多线程的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))

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))

上面是不使用join方法的結果

三.设置守护线程（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))

四.多線程的使用

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("任务执行结束")

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()