一.线程概念
进程是资源分配的最小单位
线程是计算机中调度的最小单位
多线程（即多个控制线程）的概念是，在一个进程中存在多个控制线程，多个控制线程共享该进程的地址空间，相当于一个车间内有多条流水线，都共用一个车间的资源。（一个进程里面开多个线程（共享同一个进程里面的内存空间））
#线程的缘起
资源分配需要分配内存空间,分配cpu:
分配的内存空间存放着临时要处理的数据等,比如要执行的代码,数据
而这些内存空间是有限的,不能无限分配
目前配置高的主机,5万个并发已是上限.线程概念应用而生.
#线程的特点
线程是比较轻量级,能干更多的活,一个进程中的所有线程资源是共享的.
一个进程至少有一个线程在工作
### 线程的缺陷
#线程可以并发,但是不能并行(即可以1个cpu执行,不能多个cpu一起执行)
#原因:
python是解释型语言,执行一句编译一句,而不是一次性全部编译成功,不能提前规划,都是临时调度
容易造成不同的cpu却反复执行同一个程序.所以加了一把锁叫GIL
全局解释器锁(Cpython解释器特有) GIL锁:同一时间一个线程只能被一个cpu执行
#想要并行的解决办法:
(1)用多进程间接实现线程的并发
(2)换一个Pypy,Jpython解释器
#程序分为计算密集型和io密集型
对于计算密集型程序会过度依赖cpu,但网页,爬虫,OA办公,这种io密集型的程序里,python绰绰有余
### 线程相关函数
线程.is_alive() 检测线程是否仍然存在
线程.setName() 设置线程名字
线程.getName() 获取线程名字
currentThread().ident 查看线程id号
enumerate() 返回目前正在运行的线程列表
activeCount() 返回目前正在运行的线程数量
pyhton上是一个任务首先在一个进程上执行，在多个线程内循环执行，然后换到另外一个进程再继续执行，再循环线程，不停的切换，不能进行并行，可以的是进程并发操作，就是这个任务先暂停一下，先换成另外一个任务进程执行。
因为python中有一个GIL锁。
而java上的线程是，多个任务在多个线程上进行执行。不需要不停地进行更换，线程。
二.线程的基本语法
在下面开始之前都需要导入：
from threading import Thread
from multiprocessing import Process
import os, time, random
1.一个进程可以多个线程
def func(num):
time.sleep(random.uniform(0.1, 1))
print("子线程", num, os.getpid())
for i in range(10):
t = Thread(target=func, args=(i,))
t.start()
2.并发多线程和多进程的速度对比? 多线程更快
def func(i):
#time.sleep(random.uniform(0.1,1))
print("子线程",i,os.getpid())
if __name__ == "__main__":
# 1. 计算多线程的执行速度
startime = time.perf_counter()
lst= []
for i in range(1000):
t = Thread(target=func,args=(i,))
t.start()
lst.append(t)
for i in lst:
i.join()
print("程序执行结束")
endtime = time.perf_counter()
print(endtime-startime) #0.2554951
# 2.计算多进程的执行速度
startime = time.perf_counter()
lst = []
for i in range(1000):
p = Process(target=func,args=(i,))
p.start()
lst.append(p)
for i in lst:
i.join()
print("程序执行结束")
endtime = time.perf_counter()
print(endtime-startime) #66.66021479999999
3.多线程共享同一份进程资源
最后得出的数值为0，说明资源共享。
例：
num = 100
lst = []
def func():
global num
num -= 1
for i in range(100):
t = Thread(target=func)
t.start()
lst.append(t)
for i in lst:
i.join()
print(num)
4.线程相关函数
线程.is_alive() 检测线程是否仍然存在
线程.setName() 设置线程名字
线程.getName() 获取线程名字
例：
def func():
#time.sleep(0.1)
pass
t = Thread(target=func)
t.start()
print(t.is_alive()) # False
print(t.getName()) #Thread-1
t.setName("hsz")
print(t.getName()) # hsz
time.sleep(2)
print(t.is_alive()) #False,线程已经结束了所有False
1.currentThread().ident 查看线程id
2.enumerate() 返回目前正在运行的线程列表
3.activeCount() 返回目前正在运行的线程数量
# 1.currentThread().ident 查看线程id号
from threading import current_thread
def func():
print("子线程:",current_thread().ident)
t = Thread(target=func)
t.start()
print("主线程:",current_thread().ident)
# 2.enumerate() 返回目前正在运行的线程列表
from threading import current_thread
from threading import enumerate
def func():
print("子线程:", current_thread().ident)
time.sleep(0.5)
for i in range(10):
t = Thread(target=func)
t.start()
print(len(enumerate()))
time.sleep(3)
# 10个子线程 + 1个主线程 = 11个正在运行的线程
print(enumerate())
print(len(enumerate()))
# 3.activeCount() 返回目前正在运行的线程数量
from threading import current_thread
from threading import activeCount
def func():
print("子线程:", current_thread().ident)
time.sleep(0.5)
for i in range(10):
t = Thread(target=func)
t.start()
print(activeCount())
三.守护线程
守护线程 :等待所有线程执行结束之后,在自动结束,守护所有线程.
例：
from threading import Thread
import time
def func1():
while True:
time.sleep(0.5)
print("我是守护线程")
def func2():
print("func2 -> start")
time.sleep(3)
print("func2 -> end")
t1 = Thread(target=func1)
# setDaemon 讲t1线程对象变成守护线程
t1.setDaemon(True)
t1.start()
t2 = Thread(target=func2)
t2.start()
time.sleep(5)
print("主线程执行结束")
