Python 并发编程（线程）

线程

线程：执行单位,cpu执行的就是线程，一个流水线的运行过程（进程内代码的运行过程）

进程：资源单位，会申请一块内存空间来存放程序，进程是包含线程的一个容器

执行一个Python文件默认会开启一个进程，进程内默认包含一个线程（主线程），相当于执行每个操作都是由一个线程来执行的，而我们开启的子进程其中也包含一个线程，所以它占用的资源会远大于创建一个线程。多线程就是在一个进程内开启多个线程。

线程的优势

1. 同一进程下的多个线程共享该进程的内存空间。
2. 开启子线程的开销远小于开启子进程

线程与进程的区别

1、线程共享创建它的进程的地址空间；进程有自己的地址空间。
2、线程可以直接访问其进程的数据段；进程有自己的父进程数据段副本。
3、线程可以直接与其进程的其他线程通信；进程必须使用进程间通信来与同级进程通信。
4、新线程很容易创建；新进程需要复制父进程。
5、线程可以对同一进程的线程执行相当大的控制；进程只能对子进程执行控制。
6、对主线程的更改（取消、优先级更改等）可能会影响进程的其他线程的行为；对父进程的更改不会影响子进程。

多线程的开启

Python使用threading模块来创建线程，但是其实还有另一种模块_thread也可以创建线程，但基本被淘汰了，其功能远不如threading，所以这里使用的是teahding模块

import threading
import time


def task(n):
    print('当前线程：%s 开始了' % threading.currentThread().name)
    time.sleep(n)
    print('当前线程：%s 结束了' % threading.currentThread().name)
    
	# threading.currentThread() 执行这个函数的线程对象
	# .name这个线程的名称

if __name__ == '__main__':
    t = threading.Thread(target=task, args=(1,))
    t2 = threading.Thread(target=task, args=(2,))

    t.start()
    t2.start()

    t.join()
    t2.join()

    print('主线程结束了',threading.currentThread().name) # 主线程名称

执行结果

'''
当前线程：Thread-1 开始了
当前线程：Thread-2 开始了
当前线程：Thread-1 结束了
当前线程：Thread-2 结束了
主线程结束了 MainThread
'''

创建使用线程的方式与进程大部分都相似

创建、并开启一个子线程的速度远快于一个子进程

import threading

def task():
    print(f'线程：{threading.currentThread().name} 开启')

if __name__ == '__main__':
    t = threading.Thread(target=task)
    t.start()

    print(' 主线程结束了') # 开启线程速度很快，呈现出来的效果几乎会优先这行显示出来

执行结果

'线程：Thread-1 开启 主线程结束了'

以上叙述了一种开启线程的方式，第二种就是通过继承的方式来开启线程

import threading
import time

class MyThread(threading.Thread):
    def __init__(self,count):
        super().__init__()
        self.count = count

    def run(self) -> None:
        print(f'Thread-{self.count}开启了')
        time.sleep(self.count)
        print(f'Thread-{self.count}结束了')

if __name__ == '__main__':
    t = MyThread(1)
    t.start()
    t.join() # 主线程等待子线程结束
    
    print('主线程结束了')

线程对象的常用方法

通过提供的方法，我们可以查看当前进程内线程的状态信息

import threading

threading.currentThread() # 获取当前线程对象
# threading.current_thread() 效果一样

print(threading.currentThread().name) # 获取线程的名称

print(threading.currentThread().is_alive()) # 获取这个线程是否存活

print(threading.active_count()) # 当前进程活跃线程的数量

print(threading.enumerate()) # 当前进程内所有活跃的线程，返回一个列表

print(threading.get_ident()) # 获取当前线程编号

守护线程

当某个线程成为守护线程，它首要关注的是主线程的生命周期，如果主线程生命周期结束，不管这个守护线程是否正在运行，都会随之结束。

守护线程与守护进程不同的是：

守护进程关注的是：父进程的代码是否执行完毕。
守护线程关注的是：当前程序的任务是否执行完毕，但不包括守护线程。

import threading
import time

# 守护线程：守护的是主线程的生命周期
def task(n):
    print(f' 子线程：{threading.current_thread().name} 开启了') # 获取线程名称
    time.sleep(n)
    print(f' 子线程：{threading.current_thread().name} 结束了')

if __name__ == '__main__':
    t = threading.Thread(target=task,args=(10,))
    t.daemon = True # 将t变成守护线程

    t2 = threading.Thread(target=task,args=(5,))

    t.start()
    t2.start()
    # 当前程序，当这个线程运行完以后，整体主线程就会结束，那么不管t线程是否运行完毕，都会结束

    # 主线程会等待所有子线程结束，生命周期才会结束，但是不包括守护线程。
    # 也就是说主线程会等待其它的线程，而不会等待守护线程，当其它线程结束以后，主线程就会结束，并且会携带守护线程一起离去

执行结果<