无敌---进程与线程

分手后的思念是犯贱 2022-11-25 00:42 72阅读 0赞

一：进程  
1：概念：  
进程：操作系统进行资源分配的基本单位。

进程知识点总结：

1：导入进程模块
    import multiprocess
    
    2:创建子进程
    p1 = multiprocess.Process(target=sing)
    
    3:启动子进程
    p1.start()
    
    4:获取进程对象
    multiprocessing.current_process()
    
    5:获取进程ID
    os.getpid()
    
    6:获取父进程ID
    os.getppid()
    
    7:杀死进程
    os.kill(os.getpid(), 9)
    
    8:进程带有参数
    
    元组传参
    p1 = multiprocessing.Process(target=sing, args=(6，))
    
    字典传参
    注意：kwargs中键必须和参数名相同
    p2 = multiprocessing.Process(target=dance, kwargs={
        "num": 4})
    
    9：设置守护线程
    
    子进程对象名.daemon = True
    
    子进程自杀：
    子进程对象名.tarminate()

线程知识点总结：

1：导线程包
    import threading
    
    2:创建子线程
    t1 = threading.Thread(target=sing)
    
    3:启动子线程
    t1.start()
    
    4:获取线程对象
    threading.current_thread()
    
    5:线程的传参方式：
    
    t1 = threading.Thread(target=sing, args=(3,))
    t2 = threading.Thread(target=sing, kwargs={
        "num": 3})
    
    6:创建守护线程：
    方案一:
    t1 = threading.Thread(target=sing,daemon=True)
    方案二：
    t1.setDaemon(True)
    
    方案三：
    t1.daemon = True
    
    7:设置线程同步
    t1.join()
    
    8:锁的使用
    
    创建锁：
    mutex = threading.Lock()
    
    上锁：
    mutex.acquire()
    
    解锁：
    mutex.release()

线程和进程对比：

- 关系对比：
      - 线程依附进程，有进程才有线程
      - 一个进程默认有一个线程，也可以有多个线程
    - 区别对比：
      - 全局变量:
        - 进程不能共享全局变量
        - 线程可以共享全局变量，出现资源竞争问题，可以通过互斥锁和线程同步解决。
      - 开销上：
        - 创建进程的开销比创建线程的开销大
      - 概念上：
        - 进程是操作系统资源分配的单位
        - 线程是cpu调度的单位
      - 关系上：
        - 线程依附进程存在，不能单独存在
      - 稳定性上
        - 多进程编程比单进程多线程编程稳定性更好
    - 优缺点对比：
      - 进程：优点（稳定性，可以使用多核）缺点（开销大）
      - 线程：优点（开销小）缺点（不能使用多核）

2：多进程的使用：  
三步走：导入包：import multiprocessing—>创建子进程：multiprocessing.Process(target=sing)—>启动子进程：  
sing\_process.start()

import multiprocessing
    import time
    
    
    # 跳舞任务
    def dance():
        for i in range(5):
            print("跳舞中...")
            time.sleep(0.2)
    
    
    # 唱歌任务
    def sing():
        for i in range(5):
            print("唱歌中...")
            time.sleep(0.2)
    
    if __name__ == '__main__':
        # 创建跳舞的子进程
        # group: 表示进程组，目前只能使用None
        # target: 表示执行的目标任务名(函数名、方法名)
        # name: 进程名称, 默认是Process-1, .....
        dance_process = multiprocessing.Process(target=dance, name="myprocess1")
        sing_process = multiprocessing.Process(target=sing)
    
        # 启动子进程执行对应的任务
        dance_process.start()
        sing_process.start()

3：获取进程编号和父类进程编号：

# 创建一个子进程,在子进程中查看自己的进程编号,和父亲的编号
    import multiprocessing
    import time
    import os
    
    def test():
        print("我是子进程:", multiprocessing.current_process())
        print("我的进程名是: ", multiprocessing.current_process().name)
        print("我的当前进程编号是: ", os.getpid())
        print("我的父进程的编号是: ", os.getppid())
        for i in range(5):
            print("看我能活几轮...")
            # 杀死我自己,9是杀死指令
            os.kill(os.getpid(), 9)
    
    
    
    
    def main():
    
        p1 = multiprocessing.Process(target=test)
        p1.start()
    
        print("我是父进程:", multiprocessing.current_process())
        print("我是父进程,我的进程名是: ", multiprocessing.current_process().name)
        print("我是父进程,我的进程编号是: ", os.getpid())
    if __name__ == '__main__':
        main()

4：进程执行带有参数的任务:

import multiprocessing
    import time
    
    def sing(num, name):
    
        for i in range(num):
            print("我叫%s,我要唱我的第%d首歌" % (name, i+1))
            time.sleep(1)
    
    
    def dance(num, name):
        for i in range(num):
            print("我叫%s,我要跳我的第%d首舞" % (name, i+1))
            time.sleep(1)
    
    
    def main():
    
        p1 = multiprocessing.Process(target=sing,args=(3,"小明"))
        p2 = multiprocessing.Process(target=dance,kwargs={
        "num": 5, "name": "小红"})
        p1.start()
        p2.start()
    
    
    
    if __name__ == '__main__':
        main()

5:进程之间不共享全局变量：

# 思路:建立一个空数组,在两个进程中分别修改,看输出的情况
    import multiprocessing
    import time
    
    
    def test1():
        for i in range(5):
            g_num.append(i)
    
        print("我是子进程一,我的g_num: ",g_num)
    
    
    def test2():
        print("我是子进程二,我的g_num: ",g_num)
    
    
    
    g_num = []
    
    def main():
        p1 = multiprocessing.Process(target=test1)
        p2 = multiprocessing.Process(target=test2)
    
        p1.start()
        time.sleep(1)
        p2.start()
        print("我是主进程,我的g_num是: ", g_num)
    
    
    if __name__ == '__main__':
        main()
    
    # 运行结果是:
    # 我是子进程一,我的g_num:  [0, 1, 2, 3, 4]
    # 我是主进程,我的g_num是:  []
    # 我是子进程二,我的g_num:  []

6：主进程会等待所有的子进程执行结束再结束

# 思路:让子进程花费比自己多的时间
    import multiprocessing
    import time
    
    def test():
        for i in range(5):
            print("我是子进程,我正在执行......")
            time.sleep(0.2)
    
    
    def main():
        p = multiprocessing.Process(target=test)
        p.start()
    
        time.sleep(0.5)
        print("我是主进程,我要结束啦")
        exit()
    
    if __name__ == '__main__':
        main()
    
    # 运行结果:
    # 我是子进程,我正在执行......
    # 我是子进程,我正在执行......
    # 我是子进程,我正在执行......
    # 我是主进程,我要结束啦
    # 我是子进程,我正在执行......
    # 我是子进程,我正在执行......

7：守护主进程以及子进程的销毁：

# 思路:设置子进程.daemon=True或者 子进程杀死自己
    
    import multiprocessing
    import time
    
    def test():
        for i in range(5):
            print("我是子进程,我正在执行......")
            time.sleep(0.2)
    
    
    def main():
        p = multiprocessing.Process(target=test)
        #将子进程设置成守护主线程
        # p.daemon=True
    
        p.start()
    
        time.sleep(0.5)
        print("我是主进程,我要结束啦")
    
        # 在主进程销毁之前杀死子进程
        p.terminate()
        exit()
    
    if __name__ == '__main__':
        main()
    #
    # 运行结果:
    # 我是子进程,我正在执行......
    # 我是子进程,我正在执行......
    # 我是子进程,我正在执行......
    # 我是主进程,我要结束啦

二：线程：  
1：定义：线程是CPU调度的基本单位  
2：线程的基本使用：

import threading
    import time
    
    # 唱歌任务
    def sing():
        # 扩展： 获取当前线程
        # print("sing当前执行的线程为：", threading.current_thread())
        for i in range(3):
            print("正在唱歌...%d" % i)
            time.sleep(1)
    
    # 跳舞任务
    def dance():
        # 扩展： 获取当前线程
        # print("dance当前执行的线程为：", threading.current_thread())
        for i in range(3):
            print("正在跳舞...%d" % i)
            time.sleep(1)
    
    
    if __name__ == '__main__':
        # 扩展： 获取当前线程
        # print("当前执行的线程为：", threading.current_thread())
        # 创建唱歌的线程
        # target： 线程执行的函数名
        sing_thread = threading.Thread(target=sing)
    
        # 创建跳舞的线程
        dance_thread = threading.Thread(target=dance)
    
        # 开启线程
        sing_thread.start()
        dance_thread.start()

3：线程执行带有参数的任务：

# 思路，主线程向子线程中传递一些参数，在子线程中使用这些参数
    import threading
    import time
    
    
    def dance(num,name):
        for i in range(num):
            print("我是%s,我在跳第%d个舞，欢迎观赏" % (name, i))
            time.sleep(0.2)
    
    def sing(num,name):
        for i in range(num):
            print("我是%s,我在唱第%d个歌，欢迎倾听" % (name,i))
            time.sleep(0.2)
    
    def main():
        t1 = threading.Thread(target=dance, args=(5,"小红"))
    
        # 注意：这里必须键和参数名字相同
        t2 = threading.Thread(target=sing,kwargs={
        "num": 3,"name":"小绿"})
        t1.start()
        t2.start()
    
    
    if __name__ == '__main__':
        main()
    
    
    # # 运行结果：
    # 我是小红,我在跳第0个舞，欢迎观赏
    # 我是小绿,我在唱第0个歌，欢迎倾听
    # 我是小绿,我在唱第1个歌，欢迎倾听
    # 我是小红,我在跳第1个舞，欢迎观赏
    # 我是小绿,我在唱第2个歌，欢迎倾听
    # 我是小红,我在跳第2个舞，欢迎观赏
    # 我是小红,我在跳第3个舞，欢迎观赏
    # 我是小红,我在跳第4个舞，欢迎观赏

4：线程之间执行没有顺序

# 思路：创建10个线程，分别打印
    import  threading
    import  time
    
    def test():
        # 为什么要休眠一秒？？
        time.sleep(1)
        print("我是线程：",threading.current_thread().name)
    
    
    
    def main():
    
        # 因为循环创建线程，先初始化，再启动，可能的第一个和第二个初始化之间，第一个已经启动完成了。这就导致会顺序创建线程。
        # 用睡眠堵塞每个进程，让他们几乎同一时间启动。
        for i in range(10):
            t1 = threading.Thread(target=test)
            t1.start()
    
    if __name__ == '__main__':
        main()

5：主线程要等待所有子线程结束再结束

# 让子线程花费比主线程更多的时间，使用exit退出主线程
    import threading
    import time
    
    def test():
        for i in range(5):
            print("我是子线程.....")
            time.sleep(1)
        print("我是子线程，我死啦")
    
    
    def main():
        t1 = threading.Thread(target=test)
        t1.start()
    
        time.sleep(1)
        print("----我是主线程，我马上就死啦")
        exit()
        print("----我绝对死透了，你看不到我")
    
    if __name__ == '__main__':
        main()
    
    # 运行结果:
    # 我是子线程.....
    # ----我是主线程，我马上就死啦
    # 我是子线程.....
    # 我是子线程.....
    # 我是子线程.....
    # 我是子线程.....
    # 我是子线程，我死啦

6：守护主线程的三种方式:

import threading
    import time
    
    def test():
        print("我是子线程,我要用3s")
        time.sleep(3)
        print("主线程没死，我就让你看到")
    
    
    def main():
    
        # 方法一：在创建子线程的参数中加上daemon=True
        # t1 = threading.Thread(target=test, daemon=True)
        t1 = threading.Thread(target=test)
    
        # 方法二：使用子线程的setDaemo方法
        # t1.setDaemon(True)
    
    
        # 方法三：设置子线程的daemon参数=True
        t1.daemon = True
    
        t1.start()
    
        time.sleep(1)
    
    
    if __name__ == '__main__':
        main()

7:线程之间共享全局变量：

# 思路：对于一个数据，一个线程向里面写数据，一个线程读数据，看能不能读到另外一个线程写入后的数据
    
    import  threading
    
    import time
    
    def num_add():
        for i in range(4):
            g_num.append(i)
    
        print("我是子线程一中的g_num: ",g_num)
    
    def num_read():
        print("我是子线程二中的g_num: ", g_num)
    
    
    
    
    g_num = []
    
    def main():
    
        t1 = threading.Thread(target=num_add)
        t2 = threading.Thread(target=num_read)
    
        t1.start()
        # 保证子线程一执行完成
    
        time.sleep(1)
        t2.start()
        print("我是主线程中的g_num: ", g_num)
    
    
    
    
    
    if __name__ == '__main__':
        main()
    
    # #运行结果
    # 我是子线程一中的g_num:  [0, 1, 2, 3]
    # 我是子线程二中的g_num:  [0, 1, 2, 3]
    # 我是主线程中的g_num:  [0, 1, 2, 3]

8：线程之间共享全局变量存在的问题：

# 思路：如果一个线程给一个全局变量增加100000次，另一个也进行，最后的结果不会是200000，而是在100000到200000之间。
    import  threading
    import  time
    
    def num_add1():
        for i in range(1000000):
            global g_num
            g_num += 1
    
        print("当子线程一只想结束g_num是:", g_num)
    
    
    def num_add2():
        for i in range(1000000):
            global g_num
            g_num += 1
    
        print("当子线程二只想结束g_num是:", g_num)
    
    
    g_num = 0
    
    def main():
        t1 = threading.Thread(target=num_add1)
        t2 = threading.Thread(target=num_add2)
    
        t1.start()
        t2.start()
    
    
    if __name__ == '__main__':
        main()
    
    # 运行结果:
    # 当子线程一只想结束g_num是: 1280374
    # 当子线程二只想结束g_num是: 1589925

9：共享变量的解决方案—同步

# 思路：让一个线程执行完，另一个线程再执行
    import  threading
    import  time
    
    def num_add1():
        for i in range(1000000):
            global g_num
            g_num += 1
    
        print("当子线程一只想结束g_num是:", g_num)
    
    
    def num_add2():
        for i in range(1000000):
            global g_num
            g_num += 1
    
        print("当子线程二只想结束g_num是:", g_num)
    
    
    g_num = 0
    
    def main():
        t1 = threading.Thread(target=num_add1)
        t2 = threading.Thread(target=num_add2)
    
        t1.start()
        # 让子线程一执行结束再开启子线程二
        t1.join()
        t2.start()
    
    
    if __name__ == '__main__':
        main()
    #
    # 运行结果:
    # 当子线程一只想结束g_num是: 1000000
    # 当子线程二只想结束g_num是: 2000000

10：共享变量的解决方案—互斥锁

# 思路：让可能出现资源竞争的地方所上锁
    import  threading
    
    # 1:创建锁
    lock = threading.Lock()
    
    
    def num_add1():
    
        # 2：出现资源竞争的地方所上锁
        lock.acquire()
        for i in range(1000000):
            global g_num
            g_num += 1
    
        print("当子线程一只想结束g_num是:", g_num)
        # 3:执行完释放锁
        lock.release()
    
    
    
    def num_add2():
    
        # 相同地方上锁
        lock.acquire()
        for i in range(1000000):
            global g_num
            g_num += 1
    
        print("当子线程二只想结束g_num是:", g_num)
        # 相同地方解锁
        lock.release()
    
    g_num = 0
    
    def main():
        t1 = threading.Thread(target=num_add1)
        t2 = threading.Thread(target=num_add2)
    
        t1.start()
        t2.start()
    
    
    if __name__ == '__main__':
        main()
    #
    # 运行结果：
    # 当子线程一只想结束g_num是: 1000000
    # 当子线程二只想结束g_num是: 2000000
    
    
    # 问题：为啥不在g_num += 1的前后上锁，而是在循环前后上锁，因为频繁开锁和解锁会降低代码执行效率
    # 导致程序运行缓慢

11：死锁：一直等待对方释放锁的情景就是死锁

import threading
    
    
    lock = threading.Lock()
    
    def get_value(index):
    
        lock.acquire()
    
    
        if index >= len(g_num):
            print("数组下标越界啦")
            lock.release()
            return
    
        value = g_num[index]
        print(value)
        lock.release()
    
    g_num = [1,2,3]
    def main():
        for i in range(30):
    
            t1 = threading.Thread(target=get_value, args=(i,))
            t1.start()
    
    
    if __name__ == "__main__":
        main()