04-进程和线程

最新推荐文章于 2024-06-13 23:55:30 发布

鲨鱼先生123

最新推荐文章于 2024-06-13 23:55:30 发布

阅读量1.6k

点赞数 28

文章标签：开发语言 python

本文链接：https://blog.csdn.net/weixin_45068294/article/details/138541839

版权

一、进程

1.多任务编程

（1）多任务概念：多任务是指在同一时间内执行多个任务

（2）并发：在一段时间内交替去执行任务。（单核CPU：多个软件交替执行）

（3）并行：多个内核是真正的一起执行软件

总结：任务数大于CPU的核数表示并发的去执行多任务，任务数小于等于CPU的核数表示并行的去执行多任务。

2.进程

（1）进程概念：一个正在进行的软件或者编程就是一个进程，他是操作系统进行资源分配的基本单位。

比如：现实生活中的公司可以理解为一个进程，公司提供办公资源，真正干活的是员工，员工可以理解为线程。

注意：一个程序运行后至少有一个进程，一个进程默认有一个线程，进程里面可以创建多个线程，线程是依附在进程里面的，没有进程就没有线程。

进程不干活，只是索要内存，干活的事线程

3.多进程使用

（1）导入进程包

import multiprocessing

（2）Process进程类的说明

Process([group[,target[,name[,args[,kwargs]]]]])

group:指定进程组，目前只能使用None（一般不需要设置）

target:执行的目标任务名（函数名）

name:进程名字

args:以元组的方式给执行任务传参

kwargs:以字典的方式

Process创建的实例对象的常用方法

start():启动子进程实例（创建子进程）

join():等待子进程执行结束

terminate():不管任务是否完成，立即终止子进程

# 1.导入进程包
import multiprocessing
import time

# 跳舞任务
def dance():
    for i in range(3):
        print("跳舞中。。。。")
        time.sleep(0.2)
# 唱歌任务
def sing():
    for i in range(3):
        print("唱歌中。。。。")
        time.sleep(0.2)
if __name__ == "__main__":
    multiprocessing.freeze_support()
    dance_process = multiprocessing.Process(target=dance,name="dance_process")
    sing_process = multiprocessing.Process(target=sing,name="sing_process")
    # 启动进程执行对应的任务
    dance_process.start()
    sing_process.start()

4.获取进程编号

（1）获取进程编号的目的就是主进程和子进程的关系，可以得出子进程是由哪两个主进程创建出来的。

获取当前进程的两种编号

获取当前进程编号

os.getpid()

获取当前父进程编号

os.getppid()

# 1.导入进程包
import multiprocessing
import time
import os


# 跳舞任务
def dance():
    # 获取当前进程编号(子进程)
    dance_process_id = os.getpid()
    # 获取当前进程对象，查看当前代码是由哪个进程执行：multiprocessing.current_process()
    print("dance_process_id:", dance_process_id, multiprocessing.current_process())
    # 获取当前进程的父进程编号
    dance_process_parent_id= os.getppid()
    print("dance_process的父进程编号是：",dance_process_parent_id)
    for i in range(3):
        print("跳舞中。。。。")
        time.sleep(0.2)
#         扩展：根据进程编号强制杀死指定进程
        os.kill(dance_process_parent_id,9)
# 唱歌任务
def sing():
    sing_process_id = os.getpid()
    # 获取当前进程对象，查看当前代码是由哪个进程执行：multiprocessing.current_process()
    print("sing_process_id:", sing_process_id, multiprocessing.current_process())
    sing_process_parent_id = os.getppid()
    print("sing_process的父进程编号是：", sing_process_parent_id)
    for i in range(3):
        print("唱歌中。。。。")
        time.sleep(0.2)
if __name__ == "__main__":
    multiprocessing.freeze_support()
    # 其他代码

    # 2.创建子进程（自己手动创建的进程称为子进程）
    # 获取当前进程编号(主进程)
    main_process_id=os.getpid()
    # 获取当前进程对象，查看当前代码是由哪个进程执行：multiprocessing.current_process()
    print("main_process_id:",main_process_id,multiprocessing.current_process())

    dance_process = multiprocessing.Process(target=dance,name="dance_process")
    print("dance_process:", dance_process)
    sing_process = multiprocessing.Process(target=sing,name="sing_process")
    print("sing_process:", sing_process)
    # 启动进程执行对应的任务
    dance_process.start()
    sing_process.start()

5.进程执行带有参数的任务

Process类执行任务并给任务传参数两种方式：

args：表示以元组的方式给执行任务传参

kwargs：表示以字典的方式给执行任务传参

import multiprocessing


# 显示信息的任务
def show_info(name,age):
    print(name,age)
if __name__ == "__main__":
    multiprocessing.freeze_support()
    # 创建子进程
    # 以元组方式传参，元组里面的元素顺序要和函数顺序保持一致
    # sub_process = multiprocessing.Process(target=show_info,args=("李四",20))
    #
    # # 启动进程
    # sub_process.start()
    # 以字典方式传参，字典里面的key要和函数里面的参数名保持一致，没有顺序要求
    # sub_process = multiprocessing.Process(target=show_info, kwargs={"age":20,"name":"王五"})
    #
    # # 启动进程
    # sub_process.start()



    sub_process = multiprocessing.Process(target=show_info,args=("李四",), kwargs={"age": 20})

    # 启动进程
    sub_process.start()

6.进程的注意点

注意点介绍：

（1）进程之间不会共享全局变量

import multiprocessing
import time

# 定义全局变量列表
g_list = list()
# 添加数据的任务
def add_data():
    for i in range(3):
        # 因为列表是可变类型，可以在原有内存基础上修改数据，并且修改后内存地址不变
        # 所以不需要加上global关键字
        # 加上global 表示声明要修改全局变量内存地址
        g_list.append(i)
        print("add:",i)
        time.sleep(0.2)
    print("添加完成：",g_list)
# 读取数据的任务
def read_data():
    print("read:",g_list)


if __name__ == "__main__":
    multiprocessing.freeze_support()
    # 添加数据的子进程
    add_process = multiprocessing.Process(target=add_data)

    # 读取数据的子进程
    read_porcess = multiprocessing.Process(target=read_data)

    # 启动进程
    add_process.start()
    # 当前进程（主进程）等待添加数据的进程执行完成以后代码在继续往下执行

    add_process.join()
    read_porcess.start()

注意：创建子进程其实就是对主进程资源进行拷贝，子进程其实就是主进程的一个副本。

（2）主进程会等待所有的子进程执行结束后在结束

import multiprocessing
import time


def task():
    for i in range(10):
        print("任务执行中：")
        time.sleep(0.2)

# 判断是否为直接执行主模块，程序入口模块
if __name__ == '__main__':
    # 创建子进程
    sub_process = multiprocessing.Process(target = task)
    # 1.让子进程设置成为守护主进程，主进程退出子进程销毁，子进程会依赖主进程
    # sub_process.daemon = True
    sub_process.start()
    # 主进程延时0.5s钟
    time.sleep(0.5)
    # 2.让主进程退出之前先让子进程销毁
    sub_process.terminate()
    print("over")

# 解决办法：主进程退出子进程销毁

# 1.让子进程设置成为守护主进程，主进程退出子进程销毁，子进程会依赖主进程
# 2.让主进程退出之前先让子进程销毁

二、线程

1.线程概念

线程是进程中执行代码的一个分支，每个执行分支要想工作执行代码需要CPU调度，也就是说线程是CPU调度的基本单位，每个进程至少有一个线程，这个线程称为主线程

多线程可以完成多任务

2.多线程的使用

（1）导入线程模块

import threading

（2）线程类Thread参数说明

Thread([group[,target[,name[,args[,kwargs]]]]])

group:指定进程组，目前只能使用None（一般不需要设置）

target:执行的目标任务名（函数名）

name:线程名字，一般不用设置

args:以元组的方式给执行任务传参

kwargs:以字典的方式

（3）启动线程

使用start方法

（4）多线程完成多任务代码

# 1.导入线程模块
import threading
import time

def sing():
    # 获取当前线程
    current_thread = threading.current_thread()
    print("sing:",current_thread)
    for i in range(3):
        print("唱歌中。。。")
        time.sleep(0.2)
def dance():

    # 获取当前线程
    current_thread = threading.current_thread()
    print("dance:",current_thread)
    for i in range(3):
        print("跳舞中。。。")
        time.sleep(0.2)
        

if __name__ == '__main__':
    current_thread = threading.current_thread()
    print("main_thread:", current_thread)
    # 2.创建子线程
    sing_thread = threading.Thread(target=sing)
    dance_thread = threading.Thread(target=dance)
    # 3，启动子线程
    sing_thread.start()
    dance_thread.start()

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

# 1.导入线程模块
import threading
import time

def show_info(name,age):
    print("name:%s age:%d"%(name,age))


if __name__ == '__main__':
    # 2.创建子线程
    sub_thread = threading.Thread(target=show_info,args=("李四",20))
    
    # 启动时线程执行对应的任务
    sub_thread.start()

4.线程的注意点

（1）线程之间执行是无序的

# import threading
# import time
#
#
# def task():
#     time.sleep(1)
#     print(threading.current_thread())
#
# if __name__ == '__main__':
#     for i in range(20):
#         sub_thread = threading.Thread(target=task)
#
#         sub_thread.start()
#

# 线程之间执行是无序的，具体哪个线程执行是由CPU调度的

import multiprocessing
import time

def task():
    time.sleep(1)
    print(multiprocessing.current_process())


if __name__ == '__main__':
    for i in range(20):
        sub_process= multiprocessing.Process(target=task)

        sub_process.start()
        
        
# 进程之间执行是无序的，是由操作系统调度进程来决定的

（2）主线程会等待所有子线程执行结束后在结束

import threading
import time
def task():
    while True:
        print("任务执行中。。。")
        time.sleep(0.3)

if __name__ == '__main__':
    # daemon=True 表示创建的子线程守护主线程，主线程退出子线程直接销毁
    # sub_thread = threading.Thread(target=task,daemon=True)
    sub_thread = threading.Thread(target=task)
    sub_thread.setDaemon(True)
    sub_thread.start()



    # 主进程延时执行1s
    time.sleep(1)
    print("over")

（3）线程之间共享全局变量

import threading

# 定义全局变量

g_list = []


# 添加数据的任务
def add_data():
    for i in range(3):
        # 每循环一次把数据添加到全局变量
        g_list.append(i)
        print("add:",i)
#     代码执行到此，说明添加数据完成
    print("添加数据完成：",g_list)

def read_data():
    print(g_list)
if __name__ == '__main__':
#     创建添加数据的子线程
    add_thread = threading.Thread(target=add_data)
    # 创建读取数据的子线程
    read_thread = threading.Thread(target=read_data)
    add_thread.start()
    read_thread.start()

（4）线程之间共享全局变量数据出现错误问题

import threading

# 全局变量
g_num = 0

# 循环100万次执行的任务
def task1():
    for i in range(1000000):
        # 每循环一次给全局变量+1
        global g_num   # 表示要声明修改全局变量的内存地址
        g_num+=1

    # 代码执行到此，说明数据计算完成
    print("task1:",g_num)


def task2():
    for i in range(1000000):
        # 每循环一次给全局变量+1
        global g_num  # 表示要声明修改全局变量的内存地址
        g_num += 1

    # 代码执行到此，说明数据计算完成
    print("task2:", g_num)


if __name__ == '__main__':
    # 创建两个子线程
    first_thread = threading.Thread(target=task1)
    second_thread = threading.Thread(target=task2)
    # 启动子线程
    first_thread.start()
    # 线程等待，让第一个线程先执行，然后让第二个线程在执行，保证数据不会有问题
    first_thread.join()
    second_thread.start()

5.互斥锁

线程同步的方式：：

（1）线程等待（join）

（2）互斥锁：对共享数据进行锁定，保证同一时刻只能有一个线程去操作

注意：互斥锁是多个线程一起去抢，抢到锁的线程先执行，没有抢到锁的线程需要等待

（3）互斥锁的使用

threading模块定义了lock变量，这个变量本质上是一个函数，通过调用这个函数可以获取一把互斥锁

步骤：

#创建锁

mutex = threading.lock()

#上锁

mutex.acquire()

....这里编写代码能保证同一时刻只能有一个线程去操作，对共享数据进行锁定

#释放锁

mutex.release()

# 线程等待和互斥锁都是把多任务该成单任务去执行，保证了数据的准确性，但是执行性能会下降

import threading

# 全局变量
g_num = 0



# 创建互斥锁
lock = threading.Lock()
# 循环100万次执行的任务
def task1():
    # 上锁
    lock.acquire()
    for i in range(1000000):
        # 每循环一次给全局变量+1
        global g_num   # 表示要声明修改全局变量的内存地址
        g_num+=1

    # 代码执行到此，说明数据计算完成
    print("task1:",g_num)
    # 释放锁
    lock.release()

def task2():
    # 上锁
    lock.acquire()
    for i in range(1000000):
        # 每循环一次给全局变量+1
        global g_num  # 表示要声明修改全局变量的内存地址
        g_num += 1

    # 代码执行到此，说明数据计算完成
    print("task2:", g_num)
    # 释放锁
    lock.release()

if __name__ == '__main__':
    # 创建两个子线程
    first_thread = threading.Thread(target=task1)
    second_thread = threading.Thread(target=task2)
    # 启动子线程
    first_thread.start()
    # 线程等待，让第一个线程先执行，然后让第二个线程在执行，保证数据不会有问题
    # first_thread.join()
    second_thread.start()

6.死锁

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

7.进程和线程对比

三个方向对比：

（1）关系对比

线程是依附在进程里面的吗，没有进程就没有线程

一个进程默认提供一个线程，进程可以创建多个线程。

（2）区别对比

进程之间不共享全局变量

线程之间共享全局变量，但是要注意资源竞争的问题，解决办法：互斥锁或者线程同步

创建线程的资源开销要比创建线程资源开销大

进程是操作系统资源分配的基本单位，线程是CPU调度的基本单位

线程不能够独立执行，必须依存在进程中

多进程开发比单进程多线程开发稳定性强

（3）优缺点对比

进程优缺点：

优点：可以用多核

缺点：资源开销大

和计算密集型相关操作使用多进程

线程优缺点：

优点：资源开销小

缺点：不能用多核

文件写入，文件下载，i/o操作

鲨鱼先生123

关注

28
点赞
踩
37

收藏

觉得还不错? 一键收藏
0
评论
04-进程和线程

（1）多任务概念：多任务是指在同一时间内执行多个任务（2）并发：在一段时间内交替去执行任务。（单核CPU：多个软件交替执行）（3）并行：多个内核是真正的一起执行软件总结：任务数大于CPU的核数表示并发的去执行多任务，任务数小于等于CPU的核数表示并行的去执行多任务。2.进程（1）进程概念：一个正在进行的软件或者编程就是一个进程，他是操作系统进行资源分配的基本单位。比如：现实生活中的公司可以理解为一个进程，公司提供办公资源，真正干活的是员工，员工可以理解为线程。
复制链接

扫一扫