线程与进程 | GIL | Python

Posted 2020-10-18 胡说八道

# 进程：系统进行资源调度的基本单元；
# 一个程序在一个数据集上一次动态执行过程；
# 进程：程序，数据集，进程控制块；
# 1.程序：描述进程功能的完成；
# 2.数据集：程序在执行过程中需要使用的资源；
# 3.进程控制块：描述进程执行的变化过程，用来系统控制管理进程；

# 线程：CPU调度的基本单元；轻量级的进程；
# 作用：减少程序并发执行的开销，提高性能；
# 线程没自由自己的系统资源；

# join() # 子线程未执行结束，主线程就一直处于阻塞状态；
# setDaemon(True) # 主线程退出，子线程也跟着结束；
#     必须在start()之前设置；

# 1.Thread类直接创建线程：
    import threading 


    def work(num):
        print("threading---{}".format(num))


    if __name__ == ‘__main__‘:
        # 创建线程
        t1 = threading.Thread(target=work, args=(5,))
        # 开启线程
        t1.start()
        # 返回当前线程
        print(threading.currentThread())
        # 返回正在运行的线程列表
        print(threading.enumerate())
        # 返回正在运行的线程数量
        print(threading.activeCount())
        print(len(threading.enumerate()))

# 2.Thread类继承式创建
    import threading


    class Work(threading.Thread):
        def __init__(self, num):
            threading.Thread.__init__(self)
            self.num = num

        def run(self):
            print(‘执行线程---{}‘.format(self.num))

    t1 = Work(100)
    # 返回线程是否活动
    print(t1.isAlive())
    # 设置线程名
    t1.setName(‘我是小线程‘)
    # 返回线程名
    print(t1.getName())
    t1.start()

# GIL|全局解释器锁
# 实现不同线程资源共享的互斥；
# 计算密集型效率低，I/O密集型效率还是显著的；

# 解决方案：引入多进程
    from multiprocessing import Process

    def work():
        print(‘multiprocessing---1‘)
        
    if __name__ == "__main__":
        # 创建进程
        w1 = multiprocessing.Process(target=work)
        # 启动进程
        t.start()
# 每个进程都拥有一个GIL，进程间不共享资源；

# 互斥锁
    import threading

    lock = threading.Lock()
    lock.acpuire()
    ...
    lock.release()
    # 或者with lock

# 死锁：进程，线程在执行过程中因为资源争夺而导致相互等待的现象；

# 进程间通信

# 进程池
    from multiprocessing import Pool
    
    def work(num):
        print(num)
    
    if __name__ == "__main__"；
        # 实例化进程池对象 
        p = Pool(5)
        for i in range(30)；
            # 执行任务
            p.apply_async(func=work, args=(2,))
            # 等待子进程完毕后关闭进程池
            p.close()
            # 立即关闭进程池
            p.terminate()
            p.join() # 主进程等待所有子进程执行完毕，必须在close()与terminate()后；