进程和线程

1.多任务编程

多任务的意思，就是在同一时间执行多个任务， 多任务的作用：充分的利用cpu资源，提高程序的执行效率。

多任务的表现形式：

• 并发：多个任务在同一时间交替执行，单核cpu中。

• 并行：多核cpu中，多个任务同时执行， 但是要注意，如果任务数超过了cpu的核心数，那么并发和并行是一起进行的

2.进程

2.1进程介绍

概念： 操作系统分配资源和调度运行的基本单位，通俗理解，一个正在运行的程序就是一个进程。

import time
# 1. 导入进程模块
import multiprocessing


def sing():
    for i in range(5):
        time.sleep(0.1)
        print('sing.......')


def dance():
    for i in range(5):
        time.sleep(0.1)
        print('dance........')


# 上面的两个函数就是两个任务。如果按照之前代码程序执行的过程, 先执行完sing任务之后，才可以去执行dance任务，
# 同一时间只能执行一个任务。效率低。
# 现在想要实现的效果： 在同一时间内 同时执行多个任务， 提高程序的执行效率。 就可以使用 多进程来实现。
if __name__ == '__main__':
    # 2. 创建进程对象，一个任务就是一个进程对象  ,需要传参数的， 必传的参数， target=要执行的任务函数名   函数名后面不需要加括号
    s_process = multiprocessing.Process(target=sing)
    d_process = multiprocessing.Process(target=dance)
    # 3. 启动进程，执行任务
    s_process.start()
    d_process.start()

上述程序一共有三个进程。

• 一个正在运行的程序中，默认就会有一个进程，这个进程我们成为 主进程

• 在程序运行过程中，我们 又创建了两个进程，s_process、d_process， 这两个进程，我们成为 子进程

2.2进程的使用

1.导包
    import multiprocessing

2.创建子进程对象
    p = multiprocessing.Process([group[,target[,arge[,kwargs]]]]])  
        group
            指定进程组，目前只能使用None
        target
            指定任务函数名字
        args
            给任务函数以元组的方式传参
        kwargs
            给任务函数以字典的方式传参
        daemon = True
            设置守护进程
        name
            给子进程起名
    Process创建的实例对象的常用方法
        start()
            启动子进程实例（创建子进程）
        join()
            等待子进程执行结束
        terminate()
            不管任务是否完成，立即终止子进程

3.启动
    p,start()

进程使用带有参数的任务
    使用args=()
    使用kwargs{形参名：具体的实参值}
 

进程使用的注意点

进程之间不共享全局变量
    子进程会将主进程中创建的全局变量复制一份，每个进行之间的变量是独立的，互步影响的

进程执行的时候是无序的

主进程会等待所有的子进程执行结束之后再结束
    如果不想等子进程
        不管子进程有没有结束，主进程结束的时候程序立刻结束
        1.创建子进程对象的时候，daemon = True
        2.子进程对象.daemon = True
        3.子进程对象,setDeamon(True)
        注意：设置守护进程一定要在启动子进程之前进行设置
 

3. 线程

3.1 介绍

    线程是进程中执行代码的一个分支
    线程是cpu调度的基本单位
    一个程序运行起来，默认会有一个进程，主进程，在这个主进程中默认有一个线程，这个线程就是主线程
    线程是依附于进程的，没有进程就没有线程
    在程序中，我们自己创建的线程就是子线程
 

3.2 线程的使用

1.导包
    import  threading

2.创建对象
    t = threading.Thread()
        target
        args
        kwargs
        daemon = True
            设置守护线程
        参数使用和进程相同

3.启动
    t.start()

注意点

 线程之间的执行是无序的
 线程是由cpu调度决定的
 进程是由操作系统调度决定的
 主线程对等待所有子线程结束之后在结束
        守护线程
            1.创建线程对象的时候daemon = True 设置守护线程
            2.线程对象.daemon = True
            3.线程对象.setDaemon(True)
    在同一个进程中的所有线程是共享全局变量的
    线程之间共享全局变量数据出现错误问题
        子线程对象.join()
            一旦调用join方法，子线程对象会先执行完，在执行后续的任务
        了解互斥锁
            给线程加锁，加锁之后别的线程就不能去抢资源
            在同一时间只能有一个线程去执行任务

3.2 线程的基本使用

# 1、导入模块
import threading
import time


def sing(num):
    for i in range(num):
        time.sleep(0.1)
        print(f'sing-----> {i}')


def dance(num):
    for i in range(num):
        time.sleep(0.1)
        print(f'dance-----> {i}')


if __name__ == '__main__':
    # 2. 创建线程对象
    sing_t = threading.Thread(target=sing, args=(5,))
    dance_t = threading.Thread(target=dance, kwargs={"num": 5})
    # 3. 启动执行
    sing_t.start()
    dance_t.start()