Python线程

概念

什么是进程，在windows操作系统中一个进程就是一个exe或者dll程序、他们相互独立，相互可以通信
一个进程中可以有多个线程，多个线程共享一块内存空间和一组系统资源，系统在各个线程之间切换时，开销要比进程小得多，正应如此，线程被称为轻量级进程；
了解了线程和进程那么我们说说python

python程序中只要有一个线程，这就是主线程，程序启动后由python解释器负责创建主线程，在程序结束后由python解释器负责停止主程序；

线程呢模块--threading

函数常用方法：

• active_count():返回当前处于活动状态的线程个数。
• current_thread():返回当前Thread对象
• main_thread()：返回主线程对象，主线程python解释器启动的线程。

import threading

t=threading.current_thread()
print(t.name)
print(threading.active_count())
t= threading.main_thread()
print(t.name)
执行结果
MainThread
1
MainThread

子线程

• 线程对象：线程对象就是threading模块的线程类Thread或Thread子类所创建的对象。
• 线程体：线程体是子线程要执行的代码，这些代码会被封装到一个函数中。子线程在启动后会执行线程体。
• 实现线程体主要有一下两种方式

1. 自定义函数实现线程体
2. 自定义线程类实现线程体

代码演示

import threading

import  time

value=[]

def thread_body():
    t=threading.current_thread()
    for n in range(5):
        print('第{}次执行线程{}'.format(n,t.name))
        time.sleep(2)
    print('线程{}执行完成'.format(t.name))

t1=threading.Thread(target=thread_body)
t2=threading.Thread(target=thread_body,name='Myt2Thread')
t1.start()
t2.start()

以及使用继承实现

import threading

import  time

value=[]

class SmallThread(threading.Thread):
    def __init__(self,name):
        super().__init__(name=name)

    def run(self) -> None:
        t=threading.current_thread()
        for n in range(5):
            print('第{}次执行线程{}'.format(n, t.name))
            time.sleep(2)
        print('线程{}执行完成'.format(t.name))

def thread_body():
    t=threading.current_thread()
    for n in range(5):
        print('第{}次执行线程{}'.format(n,t.name))
        time.sleep(2)
    print('线程{}执行完成'.format(t.name))

t1 = SmallThread('t1Thread')
# t1=threading.Thread(target=thread_body)
t2=threading.Thread(target=thread_body,name='Myt2Thread')
t1.start()
t2.start()

线程管理

• 等待线程执行结束
  有时，一个线程（假设是主线程）需要等待另外一个线程（假设是 t1子线程）执行结束才能继续执行。

  
  
  image.png
  
  

  使用join方法可以解决该问题,join(timeout=None)设置超时时间,如果没有设置则视为一直等待,如果设置超时后会结束

import threading
import time

value=[]

def thread_body():
    print('子线程开始')
    for n in range(5):
        print('子线程执行')
        value.append(n)
        time.sleep(2)
    print('子线程结束')
print('主线程执行开始')
t1=threading.Thread(target=thread_body)
t1.start()
# t1.join()
print('value={}'.format(value))
print('主线程执行结束')
执行结果
主线程执行开始
子线程开始
子线程执行
value=[0]
主线程执行结束
子线程执行
子线程执行
子线程执行
子线程执行
子线程结束

使用join后

import threading
import time

value=[]

def thread_body():
    print('子线程开始')
    for n in range(5):
        print('子线程执行')
        value.append(n)
        time.sleep(2)
    print('子线程结束')
print('主线程执行开始')
t1=threading.Thread(target=thread_body)
t1.start()
t1.join()
print('value={}'.format(value))
print('主线程执行结束')
执行结果
主线程执行开始
子线程开始
子线程执行
子线程执行
子线程执行
子线程执行
子线程执行
子线程结束
value=[0, 1, 2, 3, 4]
主线程执行结束

线程停止

在线程体结束时，线程就停止了。但在某些业务比较复杂时，会在 线程体中执行一个“死循环”。线程体是否持续执行“死循环”是通过判断 停止变量实现的，“死循环”结束则线程体结束，线程也就结束了。 另外，在一般情况下，死循环会执行线程任务，然后休眠，再执行 ，再休眠，直到结束循环。

image.png

import threading
import time

isrunning=True

def workthread_body():
    while isrunning:
        print('工作线程执行中')
        time.sleep(5)
    print('工作线程执行完毕')

def contorlthread_body():
    global isrunning
    while isrunning:
        comp=input('输入质量暂停')
        if comp == 'exit':
            isrunning=False
            print('控制线程结束')

work=threading.Thread(target=workthread_body)
cont=threading.Thread(target=contorlthread_body)
work.start()
cont.start()


执行结果：

工作线程执行中
输入质量暂停
输入质量暂停
输入质量暂停
输入质量暂停
输入质量暂停工作线程执行中

输入质量暂停
输入质量暂停exit
控制线程结束
工作线程执行完毕