threading多线程模块

概述基本使用 Python中提供了threading模块用来实现线程并发编程，使用方法有两种，一种是将threading模块下的Therad类进行实例化的方式实现，一种是通过继承threading模块下的 基本使用

　　Python中提供了threading模块用来实现线程并发编程，使用方法有两种，一种是将threading模块下的Therad类进行实例化的方式实现，一种是通过继承threading模块下的Therad类并覆写run()方法实现。

　　官方中文文档

实例化Therad类创建子线程

　　这种方式是最常用的也是推荐使用的方式。先来介绍一个Therad类中的方法，然后再看代码。

　　start()：开始线程活动。

　　它在一个线程里最多只能被调用一次。它安排对象的 run() 方法在一个独立的控制进程中调用。如果同一个线程对象中调用这个方法的次数大于一次，会抛出 RuntimeError 。

　　PS：该方法不会立即执行，只是告诉cpu说你可以调度我了，我准备好了，一定要注意不是立即执行！

import threading timeprint("主线程任务开始处理")def task(th_name):    子线程任务开始处理,参数:{0}.format(th_name))    time.sleep(3)  # <-- 这里睡眠了三秒，可以看见主线程继续往下走了    子线程任务处理完毕if __name__ == '__main__':         ==== 实例化出Thread类并添加子线程任务以及参数 ====    t1 = threading.Thread(target=task,args=(线程[1]",))   <-- 参数必须添加逗号。因为是args所以会打散，如果不加逗号则不能进行打散会抛出异常    t1.start()   等待cpu调度..请注意这里不是立即执行        主线程任务处理完毕) ==== 执行结果 ====    """主线程任务开始处理子线程任务开始处理,参数:线程[1]主线程任务处理完毕子线程任务处理完毕"""

　　我们可以看见，在进行time.sleep()的时候线程做了一次切换，这是因为该方法是属于IO *** 作，所以GIL锁将执行权限丢给了主线程。还有一点要注意的就是主线程任务处理完毕后不会立马结束掉，而是等子线程任务处理完毕后才会真正将主线程连同子线程一起kill掉。

　　图示：

自定义类继承Therad并覆写run方法

　　这种方法并不常见，但是还是要举例说出来。我们可以看到第一种方法是实例化出了Therad类，并且执行了其start()方法，然后子线程就可以被调度了，其实在内部是通过start()方法调用了Therad类下的run()方法的。

　　run()：代表线程活动的方法。

　　你可以在子类型里重载这个方法。 标准的 run() 方法会对作为 target 参数传递给该对象构造器的可调用对象（如果存在）发起调用，并附带从 args 和 kwargs 参数分别获取的位置和关键字参数。

　　那么我们就可以自定义一个类并继承Therad类，再覆写run()方法

class Threading(threading.Thread):    自定义类"""    def __init__(self,th_name):        self.th_name = th_name        super(Threading,self).()     run(self):        .format(self.th_name))        time.sleep(3)   <-- 这里睡眠了三秒，可以看见主线程继续往下走了        :        t1 = Threading()    t1.start()  """

　　注意现在依然是主线程任务处理完毕后现在是不会立马结束掉的，而是等子线程任务处理完毕后才会真正将主线程kill掉。其实原则上这两种创建线程的方式都一模一样。

源码浅析-选读

　　这个源码浅析非常浅，主要是来看一下基于实例化Therad类创建子线程内部是如何做的。

　　那么我们看一下其Thread类的源码，：

class threading.Thread(group=None,target=None,name=None,args=(),kwargs={},***,daemon=None)

　　调用这个构造函数时，必需带有关键字参数。参数如下：

　　group 应该为 None；为了日后扩展 ThreadGroup 类实现而保留。

　　target 是用于 run() 方法调用的可调用对象。默认是 None，表示不需要调用任何方法。

　　name 是线程名称。默认情况下，由 "Thread-N" 格式构成一个唯一的名称，其中 N 是小的十进制数。

　　args 是用于调用目标函数的参数元组。默认是 ()。

　　kwargs 是用于调用目标函数的关键字参数字典。默认是 {}。

　　如果不是 None，daemon 参数将显式地设置该线程是否为守护模式。 如果是 None (默认值)，线程将继承当前线程的守护模式属性。

　　如果子类型重载了构造函数，它一定要确保在做任何事前，先发起调用基类构造器(Thread.__init__())。

 Thread:    注释被我删掉了"""        _initialized = False   这是一个状态位，来表示该线程是否被被初始化过__init__(self,group=None,target=None,name=None,args=(),kwargs=None,*,daemon=None):                         """                           assert group is None,group argument must be None for Now" 如果不是 None，daemon参数将显式地设置该线程是否为守护模式。 如果是 None (默认值)，线程将继承当前线程的守护模式属性。        if kwargs is None:            kwargs = {}   kwargs 是用于调用目标函数的关键字参数字典。默认是 {}。        self._target = target   对于第一种调用方式来说，它就是我们的task函数。        self._name = str(name or _newname())   线程名        self._args = args   _args是用于调用目标函数的参数元组。默认是 ()。        self._kwargs = kwargs         if daemon is not None:  判断其是否为守护线程            self._daemonic = daemon        else:            self._daemonic = current_thread().daemon        self._IDent = None  这个是线程的编号        if _HAVE_THREAD_NATIVE_ID:   判断是否具有本地ID            self._native_ID = None        self._tstate_lock = None   锁定的状态        self._started = Event()  开始        self._is_stopped = False  状态位，是否停止        self._initialized = True   将初始化状态为改为True         copy of sys.stderr used by self._invoke_excepthook()        self._stderr = _sys.stderr        self._invoke_excepthook = _make_invoke_excepthook()         For deBUGging and _after_fork()        _dangling.add(self)

Thread类的__init__方法

　　我们可以看见其__init__方法大多都是做了一些初始化的东西。下面我们来看run()方法，它才是离我们最近的一个方法。

 run(self):    """        try:        if self._target:   简单吧，这个方法，就是判断你有没有传入一个函数。即我们定义的task            self._target(*self._args,**self._kwargs)   有的话就立即执行，我们传入的name其实就放在了_args中。这里将它打散出来了，所以我们的task函数中的第一个参数name能收到。    finally AvoID a refcycle if the thread is running a function with         an argument that has a member that points to the thread.        del self._target,self._args,self._kwargs   不管处不出错，都会清理他们。当然，如果有则是执行完成后清理

Tcpserver中的run()方法

　　好了，其实看到这里就行了。其实我们自定义类的传参也可以不用覆写__init__再去调用父类方法初始化进行传参，我们完全以另一种方式，但是我个人不太推荐。

主线程任务开始运行"""    print(self._args)   ('线程[1]',)        print(self._kwargs)   {}        .format(self._args[0]))        time.sleep(3)  子线程任务运行完毕):        t1 = Threading(args=(,))    t1.start()   等待cpu调度..请注意这里不是立即执行            主线程任务开始处理('线程[1]',)主线程任务处理完毕{}子线程任务开始处理,参数:线程[1]子线程任务处理完毕"""

自定义类继承Therad并覆写run方法的其他方式参数传入threading模块方法大全

thrading模块方法大全
方法/属性名称	功能描述
threading.active_count()	查看当前进程下一共存活了多少个线程的数量，返回的是一个int值。
threading.current_thread()	获取当前线程对象。
threading.currentThread()	同上
threading.excepthook(args,/)	处理由 Thread.run() 引发的未捕获异常。
threading.get_IDent()	返回当前线程对象的编号。
threading.get_native_ID()	返回当前线程对象的编号。和threading.get_IDent()相同。
threading.enumerate()	查看当前进程存活了的所有线程对象，以列表形式返回。
threading.main_thread()	返回主线程对象。
threading.settrace(func)	不太清楚..好像是测试用的。
threading.stack_size([size])	返回创建线程时使用的堆栈大小。
threading.TIMEOUT_MAX	规定一个全局的所有阻塞函数的最大时间。

线程对象方法大全

线程对象方法大全（即Thread类的实例对象）
方法/属性名称	功能描述
start()	启动线程，该方法不会立即执行，而是告诉cpu自己准备好了，可以随时调度，而非立即启动。
run()	一般是自定义类继承Thread并覆写的方法，即线程的详细任务逻辑。
join(timeout=None)	主线程默认会等待子线程运行结束后再继续执行，timeout为等待的秒数，如不设置该参数则一直等待。
name	可以通过 = 给该线程设置一个通俗的名字。如直接使用该属性则返回该线程的默认名字。
getname()	获取该线程的名字。
setname()	设置该线程的名字。
IDent	获取线程的编号。
native_ID	获取线程的编号，和IDent相同。
is_alive()	查看线程是否存活，返回布尔值。
isAlive( )	同上，但是不推荐使用这种方法。
daemon	查看线程是否为一个守护线程，返回布尔值。默认为False。
isDaemon()	查看线程是否为一个守护线程，返回布尔值。默认为False。
setDaemon()	设置一个线程为守护线程，参数如果为True则表示该线程被设置为守护线程，默认为False。 当主线程运行完毕之后设置为守护线程的子线程便立即结束执行...

常用方法示例

　　由于方法太多了，所以这里就只例举一些非常常用的。

守护线程setDaemon()

　　setDaemon() ：设置一个线程为守护线程，参数如果为True则表示该线程被设置为守护线程，默认为False。当主线程运行完毕之后设置为守护线程的子线程便立即结束执行...

　　我们对比上面的图，现在子线程是没有设置为守护线程的：

　　当他设置为守护线程之后会是这样的：

　　代码如下：

.format(th_name))    time.sleep(3)    :        t1 = threading.Thread(target=task,))        t1.setDaemon(True)   <-- 设置线程对象t1为守护线程，注意这一步一定要放在start之前。        t1.start()  """

线程阻塞join()

　　join(timeout=None)：主线程默认会等待子线程运行结束后再继续执行，timeout为等待的秒数，如不设置该参数则一直等待。

　　图示如下：（未设置超时时间）

　　代码如下：

:    t1 = threading.Thread(target=task,))    t1.start()    等待cpu调度..请注意这里不是立即执行    t1.join()   <--- 放在start()下面，死等     ==== 执行结果 ===="""

　　图示如下：（设置超时时间）

　　代码如下：

    t1.join(2)   <--- 放在start()下面，等2秒后主线程继续执行    """

注意，join()方法可以多次设置！

join()与setDaemon(True)共存

　　如果同时设置setDaemon(True)与join()方法会怎么样呢？有两种情况：

　　　　1.join()方法没有设置timeout（没有设置即表示死等）或者timeout的时间比子线程作业时间要长，这代表子线程会死在主线程之前，setDaemon(True)也就没有了意义，即失效了。

　　　　2.join()设置了timeout并且timeout的时间比子线程作业时间要短，这代表主线程会死在子线程之前，setDaemon(True)生效，子线程会跟着主线程一起死亡。

 ==== 情况一 ==== <--- 放在start()上面，主线程运行完后会立即终止子线程的运行。但是由于有join()，故不生效。    t1.start()  """

情况一

 ==== 情况二 ===="""

情况二设置与获取线程名

　　我们来看一下如何设置与获取线程名。

　　threading.current_thread() ：获取当前线程对象。

　　getname() ：获取该线程的名字。

　　setname() ：设置该线程的名字。

　　name :可以通过 = 给该线程设置一个通俗的名字。如直接使用该属性则返回该线程的默认名字。

.format(th_name))    obj  =  threading.current_thread()   获取当前线程对象    获取当前的线程名：{0}.format(obj.getname()))    开始设置线程名)    obj.setname(yyy获取修改后的线程名：{0}.format(obj.getname()))    time.sleep(3)  :     ==== 第一步：实例化出Thread类并添加子线程任务以及参数 ====    t1 = threading.Thread(target=task,),name=xxx")   可以在这里设置，如果不设置则为默认格式：Thread-1 数字是按照线程个数来定的    t1.start()   等待cpu调度..请注意这里不是立即执行    主线程名: 直接使用属性 name    """

多线程的应用场景

　　由于GIL锁的存在，Python中对于I/O *** 作来说可以使用多线程编程，如果是计算密集型的 *** 作则不应该使用多线程进行处理，因为没有I/O *** 作就不能通过I/O切换来执行其他线程，故对于计算密集型的 *** 作来说多线程没有什么优势。甚至还可能比普通串行还慢（因为涉及到线程切换，虽然是毫秒级别，但是计算的数值越大这个切换也就越密集，GIL锁是100个cpu指令切换一次的）

　　注意：我们是在Python2版本下进行此次测试，python3版本确实相差不大，但是，从本质上来说依然是这样的。

 timenum = 0 add():    global num    for i in range(10000000):  一千万次        num += 1 sub():    in range(10000000):   一千万次        num -= 1:    start_time = time.time()    add()    sub()    end_time = time.time()    执行时间: start_time)     ==== 执行结果 ==== 三次采集大约在 1.3 - 1.4 秒"""

计算密集型程序的普通串行运行时间

 Coding:utf-8 time.time()    t1 = threading.Thread(target=add,)    t2 = threading.Thread(target=sub,)    t1.start()    t2.start()    t1.join()    t2.join()    end_time =print(u start_time)大约 4 - 5 秒"""

计算密集型程序的多线程并发运行时间补充：Timer线程延迟启动

 threading task():    print(threading.current_thread().getname(),end=""启动了...:    t1 = threading.Timer(3 线程任务三秒后准备就绪，可以被cpu调度执行。    t2.start()    Thread-1启动了...Thread-2启动了..."""

Timer线程延迟启动 总结

以上是内存溢出为你收集整理的threading多线程模块全部内容，希望文章能够帮你解决threading多线程模块所遇到的程序开发问题。

如果觉得内存溢出网站内容还不错，欢迎将内存溢出网站推荐给程序员好友。