Python基础-多进程和多线程

最新推荐文章于 2024-07-26 21:19:18 发布
最新推荐文章于 2024-07-26 21:19:18 发布
阅读量51 收藏
点赞数
分类专栏： Python基础 文章标签： python 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45187774/article/details/132735025
版权

并行与并发

并发:在一段时间内交替去执行任务。
并行:对于多核cpu处理多任务，操作系统会给cpu的每个内核安排一个执行的软件，
    多个内核是真正的一起执行软件。这里需要注意多核cpu是并行的执行多任务，始终有多个软件一起执行。

进程

进程的概念

一个正在运行的程序或者软件就是一个进程，它是操作系统进行资源分配的基本单位，
也就是说每启动一个进程，操作系统都会给其分配一定的运行资源(内存资源)保证进程的运行。

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

进程的理解

多进程可以完成多任务，每个进程就好比一家独立的公司，每个公司都各自在运营，每个进程也各自在运行，执行各自的任务。

多进程

# 导入进程包
import multiprocessing

Process进程类的说明
Process([group [, target [, name [, args [, kwargs]]]]])
    group：指定进程组，目前只能使用None
    target：执行的目标任务名
    name：进程名字
    args：以元组方式给执行任务传参
    kwargs：以字典方式给执行任务传参
Process创建的实例对象的常用方法:
    start()：启动子进程实例（创建子进程）
    join()：等待子进程执行结束
    terminate()：不管任务是否完成，立即终止子进程
Process创建的实例对象的常用属性:
    name：当前进程的别名，默认为Process-N，N为从1开始递增的整数

示例代码

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()


执行结果：
    唱歌中...
    跳舞中...
    唱歌中...
    跳舞中...
    唱歌中...
    跳舞中...
    唱歌中...
    跳舞中...
    唱歌中...
    跳舞中...

获取进程编号

获取进程编号的目的是验证主进程和子进程的关系，可以得知子进程是由那个主进程创建出来的。
获取进程编号的两种操作
    获取当前进程编号
    获取当前父进程编号

获取当前进程编号

os.getpid()表示获取当前进程编号

示例代码

import multiprocessing
import time
import os


# 跳舞任务
def dance():
    # 获取当前进程的编号
    print("dance:", os.getpid())
    # 获取当前进程
    print("dance:", multiprocessing.current_process())
    for i in range(5):
        print("跳舞中...")
        time.sleep(0.2)
        # 扩展:根据进程编号杀死指定进程
        os.kill(os.getpid(), 9)


# 唱歌任务
def sing():
    # 获取当前进程的编号
    print("sing:", os.getpid())
    # 获取当前进程
    print("sing:", multiprocessing.current_process())
    for i in range(5):
        print("唱歌中...")
        time.sleep(0.2)


if __name__ == '__main__':
    # 获取当前进程的编号
    print("main:", os.getpid())
    # 获取当前进程
    print("main:", multiprocessing.current_process())
    # 创建跳舞的子进程
    # 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()

执行结果：
    main: 13976    主进程id
    main: <_MainProcess name='MainProcess' parent=None started>
    dance: 13764    子进程id
    dance: <Process name='myprocess1' parent=13976 started>    
        parent=13976 表示父进程id为13976，是13976这个进程创建出来的子进程
    跳舞中...
    sing: 14976     子进程id
    sing: <Process name='Process-2' parent=13976 started>   
        parent=13976 表示父进程id为13976，是13976这个进程创建出来的子进程
    唱歌中...
    唱歌中...
    唱歌中...
    唱歌中...
    唱歌中...

获取当前父进程编号

os.getppid()表示获取当前父进程编号

示例代码

import multiprocessing
import time
import os


# 跳舞任务
def dance():
    # 获取当前进程的编号
    print("dance:", os.getpid())
    # 获取当前进程
    print("dance:", multiprocessing.current_process())
    # 获取父进程的编号
    print("dance的父进程编号:", os.getppid())
    for i in range(5):
        print("跳舞中...")
        time.sleep(0.2)
        # 扩展:根据进程编号杀死指定进程
        os.kill(os.getpid(), 9)


# 唱歌任务
def sing():
    # 获取当前进程的编号
    print("sing:", os.getpid())
    # 获取当前进程
    print("sing:", multiprocessing.current_process())
    # 获取父进程的编号
    print("sing的父进程编号:", os.getppid())
    for i in range(5):
        print("唱歌中...")
        time.sleep(0.2)


if __name__ == '__main__':
    # 获取当前进程的编号
    print("main:", os.getpid())
    # 获取当前进程
    print("main:", multiprocessing.current_process())
    # 创建跳舞的子进程
    # 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()

执行结果：
    main: 13320
    main: <_MainProcess name='MainProcess' parent=None started>
    dance: 14692
    dance: <Process name='myprocess1' parent=13320 started>
    sing: 10468
    sing: <Process name='Process-2' parent=13320 started>
    dance的父进程编号: 13320
    跳舞中...
    sing的父进程编号: 13320
    唱歌中...
    唱歌中...
    唱歌中...
    唱歌中...
    唱歌中...

进程执行带有参数的任务

Process类执行任务并给任务传参数有两种方式:
    args 表示以元组的方式给执行任务传参
    kwargs 表示以字典方式给执行任务传参

args参数的使用

import multiprocessing
import time


# 带有参数的任务
def task(count):
    for i in range(count):
        print("任务执行中..")
        time.sleep(0.2)
    else:
        print("任务执行完成")


if __name__ == '__main__':
    # 创建子进程
    # args: 以元组的方式给任务传入参数
    sub_process = multiprocessing.Process(target=task, args=(5,))
    sub_process.start()

任务执行中..
任务执行中..
任务执行中..
任务执行中..
任务执行中..
任务执行完成

kwargs参数的使用

import multiprocessing
import time


# 带有参数的任务
def task(count):
    for i in range(count):
        print("任务执行中..")
        time.sleep(0.2)
    else:
        print("任务执行完成")


if __name__ == '__main__':
    # 创建子进程

    # kwargs: 表示以字典方式传入参数
    sub_process = multiprocessing.Process(target=task, kwargs={"count": 3})
    sub_process.start()

任务执行中..
任务执行中..
任务执行中..
任务执行完成

进程的注意点

进程之间不共享全局变量
主进程会等待所有的子进程执行结束再结束

进程之间不共享全局变量

import multiprocessing
import time

# 定义全局变量
g_list = list()


# 添加数据的任务
def add_data():
    for i in range(5):
        g_list.append(i)
        print("add:", i)
        time.sleep(0.2)

    # 代码执行到此，说明数据添加完成
    print("add_data:", g_list)


def read_data():
    print("read_data:", g_list)


if __name__ == '__main__':
    # 创建添加数据的子进程
    add_data_process = multiprocessing.Process(target=add_data)
    # 创建读取数据的子进程
    read_data_process = multiprocessing.Process(target=read_data)

    # 启动子进程执行对应的任务
    add_data_process.start()
    # 主进程等待添加数据的子进程执行完成以后程序再继续往下执行，读取数据
    add_data_process.join()
    read_data_process.start()

    print("main:", g_list)

    # 总结: 多进程之间不共享全局变量

add: 0
add: 1
add: 2
add: 3
add: 4
add_data: [0, 1, 2, 3, 4]
main: []
read_data []

创建子进程会对主进程资源进行拷贝，也就是说子进程是主进程的一个副本，好比是一对双胞胎，
之所以进程之间不共享全局变量，是因为操作的不是同一个进程里面的全局变量，只不过不同进程里面的全局变量名字相同而已。

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

假如我们现在创建一个子进程，这个子进程执行完大概需要2秒钟，现在让主进程执行0.5秒钟就退出程序，查看一下执行结果

示例代码

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)
    sub_process.start()

    # 主进程延时0.5秒钟
    time.sleep(0.5)
    print("over")
    exit()

    # 总结： 主进程会等待所有的子进程执行完成以后程序再退出

任务执行中...
任务执行中...
任务执行中...
over
任务执行中...
任务执行中...
任务执行中...
任务执行中...
任务执行中...
任务执行中...
任务执行中...

说明:
    通过上面代码的执行结果，我们可以得知: 主进程会等待所有的子进程执行结束再结束
    假如我们就让主进程执行0.5秒钟，子进程就销毁不再执行，那怎么办呢?
        我们可以设置守护主进程 或者 在主进程退出之前 让子进程销毁
    守护主进程:
        守护主进程就是主进程退出子进程销毁不再执行
    子进程销毁:
        子进程执行结束

保证主进程正常退出的示例代码

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)
    # 设置守护主进程，主进程退出子进程直接销毁，子进程的生命周期依赖与主进程
    # sub_process.daemon = True
    sub_process.start()

    time.sleep(0.5)
    print("over")
    # 让子进程销毁
    sub_process.terminate()
    exit()

    # 总结： 主进程会等待所有的子进程执行完成以后程序再退出
    # 如果想要主进程退出子进程销毁，可以设置守护主进程或者在主进程退出之前让子进程销毁

任务执行中...
任务执行中...
任务执行中...
over

线程

在Python中，想要实现多任务除了使用进程，还可以使用线程来完成，线程是实现多任务的另外一种方式。

线程的概念

线程是进程中执行代码的一个分支，每个执行分支（线程）要想工作执行代码需要cpu进行调度 ，
也就是说线程是cpu调度的基本单位，每个进程至少都有一个线程，而这个线程就是我们通常说的主线程。
多线程可以完成多任务

多线程

导入线程模块

# 导入线程模块
import threading

线程类Thread参数说明
Thread([group [, target [, name [, args [, kwargs]]]]])
    group: 线程组，目前只能使用None
    target: 执行的目标任务名
    args: 以元组的方式给执行任务传参
    kwargs: 以字典方式给执行任务传参
    name: 线程名，一般不用设置
启动线程使用start()方法

多线程完成多任务示例代码

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()

正在唱歌...0
正在跳舞...0
正在唱歌...1
正在跳舞...1
正在唱歌...2
正在跳舞...2

线程执行带有参数的任务

Thread类执行任务并给任务传参数有两种方式:
    args 表示以元组的方式给执行任务传参
    kwargs 表示以字典方式给执行任务传参

args参数的使用

import threading
import time


# 带有参数的任务
def task(count):
    for i in range(count):
        print("任务执行中..")
        time.sleep(0.2)
    else:
        print("任务执行完成")


if __name__ == '__main__':
    # 创建子线程
    # args: 以元组的方式给任务传入参数
    sub_thread = threading.Thread(target=task, args=(5,))
    sub_thread.start()

任务执行中..
任务执行中..
任务执行中..
任务执行中..
任务执行中..
任务执行完成

kwargs参数的使用

import threading
import time


# 带有参数的任务
def task(count):
    for i in range(count):
        print("任务执行中..")
        time.sleep(0.2)
    else:
        print("任务执行完成")


if __name__ == '__main__':
    # 创建子线程
    # kwargs: 表示以字典方式传入参数
    sub_thread = threading.Thread(target=task, kwargs={"count": 3})
    sub_thread.start()

任务执行中..
任务执行中..
任务执行中..
任务执行完成

线程的注意点

线程之间执行是无序的
主线程会等待所有的子线程执行结束再结束
线程之间共享全局变量
线程之间共享全局变量数据出现错误问题

线程之间执行是无序的

import threading
import time


def task():
    time.sleep(1)
    print("当前线程:", threading.current_thread().name)


if __name__ == '__main__':

   for _ in range(5):
       sub_thread = threading.Thread(target=task)
       sub_thread.start()

当前线程: Thread-1
当前线程: Thread-2
当前线程: Thread-4
当前线程: Thread-5
当前线程: Thread-3

线程之间执行是无序的，它是由cpu调度决定的 ，cpu调度哪个线程，哪个线程就先执行，没有调度的线程不能执行。
进程之间执行也是无序的，它是由操作系统调度决定的，操作系统调度哪个进程，哪个进程就先执行，没有调度的进程不能执行。

主线程会等待所有子线程执行结束再结束

假如我们现在创建一个子线程，这个子线程执行完大概需要2.5秒钟，现在让主线程执行1秒钟就退出程序，查看一下执行结果

示例代码

import threading
import time


# 测试主线程是否会等待子线程执行完成以后程序再退出
def show_info():
    for i in range(5):
        print("test:", i)
        time.sleep(0.5)


if __name__ == '__main__':
    sub_thread = threading.Thread(target=show_info)
    sub_thread.start()

    # 主线程延时1秒
    time.sleep(1)
    print("over")

test: 0
test: 1
over
test: 2
test: 3
test: 4

通过上面代码的执行结果，我们可以得知: 主线程会等待所有的子线程执行结束再结束
假如我们就让主线程执行1秒钟，子线程就销毁不再执行，那怎么办呢?
我们可以设置守护主线程
守护主线程:
    守护主线程就是主线程退出子线程销毁不再执行
设置守护主线程有两种方式：
    threading.Thread(target=show_info, daemon=True)
    线程对象.setDaemon(True)

设置守护主线程示例代码

import threading
import time


# 测试主线程是否会等待子线程执行完成以后程序再退出
def show_info():
    for i in range(5):
        print("test:", i)
        time.sleep(0.5)


if __name__ == '__main__':
    # 创建子线程守护主线程 
    # daemon=True 守护主线程
    # 守护主线程方式1
    sub_thread = threading.Thread(target=show_info, daemon=True)
    # 设置成为守护主线程，主线程退出后子线程直接销毁不再执行子线程的代码
    # 守护主线程方式2
    sub_thread.setDaemon(True)
    sub_thread.start()

    # 主线程延时1秒
    time.sleep(1)
    print("over")

test: 0
test: 1
over

线程之间共享全局变量

需求:
    定义一个列表类型的全局变量
    创建两个子线程分别执行向全局变量添加数据的任务和向全局变量读取数据的任务
    查看线程之间是否共享全局变量数据

示例代码

import threading
import time


# 定义全局变量
my_list = list()

# 写入数据任务
def write_data():
    for i in range(5):
        my_list.append(i)
        time.sleep(0.1)
    print("write_data:", my_list)


# 读取数据任务
def read_data():
    print("read_data:", my_list)


if __name__ == '__main__':
    # 创建写入数据的线程
    write_thread = threading.Thread(target=write_data)
    # 创建读取数据的线程
    read_thread = threading.Thread(target=read_data)

    write_thread.start()
    # 延时
    # time.sleep(1)
    # 主线程等待写入线程执行完成以后代码在继续往下执行
    write_thread.join()
    print("开始读取数据啦")
    read_thread.start()

write_data: [0, 1, 2, 3, 4]
开始读取数据啦
read_data: [0, 1, 2, 3, 4]

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

需求:
    定义两个函数，实现循环100万次，每循环一次给全局变量加1
    创建两个子线程执行对应的两个函数，查看计算后的结果

import threading

# 定义全局变量
g_num = 0


# 循环一次给全局变量加1
def sum_num1():
    for i in range(1000000):
        global g_num
        g_num += 1

    print("sum1:", g_num)


# 循环一次给全局变量加1
def sum_num2():
    for i in range(1000000):
        global g_num
        g_num += 1
    print("sum2:", g_num)


if __name__ == '__main__':
    # 创建两个线程
    first_thread = threading.Thread(target=sum_num1)
    second_thread = threading.Thread(target=sum_num2)

    # 启动线程
    first_thread.start()
    # 启动线程
    second_thread.start()

sum1: 1210949
sum2: 1496035

注意点:
    多线程同时对全局变量操作数据发生了错误
错误分析:
    两个线程first_thread和second_thread都要对全局变量g_num(默认是0)进行加1运算，但是由于是多线程同时操作，有可能出现下面情况：
    在g_num=0时，first_thread取得g_num=0。此时系统把first_thread调度为”sleeping”状态，
        把second_thread转换为”running”状态，t2也获得g_num=0
    然后second_thread对得到的值进行加1并赋给g_num，使得g_num=1
    然后系统又把second_thread调度为”sleeping”，把first_thread转为”running”。线程t1又把它之前得到的0加1后赋值给g_num。
    这样导致虽然first_thread和first_thread都对g_num加1，但结果仍然是g_num=1
全局变量数据错误的解决办法:
    线程同步: 保证同一时刻只能有一个线程去操作全局变量 同步: 就是协同步调，按预定的先后次序进行运行。
    如:你说完，我再说, 好比现实生活中的对讲机
全局变量数据错误的解决办法:
    线程同步: 保证同一时刻只能有一个线程去操作全局变量 同步: 就是协同步调，按预定的先后次序进行运行。如:你说完，我再说, 好比现实生活中的对讲机
线程同步的方式:
    线程等待(join)
    互斥锁

线程等待

import threading

# 定义全局变量
g_num = 0


# 循环1000000次每次给全局变量加1
def sum_num1():
    for i in range(1000000):
        global g_num
        g_num += 1

    print("sum1:", g_num)


# 循环1000000次每次给全局变量加1
def sum_num2():
    for i in range(1000000):
        global g_num
        g_num += 1
    print("sum2:", g_num)


if __name__ == '__main__':
    # 创建两个线程
    first_thread = threading.Thread(target=sum_num1)
    second_thread = threading.Thread(target=sum_num2)

    # 启动线程
    first_thread.start()
    # 主线程等待第一个线程执行完成以后代码再继续执行，让其执行第二个线程
    # 线程同步： 一个任务执行完成以后另外一个任务才能执行，同一个时刻只有一个任务在执行
    first_thread.join()
    # 启动线程
    second_thread.start()

sum1: 1000000
sum2: 2000000

互斥锁

互斥锁: 对共享数据进行锁定，保证同一时刻只能有一个线程去操作。
注意:
    互斥锁是多个线程一起去抢，抢到锁的线程先执行，没有抢到锁的线程需要等待，等互斥锁使用完释放后，其它等待的线程再去抢这个锁。

互斥锁的使用

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

互斥锁使用步骤

# 创建锁
mutex = threading.Lock()

# 上锁
mutex.acquire()

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

# 释放锁
mutex.release()

注意点:
    acquire和release方法之间的代码同一时刻只能有一个线程去操作
    如果在调用acquire方法的时候 其他线程已经使用了这个互斥锁，那么此时acquire方法会堵塞，直到这个互斥锁释放后才能再次上锁。

使用互斥锁完成2个线程对同一个全局变量各加100万次的操作

import threading


# 定义全局变量
g_num = 0

# 创建全局互斥锁
lock = threading.Lock()


# 循环一次给全局变量加1
def sum_num1():
    # 上锁
    lock.acquire()
    for i in range(1000000):
        global g_num
        g_num += 1

    print("sum1:", g_num)
    # 释放锁
    lock.release()


# 循环一次给全局变量加1
def sum_num2():
    # 上锁
    lock.acquire()
    for i in range(1000000):
        global g_num
        g_num += 1
    print("sum2:", g_num)
    # 释放锁
    lock.release()


if __name__ == '__main__':
    # 创建两个线程
    first_thread = threading.Thread(target=sum_num1)
    second_thread = threading.Thread(target=sum_num2)
    # 启动线程
    first_thread.start()
    second_thread.start()

    # 提示：加上互斥锁，那个线程抢到这个锁我们决定不了，那线程抢到锁那个线程先执行，没有抢到的线程需要等待
    # 加上互斥锁多任务瞬间变成单任务，性能会下降，也就是说同一时刻只能有一个线程去执行

sum1: 1000000
sum2: 2000000

通过执行结果可以看出互斥锁能够保证多个线程访问共享数据不会出现数据错误问题

死锁

死锁: 一直等待对方释放锁的情景就是死锁
现实社会中，男女双方一直等待对方先道歉的这种行为就好比是死锁。
死锁的结果：
    会造成应用程序的停止响应，不能再处理其它任务了。

示例代码

# 需求:
# 根据下标在列表中取值, 保证同一时刻只能有一个线程去取值
import threading
import time

# 创建互斥锁
lock = threading.Lock()


# 根据下标去取值， 保证同一时刻只能有一个线程去取值
def get_value(index):

    # 上锁
    lock.acquire()
    print(threading.current_thread())
    my_list = [3,6,8,1]
    # 判断下标释放越界
    if index >= len(my_list):
        print("下标越界:", index)
        return
    value = my_list[index]
    print(value)
    time.sleep(0.2)
    # 释放锁
    lock.release()


if __name__ == '__main__':
    # 模拟大量线程去执行取值操作
    for i in range(30):
        sub_thread = threading.Thread(target=get_value, args=(i,))
        sub_thread.start()

避免死锁

在合适的地方释放锁

import threading
import time

# 创建互斥锁
lock = threading.Lock()


# 根据下标去取值， 保证同一时刻只能有一个线程去取值
def get_value(index):
    # 上锁
    lock.acquire()
    print(threading.current_thread())
    my_list = [3, 6, 8, 1]
    if index >= len(my_list):
        print("下标越界:", index)
        # 当下标越界需要释放锁，让后面的线程还可以取值
        lock.release()
        return
    value = my_list[index]
    print(value)
    time.sleep(0.2)
    # 释放锁
    lock.release()


if __name__ == '__main__':
    # 模拟大量线程去执行取值操作
    for i in range(30):
        sub_thread = threading.Thread(target=get_value, args=(i,))
        sub_thread.start()

进程和线程的对比

进程和线程的对比的三个方向
    关系对比
    区别对比
    优缺点对比

关系对比

线程是依附在进程里面的，没有进程就没有线程。
一个进程默认提供一条线程，进程可以创建多个线程。

区别对比

进程之间不共享全局变量
线程之间共享全局变量，但是要注意资源竞争的问题，解决办法: 互斥锁或者线程同步
创建进程的资源开销要比创建线程的资源开销要大
进程是操作系统资源分配的基本单位，线程是CPU调度的基本单位
线程不能够独立执行，必须依存在进程中
多进程开发比单进程多线程开发稳定性要强

优缺点对比

进程优缺点:
    优点：可以用多核
    缺点：资源开销大
线程优缺点:
    优点：资源开销小
    缺点：不能使用多核
搬不完的砖:)
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
Python 中的多进程和多线程
weixin_42902669的博客
12-22 252
Python 中的多进程和多线程 多进程和多线程是实现多任务及提升任务执行效率的两种常用方法。两者都遵循 Master-Worker 模式，Master 负责分配任务，Worker 负责执行任务。具体来说，多进程由一个主进程与多个子进程构成，而多线程由一个主线程与多个子线程构成。两者的一个主要区别在于：多进程的每个进程创建在不同的内存空间中，而多线程创建在一个进程中。 一、 多进程与多线程的优缺点...
python 基础知识梳理——Python中的多进程和多线程
星尘博客_CSDN镜像
01-24 246
python 基础知识梳理——Python中的多进程和多线程 1. 引言 进程是操作系统资源分配的基本单位，而线程是任务调度的基本单位。 一个应用程序至少包括一个进程，而一个进程至少包括一个线程，线程的尺度更小 每个进程在执行过程中都拥有独立的内存单元，而每个进程的多个子线程共享同一个内存单元 2. 多进程 2.1 Python中的多进程与multiprocess模块 Python中的多进程编程主要依靠的是multiprocess模块，现在我们对比两个任务，一个采用多进程，另一个不采用多进程，输出运
Python 中的多线程和多进程 | 长文详解
Warmer_Sweeter
04-06 898
本文深入探讨了 Python 中的多线程和多进程，以及它们如何与并发和并行相关联。介绍多线程和多进程是编程中最基本的两个概念之一。如果你已经编写了一段时间的代码，你应该已经遇到过一些情况，其中你想加快代码中某些部分的特定操作。Python支持各种机制，使各种任务可以（几乎）同时执行。在本教程中，我们将理解多线程和多进程，并看看这些技术如何在Python中实现。我们还将讨论根据应用程序是 I/O-b...
Python 多线程和多进程用法
日常学习与专研的记录
04-19 1290
本文详细介绍Python的多进程以及多线程的用法，并且结合tqdm进度条展示
Python3 - 多进程multiprocessing与多线程multithreading
AI黑板报的专栏
05-27 3540
多进程和多线程编程对于代码的并发执行，提升代码效率和缩短运行时间至关重要，本文带你走进Python多进程和多线程的世界！
python爬虫之多线程、多进程爬虫
02-24
多线程对爬虫的效率提高是非凡的，当我们使用python的多线程有几点是需要我们知道的：1.Python的多线程并不如java的多线程，其差异在于当python解释器开始执行任务时，受制于GIL(全局解释所)，Python的线程被限制到...
Python实现的多进程和多线程功能示例
09-20
在Python编程中，多进程和多线程是两种并发执行任务的重要方式，它们在处理大量数据、提升程序执行效率和构建分布式系统时起到关键作用。本文将深入探讨这两种并发模型，以及如何在Python中实现。 首先，让我们了解...
Python并发：多线程与多进程
02-24
多进程并发提高数字运算在计算机编程领域，并发编程是一个很常见的名词和功能了，其实并发这个理念，最初是源于铁路和电报的早期工作。比如在同一个铁路系统上如何安排多列火车，保证每列火车的运行都不会发生冲突。...
python多线程与多进程及其区别
01-27
本文通过一些具体的例子简单介绍一下python的多线程和多进程，后续会写一些进程通信和线程通信的一些文章。 python中提供两个标准库thread和threading用于对线程的支持，python3中已放弃对前者的支持，后者是一种更...
Python—-多线程—-Thread
12-22
线程: cpu调度执行的最小单位，也叫执行路径，不能独立存在，依赖进程存在，一个进程至少有一个线程，叫主线程，而多个线程共享内存（数据共享，共享全局变量),从而极大地提高了程序的运行效率。 线程的运行是没有...
全网最详细Gradio教程系列5——Gradio Client: python
shao918516的博客
07-26 618
程序部署完成后，如何将Gradio App作为API访问使用呢，这就用到Gradio Client。本章讲解Gradio Client的三种使用方式：python、javascript和curl，受字数限制，所以分三篇博客发布。 使用Gradio Python Client非常易于将Gradio应用程序作为API使用，本节讲述gradio_client安装、如何连接Gradio应用程序、查看可用API及其使用方式、job及session等用法。 通过Gradio Python Cli
随机数种子的作用
帆的博客
07-23 1255
设置随机数种子（random seed）的目的是为了确保随机数生成器在每次运行时产生相同的随机数序列，从而保证实验结果的一致性。随机数种子通过初始化随机数生成器的内部状态，使得在相同的种子值下，随机数生成器每次调用时生成的序列是相同的。
安卓手机部署大模型实战
奇舞周刊
07-25 513
本文作者系360奇舞团前端开发工程师前言自ChatGPT发布以来，大语言模型（Large language model, LLM)就成了AI乃至整个计算机科学的话题中心。学术界，工业界围绕大语言模型本身及其应用展开了广泛的讨论，大量的新的实践层出不穷。由于LLM对计算资源的需求极大，有能力部署大语言模型的公司和实验室一般通过搭建集群，然后开放API或者网页demo的方式让用户可以使用模型。在人们纷...
Java实现拼图小游戏
Aishangyuwen的博客
07-22 1562
Java实现拼图小游戏
【Python】 基于Q-learning 强化学习的贪吃蛇游戏（源码+论文）【独一无二】
最新发布
测试开发自动化
07-26 993
贪吃蛇环境模块：定义了游戏规则、状态空间、动作空间，并实现了环境的重置和步进逻辑。Q-learning 算法代理模块：实现了 Q-learning 算法，用于学习和决策游戏中的动作选择。游戏窗口模块：使用 Tkinter 创建图形界面展示游戏过程，并与环境和 Q-learning 代理进行交互。该设计使得贪吃蛇游戏能够通过强化学习算法进行自动训练，并通过图形界面展示训练过程。👉👉👉 源码获取 关注【测试开发自动化】公众号，回复 “ 强化贪吃蛇 ” 获取，拿来即用。👈👈👈。
第G2周：人脸图像生成（DCGAN）
lihuhelihu的博客
07-23 965
除了生成器模型的输出层和判别器模型的输入层，在整个对抗网络的其它层上都使用了Batch Normalization，原因是Batch Normalization可以稳定学习，有助于优化初始化参数值不良而导致的训练问题。通过这些层的组合，输入的图像逐渐被降维并提取特征，最终输出一个标量值，表示输入图像被判别为真实图像的概率。总体来说，这段代码实现了GAN的训练过程，通过交替更新判别器和生成器的参数，目标是使生成器生成逼真的图像样本，同时判别器能够准确区分真实图像样本和生成图像样本。
【TORCH】matplotlib绘制一条横线的两种方法
Never Give Up
07-22 1007
列表方法) 更灵活，适合于需要详细控制图形的每一部分时使用。它允许你对x和y的每一个对应点进行操作，适用于数据点的绘制或当你需要对绘图过程有更多控制时。直接指定法) 更简洁高效，适合于快速绘制简单形状或当图形的其他部分不需要与这部分精确对应时。选择哪种方法取决于你的具体需求，例如数据的复杂性、图形的其他元素以及代码的可读性和效率。
牛客周赛 Round 52 解题报告 | 珂学家
m0_66102593的博客
07-22 1067
好难的场, 从第二题开始，就感觉画风不对
sklearn基础学习
招风的黑耳CSDN
07-23 729
sklearn，或者更正式地称为scikit-learn，是一个基于Python的开源机器学习库。它建立在NumPy、SciPy和matplotlib之上，提供了简单而有效的工具用于数据挖掘和数据分析。sklearn支持监督学习和无监督学习算法，包括分类、回归、聚类和降维等。
educoderPython--进程和线程
05-29
在Python中，可以使用`multiprocessing`模块来创建多进程，也可以使用`threading`模块来创建多线程。创建进程和线程的方式类似，都是通过创建进程或线程对象来实现。 以下是一个使用`multiprocessing`模块创建进程...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值