线程 Thread

线程 Thread

线程 :能被操作系统调度(给CPU执行)的最小单位
数据共享,操作系统调度的最小单位,可以利用多核,操作系统调度,数据不安全,开启关闭切换时间开销小

在CPython中的多线程 - 节省io操作的时间
gc 垃圾回收机制 线程
引用计数 +分代回收
全局解释器锁的出现主要是为了完成gc的回收机制,对不同线程的引用计数的变化记录的更加精准
全局解释器锁 GIL(global interpreter lock)
导致了同一个进程中的多个线程只能有一个线程真正被cpu执行
节省的是io操作的时间,而不是cpu计算的时间,因为cpu的计算速度非常快,大部分情况下,我们没有办法把一条进程中所有的io操作都规避掉

import os
import time
from threading import Thread,current_thread,enumerate,active_count
# # from multiprocessing import Process as Thread
def func(i):
    print('start%s'%i,current_thread().ident)
    time.sleep(1)
    print('end%s'%i)
if __name__ == '__main__':
    tl = []
    for i in range(10):
        t = Thread(target=func,args=(i,))
        t.start()
        print(t.ident,os.getpid())
        tl.append(t)
    print(enumerate(),active_count())
    for t in tl:t.join()
    print('所有的线程都执行完了')
    
 # current_thread() 获取当前所在的线程的对象 current_thread().ident通过ident可以获取线程id
# 线程是不能从外部terminate 关闭
# 所有的子线程只能是自己执行完代码之后就关闭
# enumerate 列表 存储了所有活着的线程对象,包括主线程
# active_count 数字 存储了所有活着的线程个数

# 面向对象的方式起线程
from threading import Thread
class MyThread(Thread):
    def __init__(self,a,b):
        self.a = a
        self.b = b
        super().__init__()

    def run(self):
        print(self.ident)

t = MyThread(1,2)
t.start()  # 开启线程 才在线程中执行run方法
print(t.ident)

# 线程之间的数据的共享
from threading import Thread
n = 100

def func():
    global n
    n -= 1

t_l = []
for i in range(100):
    t = Thread(target=func)
    t.start()
    t_l.append(t)
for t in t_l:
    t.join()
print(n)