Python进阶--线程-初解

Python进阶–线程-初解

1. 简介

线程是计算机运算时所能调度的最小单位，线程之上时进程，一个进程包含多个线程。如果把计算机想象成一个工厂，进程就是一个车间，一个车间生产一个产品（软件、软件的子程序…），线程就是车间工人，每个工人负责生产产品的一部分（程序的子任务）。

基于pyton3的threading模块进行探究。

通常将延时较大的子任务放入开辟的线程去运行，从而通过提高并发量提升执行效率。

2. 使用

每个线程执行一项具体任务、操作。

from threading import Thread

def worker():
    print("新线程已启动")

if __name__ == '__main__':
    print("主线程已启动")
    #1.生成线程对象
    th_obj= Thread(target=worker)
    #2.启动线程
    th_obj.start()
    
主线程已启动
新线程已启动

为任务worker开辟一个新线程（容器），主线程和新线程执行对应功能。

2.1 创建

#创建线程对象
class Therad:
    def __init__(self, group=None, target=None, name=None,
                 args=(), kwargs=None, *, daemon=None)
th_obj= Thread(target=worker)

• target：可调用对象，即线程需要执行的任务
• args，kwargs：参数target的参数
• name：线程名
• demo：bool型，守护标志位。

2.2 启动

th_obj.start()

启动后，线程挂在在线程队列上（线程较多时，cpu在线程队列上遍历线程、分时执行）。

2.3 生存状态

from threading import current_thread as cd, Thread, enumerate
import time

def worker():
    print('线程<%s >已启动' % cd().name)
    time.sleep(1)
    print('线程<%s >已关闭' % cd().name)

if __name__ == '__main__':
    obj_th = Thread(target= worker, name='线程一号')
    print(obj_th, obj_th.is_alive())
    obj_th.start()
    print(obj_th, obj_th.is_alive())
    time.sleep(3)
    print(obj_th, obj_th.is_alive())
    
<Thread(线程一号, initial)> False
<Thread(线程一号, started 140309028095744)> True
线程<线程一号 >已启动
线程<线程一号 >已关闭
<Thread(线程一号, stopped 140309028095744)> False

方法is_alive返回一个bool型数据，若线程对象正在运行（start方法执行后到线程结束前）返回True，反之返回False.

2.4 属性

线程对象的属性常用有ident, name, daemon

2.4.1 ident, name

from threading import Thread, current_thread as ct
import time

def worker():
    print("线程：%s 的id是：%d"%(ct().name, ct().ident))


if __name__ == '__main__':
    print("主线程已启动")
    #1.生成线程对象
    th_obj1= Thread(target=worker, name="线程一")
    #2.启动线程
    th_obj1.start()
    
主线程已启动
线程：线程一 的id是：139705775535872

• 属性ident返回线程号
• 属性name返回线程名（前提是要取名）

2.4.2 daemon

属性daemon意思是守护，其含义为daemon=True时，主线程不需要等待新线程结束后再结束（即将新线程放于后台运行）

例1：daemon = None

from threading import Thread, current_thread as ct
import time

def worker():
    print("线程：%s 已启动" % ct().name)
    time.sleep(2)             #做个延时，让新线程比主线程运行久
    print("线程：%s 的id是：%d" % (ct().name, ct().ident))


if __name__ == '__main__':
    print("主线程已启动")
    #1.生成线程对象
    th_obj1= Thread(target=worker, name="线程一") #daemon默认为None
    #2.启动线程
    th_obj1.start()
    # th_obj2.start()
    
主线程已启动
线程：线程一 已启动       #后面有延时
线程：线程一 的id是：140192825079552   #延时后打印

例2：daemon=False

from threading import Thread, current_thread as ct
import time

def worker():
    print("线程：%s 已启动" % ct().name)
    time.sleep(2)
    print("线程：%s 的id是：%d" % (ct().name, ct().ident))


if __name__ == '__main__':
    print("主线程已启动")
    #1.生成线程对象
    th_obj2= Thread(target=worker, name="线程一", daemon=False)
    #2.启动线程
    th_obj2.start()
    # th_obj2.start()
    
主线程已启动
线程：线程一 已启动   #有时候主线程运行太快，这句也不打印

daemon=True后，主线程与新线程的守护关系打开，不再依赖。主线程执行完自己的任务后，直接结束自己，不管新线程死活（新线程自立门户了）。

3 threading

threading模块由于多内置方法，用于便捷使用线程

3.1 current_thread

方法current_thread返回当前线程对象

from threading import current_thread as ct
if __name__ == '__main__':
    print(ct())
    
<_MainThread(MainThread, started 140049141180160)>

3.2 enumerate

方法enumerate返回处于运行状态的线程列表。

from threading import Thread, current_thread as ct, enumerate
import time

def worker1():
    print(enumerate())

if __name__ == '__main__':
    print("主线程已启动")
    #1.生成线程对象
    th_obj2= Thread(target=worker1, name="线程一")
    #2.启动线程
    th_obj2.start()
    
主线程已启动
[<_MainThread(MainThread, started 139767890433792)>, <Thread(线程一, started daemon 139767866418944)>]