目录
什么是线程
线程与进程都是虚拟单位，目的是为了更好的描述某种事物
进程与线程的区别
进程：资源单位
线程：执行单位
开启一个进程，一定会有一个线程，线程才是真正的执行者
- 进程间数据独立，线程间数据共享
- 进程间通信可以使用队列，线程间数据共享
- 线程cpu切换要比进程切换 快的多
开启线程
# coding=utf-8
from threading import Thread
from threading import current_thread
import time'''
开启线程方式1：
'''
def task():
print(f"{current_thread().name} 线程开启")
time.sleep(1)
print(f"{current_thread().name} 线程结束")if __name__ == '__main__': for i in range(3):
t = Thread(target=task)
t.daemon = True
t.start() # 判断子线程是否存活
print(t.is_alive())
print(t.isAlive()) print("主|")'''
开启线程方式2：
'''
class MyThread(Thread):
def run(self):
print(f"{current_thread().name} 线程开启")
time.sleep(1)
print(f"{current_thread().name} 线程结束")if __name__ == '__main__':
t = MyThread()
t.start()Thread-1 线程开启
True
True
Thread-2 线程开启
True
True
Thread-3 线程开启
True
True
主|
线程对象的属性：
current_thread().name：表示当前线程的名字
t.daemon = True：线程的守护进程 跟着主线程一起死掉
t.is_alive() or t.isAlive()：判断子线程是否存活
t.join()：等待子线程结束
为什么要使用线程
节省内存资源
开启进程：会开辟一个名称空间，每开启一个进程都会占用一份内存资源
，会自带一个线程
开启线程：一个进程可以开启多个线程，线程的开销远小于进程
注意：进程不能实现并行，线程只能实现并发，进程可以实现并行
比喻：内存就像一个工厂，子进程就像是一个个工厂车间，线程就像车间内的流水线
线程之间数据是共享的
线程互斥锁
# coding=utf-8from threading import Thread,current_thread,Lock
import timen = 100'''
线程中数据时共享的，如果不加锁，那么每个线程抢到的资源都将是同一个，则不能保证数据的安全
'''
def task(i,mutex):
print(f"线程 {current_thread().name} 启动")
global n # 添加线程互斥锁
mutex.acquire()
temp = n
time.sleep(0.1)
n = temp - 1
# 释放互斥锁
mutex.release() print(f"线程 {current_thread().name} 结束")
# print(n)if __name__ == '__main__':
mutex = Lock()
for i in range(10):
t = Thread(target=task,args=(i,mutex))
t.start()
t.join() print(n)线程 Thread-1 启动
线程 Thread-1 结束
线程 Thread-2 启动
线程 Thread-2 结束
线程 Thread-3 启动
线程 Thread-3 结束
线程 Thread-4 启动
线程 Thread-4 结束
线程 Thread-5 启动
线程 Thread-5 结束
线程 Thread-6 启动
线程 Thread-6 结束
线程 Thread-7 启动
线程 Thread-7 结束
线程 Thread-8 启动
线程 Thread-8 结束
线程 Thread-9 启动
线程 Thread-9 结束
线程 Thread-10 启动
线程 Thread-10 结束
90
