python 线程 threading模块

# 进程 : 数据隔离,资源分配的最小单位,可以利用多核,操作系统调度,数据不安全,开启关闭切换时间开销大
    # multiprocessing 如何开启进程 start join
    # 进程有数据不安全的问题 Lock (抢票的例子)
    # 进程之间可以通信ipc:
        # 队列(安全) 管道(不安全)
            # 生产者消费者模型
        # 第三方工具
    # 进程之间可以通过Manager类实现数据共享(不需要会写代码)
    # 一般情况下我们开启的进程数不会超过cpu个数的两倍
# 线程(80%)
    # 什么是线程 :能被操作系统调度(给CPU执行)的最小单位
    # 同一个进程中的多个线程同时被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)