day38 线程基础

初识线程

在操作系统中, 每一个进程都有一个地址空间,而且默认就有一个控制线程,cpu真正的执行单位是线程.(就像是在工厂中,每一个车间都有房子,而且每个车间默认就有一条流水线)
操作系统 ===> 工厂
进程 ===> 车间
线程 ===> 流水线
cpu ===> 电源
线程: cpu最小的执行单位
进程: 资源集合/资源单位
线程运行: 运行代码
进程运行: 各种资源 + 线程

当你右键运行:

首先会申请内存空间,先把解释器丢进去并且把代码也给丢进去(进程的是事情),运行代码(线程)

进程与线程的区别

过程描述的区别

线程 ==> 单指代码的执行过程
进程 ==> 资源的申请与销毁的过程

进程内存空间彼此隔离而同一个进程下的线程共享资源
进程和线程的创建速度

进程需要申请资源开辟空间 (慢)
线程就是告诉操作系统一个执行方案 (快)

线程开启的两种方式

# 方案一
from threading import Thread
import time

def task():
    print('线程 start')
    time.sleep(3)
    print('线程 end')
    
    
if __name__ == '__main__': #线程可以不用这行
    t = Thread(target=task)
    t.start() #告诉操作系统开一个线程
    print('主')
    
# 补充: 进程会等待所有线程结束才会结束   
# 方案二
from threading import Thread
import time

class MyT(Thread):
    def run(self):
        print('子线程 start')
        time.sleep(3)
        print('子进程 end')

子进程vs子进程创建速度对比

from thteading import Thread
from multiprocessing import Process
import time

def task(name):
    print(f'{name} is running')
    time.sleep(2)
    print(f'{name} is end')
    
if __name__ == '__main__':
    t = Thread(target=task, args=('子线程',))
    p = Process(target=task, args=('子进程',))
    t.start# 这个子线程较快
    p.start
    print('')

子线程共享资源

from threading import Thead
import time, os

x = 100
def task():
    global x
    x = 50
    print(os.getpid()) #5204(pid)
    
if __name__ == '__main__':
    t = Thread(target=task)
    t.start()
    time.sleep(2)
    print(x) #50
    print(os.getpid()) #5204

线程join的方法

from threading import Thread
import time
def task():
    print('子线程 start')
    time.sleep(2)
    print('子线程 end')
    
t = Thread(target=task)
t.start
t.join() #等待子线程运行结束
print('主线程')


#案例1
from threading import Thread
import time
def task(name , n):
    print(f'{name} start')
    time.sleep(n)
    print(f'{name} end')
    
t1 = Thread(target=task,args=('线程1', 1))
t2 = Thread(target=task,args=('线程2', 2))
t3 = Thread(target=task,args=('线程3', 3))
start = time.time()
t1.start
t2.start
t3.start
t1.join() #等待子线程运行结束
t2.join()
t3.join()
end = time.time()
print(end-start) #阻塞时间为3点多秒

print('主线程')


#案例二(了解部分)
from multiprocessing import Process
from threading import Thread
import time

def task():
    print('进程 开启') #3
    time.sleep(10)
    print('进程 结束') #5
    
def task2():
    print('子线程 开启') #1
    time.sleep(2)
    print('子线程 结束') #4
    
if __name__ == '__main__':
    p = Process(target=task)
    t = Thread(target=task2)
    t.start() #开线程
    p.start() #开进程
    print('子进程join开始') #2
    p.join() #主进程的主线程等待子进程运行结束
    print('主') #6
    
#结果
子线程 开启
子进程join开始
进程 开启
子线程 结束
进程 结束
主

守护线程

# 守护线程 守护的是进程的运行周期
from threading import Thread,enumerate,currentThread
import time

def task():
    print('守护线程开始')
    print(currentThread())
    time.sleep(20)
    # print('守护线程结束')

def task2():
    print('子线程 start')
    time.sleep(5)
    print(enumerate())
    print('子线程 end')

if __name__ == '__main__':
    t1 = Thread(target=task)
    t2 = Thread(target=task2)
    t1.daemon = True
    t2.start()
    t1.start()
    print('主')

Thread类的其他用法

Thread实例化对象的方法:

```
isAlive(): 返回线程是否活动的
```
```
getName(): 返回线程名字
```
```
setName(): 设置
```

threading模块提供的一些方法:

threading.currentThead(): 返回当前的线程变量

threading.enumerate(): 返回一个包含正在运行的线程list, 正在运行指线程启动后,结束前,不包含启动前和终止后线程

threading.activeCount(): 返回正在运行的线程数量,与len(threading.enumerate())有相同的结果

day38 线程基础

day38 线程基础

猜你喜欢