Python进阶————进程和线程

最新推荐文章于 2024-09-10 13:01:50 发布
最新推荐文章于 2024-09-10 13:01:50 发布
阅读量749 收藏 10
点赞数 35
分类专栏： Python进阶知识 文章标签： python 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Lyg970112/article/details/141914440
版权

进程和线程

前言

  • 之前所写的程序都是单任务的，也就是说一个函数或者方法执行完成 , 另外一个函数或者方法才能执行 . 要想实现多个任务同时执行就需要使用多任务。

一、多任务

1.1 多任务概述

"""
1、概述:
     多任务指的是 多个任务同时执行.
2、目的:
     节约资源, 充分利用CPU资源, 提高效率.
"""

1.2 多任务的两种表现形式

1.2.1 并发

  • 针对于单核CPU来讲的, 如果有多个任务同时请求执行, 但是同一瞬间CPU只能执行1个(任务), 于是就安排它们交替执行.
  • 因为时间间隔非常短(CPU执行速度太快了), 我们看起来好像是同时执行的, 其实不是.

1.2.2 并行

  • 针对于多核CPU来讲的. 多个任务可以同时执行.

1.3 多任务的优点

  • 多任务执行能够充分利用cpu资源，提高程序执行效率

二、进程

2.1 进程介绍

  • 进程（Process）是CPU资源分配的最小单位，它是操作系统进行资源分配和调度运行的基本单位。
  • 通俗理解：一个正在运行的程序就是一个进程 。 例如:正在运行的qq ，微信等他们都是一个进程

2.2 多进程完成多任务

多进程的实现步骤:
1、导包。
2、创建进程对象, 关联: 要执行的函数。
3、启动进程。

2.2.1 多进程代码演示

代码如下：

import multiprocessing, time

# 需求: 模拟一遍写代码, 一遍听音乐.

# 1. 定义函数, 表示: 写代码.
def coding():
    for i in range(1, 21):
        # 为了让效果更明显, 加入: 休眠线程.
        time.sleep(0.01)
        print(f"正在写代码... {i}", end='\n')


# 2. 定义函数, 表示: 听音乐.
def music():
    for i in range(1, 21):
        # 为了让效果更明显, 加入: 休眠线程.
        time.sleep(0.01)
        print(f"正在听音乐------ {i}")


# 3. 在main函数中测试.
if __name__ == '__main__':
    # 4. 创建两个进程对象, 分别关联上述的两个函数.
    p1 = multiprocessing.Process(target=coding)
    p2 = multiprocessing.Process(target=music)

    # 5. 启动进程.
    p1.start()
    p2.start()

2.2.2 带参数的多进程代码演示

代码如下：

"""
1、进程的参数解释, 即: multiprocessing模块的 Process类的 的参数:
 	   target: 用于关联 进程要执行的任务的.
    	name:   进程名, 默认是: Process-1, Process-2,......Process-n, 可以手动修改, 一般不改.
    	args:   可以通过 元组 的形式传递参数, 实参的个数 及 对应的数据类型 要和 形参的个数及类型 一致.
    	kwargs: 可以通过 字典 的形式传递参数, 实参的个数 要和 形参的个数 一致.

2、进程传参的两种方式是什么？
		a.元组方式传参 ：元组方式传参一定要和任务函数的参数顺序保持一致。
		
		b.字典方式传参：字典方式传参字典中的key一定要和任务函数的参数保持一致

"""
import multiprocessing, time


# 需求: 使用多进程来模拟小明一边写num行代码, 一边听count首音乐.
# 1. 小明写num行代码
def code(name, num):
    for i in range(1, num):
        # 为了让效果更明显, 加入: 休眠线程.
        time.sleep(0.01)
        print(f"{name} 正在写第 {i} 行代码... ")


# 2. 小明听count首音乐
def music(name, count):
    for i in range(1, count):
        # 为了让效果更明显, 加入: 休眠线程.
        time.sleep(0.01)
        print(f"{name} 正在听第 {i} 首音乐------ ")


# 3. 在main函数中编写测试代码.
if __name__ == '__main__':
    # 6. 看看我在不同的地方, 有什么结果.
    for i in range(200):
        time.sleep(0.01)
        print(f'看看我在什么地方---{i}')

    # 4. 创建进程对象.
    p1 = multiprocessing.Process(target=code, args=("小明", 20), name='QQ进程')
    # print(f'p1进程的名字: {p1.name}')
    p2 = multiprocessing.Process(target=music, kwargs={'count': 20, 'name': '小明'}, name='微信进程')
    # print(f'p2进程的名字: {p2.name}')

    # 5. 启动进程.
    p1.start()
    p2.start()

    # # 6. 看看我在不同的地方, 有什么结果.
    # for i in range(200):
    #     time.sleep(0.01)
    #     print(f'看看我在什么地方---{i}')

2.3 获取进程编号

"""
1、概述:
      在操作系统中, 每个进程都有自己唯一的ID, 且当前进程被终止时, 该ID会被回收, 即: ID是可以重复使用的.
2、目的:
      1. 查找子进程是由那个父进程创建的, 即: 找子进程和父进程的ID.
      2. 方便我们维护进程, 例如: kill -9 pid值 可以强制杀死进程.
3、获取进程id的方式:
      获取当前进程的ID:
           方式1: os模块的 getpid()方法
           方式2: multiprocessing模块的 pid属性
      获取当前进程的父进程的pid:
           os模块的 getppid()方法   parent process: 父进程
"""

代码如下（示例）：

# 案例: 实现一边敲着第n行代码, 一边听着第n首音乐.
# 1. 定义函数, 表示: 敲代码.
def code(name, num):
    for i in range(1, num + 1):
        print(f'{name} 正在敲第 {i} 行代码...')
        time.sleep(0.1)
        # multiprocessing模块的current_process()函数: 获取当前进程对象
        print(f'当前进程(p1)的id: {os.getpid()}, {multiprocessing.current_process().pid}, 父进程的id为: {os.getppid()}')


# 2. 定义函数, 表示: 听音乐
def music(name, count):
    for i in range(1, count + 1):
        print(f'{name} 正在听第 {i} 首音乐.........')
        time.sleep(0.1)
        print(f'当前进程(p2)的id: {os.getpid()}, {multiprocessing.current_process().pid}, 父进程的id为: {os.getppid()}')


# 在main中测试.
if __name__ == '__main__':
    # 3. 创建进程对象.
    # Process类的参数: target: 关联的函数名, name: 当前进程的名字, args:元组的形式传参. kwargs: 字典的形式传参.
    p1 = multiprocessing.Process(name='Process_QQ', target=code, args=('张三', 10))
    p2 = multiprocessing.Process(name='Process_Wechat', target=music, kwargs={'count': 10, 'name': '李四'})

    # print(f"p1进程的名字: {p1.name}")
    # print(f"p2进程的名字: {p2.name}")

    # 4. 启动进程.
    p1.start()
    p2.start()

    print(f'当前进程(main)的id: {os.getpid()}, {multiprocessing.current_process().pid}, 父进程的id为: {os.getppid()}')

2.4 进程需要注意的点

2.4.1 进程间的数据是相互隔离的

解释

"""
大白话解释:
    1. 微信 和 QQ都是进程, 它们之间的数据都是 相互隔离的. 即: 微信不能直接访问QQ的数据, QQ也不能直接访问微信的数据.
    2. 下述代码你会发现, 多个子进程相当于把 父进程的资源全部拷贝了一份(注意: main外资源), 即: 子进程相当于父进程的副本.

需求: 定义全局变量 my_list = [], 搞两个进程, 分别实现往里边添加数据, 从里边读取数据, 并观察结果.
"""

代码如下（示例）：

# 案例: 演示进程之间 数据是相互隔离的.

# 导包
import multiprocessing, time

# 1. 定义全局变量.
my_list = []

# 2. 定义函数 write_data(), 往: 列表中 添加数据.
def write_data():
    # 为了让效果更明显, 我们添加多个值.
    for i in range(1, 6):
        my_list.append(i)       # 具体添加元素到列表的动作.
        print(f'add: {i}')      # 打印添加细节(过程)
    print(f'write_data函数: {my_list}')       # 添加完毕后, 打印列表结果


# 3. 定义函数 read_data(), 从: 列表中 读取数据.
def read_data():
    # 休眠一会儿, 确保 write_data()函数执行完毕.
    time.sleep(3)
    print(f'read_data函数: {my_list}')       # 打印列表结果


# 4. 在main中测试
if __name__ == '__main__':
    # 4.1 创建两个进程对象.
    p1 = multiprocessing.Process(target=write_data)     # 进程1, 例如: QQ
    p2 = multiprocessing.Process(target=read_data)      # 进程2, 例如: 微信

    # 4.2 开启进程.
    p1.start()
    p2.start()

    # print('看看我打印了几遍? ')   # main函数内的内容, 只执行一次.

	print('看看我打印了几遍? ')   # main外资源, 自身要执行一次,  p1进程拷贝1遍,  p2进程拷贝1遍 = 3次

2.4.2 主进程会等待子进程执行结束(默认的)

解释

"""
案例:
    演示 默认情况下, 主进程会等待子进程执行结束在结束.

需求:
    创建1个子进程, 子进程执行完需要3秒钟, 让主进程1秒就结束, 观察: 整个程序是立即结束, 还是会等待子进程结束再结束.

结论:
    1. 默认情况下, 主进程会等待所有子进程执行结束再结束.
    2. 问: 如何实现, 当主进程结束的时候, 子进程也立即结束呢?
        方式1: 设置子进程为守护进程.   类似于: 公主 和 守护骑士.
        方式2: 手动关闭子进程.
"""

代码演示主进程关闭 ，但是在会等待子进程执行完毕

# 导包
import multiprocessing, time


# 1. 定义函数work(), 要被: 子进程关联.
def work():
    for i in range(10):
        print(f'工作中... {i}')
        time.sleep(0.3)     # 总计休眠时间: 0.3 * 10 = 3秒


# 2. 在main函数中测试.
if __name__ == '__main__':
    # 3. 创建子进程.
    p1 = multiprocessing.Process(target=work)
    # 4. 开启子进程.
    p1.start()

    # 5. 让主进程(main进程)休眠1秒.
    time.sleep(1)
    # 6. 主进程结束, 打印提示语句.
    print('主进程执行结束了!')

2.4.2 修改 主进程关闭 子进程也跟着立刻关闭

解释

"""
案例:
    演示 默认情况下, 主进程会等待子进程执行结束在结束.

需求:
    创建1个子进程, 子进程执行完需要3秒钟, 让主进程1秒就结束, 观察: 整个程序是立即结束, 还是会等待子进程结束再结束.

结论:
    1. 默认情况下, 主进程会等待所有子进程执行结束再结束.
    2. 问: 如何实现, 当主进程结束的时候, 子进程也立即结束呢?
        方式1: 设置子进程为守护进程.   类似于: 公主 和 守护骑士.
        方式2: 手动关闭子进程.

细节:
    1. 当非守护进程结束的时候, 它的所有守护进程都会立即终止, 且释放资源.
    2. 如果是 terminate()方式, 子进程主动结束自己, 则会变成僵尸进程, 不会立即释放资源.

"""

代码演示 主进程结束 子进程也立刻结束


# 导包
import multiprocessing, time


# 1. 定义函数work(), 要被: 子进程关联.
def work():
    for i in range(10):
        print(f'工作中... {i}')
        time.sleep(0.3)     # 总计休眠时间: 0.3 * 10 = 3秒


# 2. 在main函数中测试.
if __name__ == '__main__':
    # 3. 创建子进程.
    p1 = multiprocessing.Process(target=work)

    # 核心细节: 设置p1为守护线程, 因为p1的父进程是main, 所以p1是main的守护进程.
    # p1.daemon = True

    # 4. 开启子进程.
    p1.start()

    # 5. 让主进程(main进程)休眠1秒.
    time.sleep(1)

    # 方式2: 在主进程执行结束前, 子进程主动自己关闭自己.
    p1.terminate()  # 不推荐用, 会变成僵尸进程, 不会主动释放资源, 过段时间会交由(init进程, 充当父进程),来释放资源.

    # 6. 主进程结束, 打印提示语句.
    print('主进程执行结束了!')

三、线程

3.1 线程介绍

"""
1、线程:
       CPU调度资源的最小单位, 即: 进程的执行单元, 执行路径.
       可以理解为: 车道
2、多进程:
       多个*.exe, 例如: 微信.exe, QQ.exe, 即: 不同的软件.
       
3、多线程:
       同一个进程, 有多条执行路径, 例如: 微信.exe -> 查看钱包, 和张三聊天, 和李四聊天, 查看照片...
"""

代码演示 用多线程思路, 实现: 一边写代码, 一边听音乐.

# 导包
import threading, time

# 1. 定义函数coding(), 表示: 敲代码
def coding():
    for i in range(10):
        print(f'正在敲第 {i} 遍代码! -------')
        time.sleep(0.1)

# 2. 定义函数music(), 表示: 听音乐.
def music():
    for i in range(10):
        print(f'正在听第 {i} 首音乐!')
        time.sleep(0.1)

# 3. 在main中测试.
if __name__ == '__main__':
    # 4. 创建两个线程对象.
    t1 = threading.Thread(target=coding)
    t2 = threading.Thread(target=music)

    # 5. 开启线程.
    t1.start()
    t2.start()

3.2 多线程带参数

代码演示 用多线程思路, 实现: 一边写代码, 一边听音乐.(带参数版)

# 导包
import threading, time

# 1. 定义函数coding(), 表示: 敲代码
def coding(name, num):
    for i in range(num):
        print(f'{name} 正在敲第 {i} 遍代码! -------')
        time.sleep(0.1)

# 2. 定义函数music(), 表示: 听音乐.
def music(name, count):
    for i in range(count):
        print(f'{name} 正在听第 {i} 首音乐!', end='\n')
        time.sleep(0.1)

# 3. 在main中测试.
if __name__ == '__main__':
    # 4. 创建两个线程对象.
    # Thread()类中的参数如下:
    #   target      关联要执行的目标函数对象.
    #   name        设置线程名
    #   args        以元组形式传参, 个数, 顺序都要保持一致.
    #  kwargs       以字典形式传参, 个数, 参数名(键名和形参名)保持一致.
    t1 = threading.Thread(target=coding , args = ('张三', 9))
    t2 = threading.Thread(target=music, kwargs={'name': '李四', 'count': 10})

    # 5. 开启线程.
    t1.start()
    t2.start()

3.3 多线程注意的点

3.3.1 多线程执行顺序

解释

"""
结论：
    1. 多线程的执行具有 随机性, 因为: 线程是由CPU调度的.
    2. 调度资源常用的两种方式:
        抢占式调度: 谁抢到资源, 谁执行.
            Python, Java用的都是这种思路.
        均分时间片: 每个任务获取CPU的时间都是固定的.
"""

代码演示多线程代码 的执行顺序.

# 导包
import threading
import time


# 1. 定义函数get_info(), 用来打印: 线程信息, 看看当前是哪个线程在执行.
def get_info():
    # 休眠一会儿, 让效果更明显.
    time.sleep(0.1)

    # 1.1 获取当前的线程对象.
    ct = threading.current_thread()

    # 1.2 打印当前线程对象即可.
    print(f'当前的线程对象是: {ct}')


# 2. 在main中测试.
if __name__ == '__main__':
    # 3. 为了让效果更明显, 创建多个线程.
    # t1 = threading.Thread(target=get_info)
    # t2 = threading.Thread(target=get_info)
    #
    # t1.start()
    # t2.start()

    for i in range(10):
        t1 = threading.Thread(target=get_info)
        t1.start()

3.3.2 多线程-等待子线程结束再结束

解释

"""
结论:
    1. 默认情况下, 主线程会等待所有子线程执行结束再结束.
    2. 问: 如何实现, 当主线程结束的时候, 子线程也立即结束呢?
        设置子线程为守护线程.   类似于: 公主 和 守护骑士.

"""

代码 演示 默认情况下, 主线程会等待子线程执行结束在结束.

"""
需求:
    创建1个子线程, 子线程执行完需要3秒钟, 让主线程1秒就结束, 观察: 整个程序是立即结束, 还是会等待子线程结束再结束.
"""
# 导包
import threading, time


# 1. 定义函数work(), 要被: 子线程关联.
def work():
    for i in range(10):
        print(f'工作中... {i}')
        time.sleep(0.3)     # 总计休眠时间: 0.3 * 10 = 3秒


# 2. 在main函数中测试.
if __name__ == '__main__':
    # 3. 创建子线程.
    t1 = threading.Thread(target=work)
    # 4. 开启子线程.
    t1.start()

    # 5. 让主线程(main线程)休眠1秒.
    time.sleep(1)
    # 6. 主线程结束, 打印提示语句.
    print('主线程执行结束了!')

3.3.3 多线程-守护线程

代码演示 当非守护线程结束的时候, 和它关联的守护线程, 也会立即结束, 释放资源.

# 导包
import threading, time


# 1. 定义函数work(), 要被: 子线程关联.
def work():
    for i in range(10):
        print(f'工作中... {i}')
        time.sleep(0.3)  # 总计休眠时间: 0.3 * 10 = 3秒


# 2. 在main函数中测试.
if __name__ == '__main__':
    # 3. 创建子线程.
    # 守护线程, 格式1: 创建线程对象的时候, 直接指定.
    # t1 = threading.Thread(target=work, daemon=True)

    t1 = threading.Thread(target=work)
    # 守护线程, 格式2: 创建线程对象后, 通过 daemon属性设置.
    # t1.daemon = True

    # 守护线程, 格式3: 创建线程对象后, 通过 setDaemon()函数设置.
    t1.setDaemon(True)      # 类似于以前我们学的: get_name(), set_name()

    # 4. 开启子线程.
    t1.start()

    # 5. 让主线程(main线程)休眠1秒.
    time.sleep(1)

    # 6. 主线程结束, 打印提示语句.
    print('主线程执行结束了!')

3.3.4 多线程共享全局变量

解释

"""
结论:
    1. 进程之间, 数据相互隔离.        进程 = 软件.
    2. 线程之间, 数据共享.
"""

代码演示 同一进程的多个线程, 可以共享 该进程的资源.

# 导包
import threading, time

# 1. 定义全局变量.
my_list = []


# 2. 定义函数write_data(), 实现: 往列表中添加数据.
def write_data():
    # 为了效果更明显, 我们添加多个元素.
    for i in range(1, 6):
        # time.sleep(0.1)
        # 往列表中添加元素.
        my_list.append(i)
        # 打印添加的细节
        print(f'add: {i}')

    # 添加之后, 打印结果.
    print(f'write_data函数: {my_list}')


# 3. 定义函数read_data(), 实现: 从列表中读取数据.
def read_data():
    time.sleep(2)     # 为了效果更好看, 加入休眠线程.
    print(f'read_data函数: {my_list}')


# 4. main函数中进行测试.
if __name__ == '__main__':
    # 4.1 创建两个线程对象, 分别关联: write_data(), read_data()函数.
    t1 = threading.Thread(target=write_data)
    t2 = threading.Thread(target=read_data)

    # 4.2 启动线程.
    t1.start()
    t2.start()

3.3.5 数据安全

解释

"""
案例:  线程可以共享全局变量, 同时操作, 可能会出现: 安全问题.

1、遇到的问题:
      两个线程同时操作共享变量, 进行累加操作, 出现: 累计次数"不够"的情况, 我们要的效果是:  get_sum1: 100W,  get_sum2:200W, 但是结果不是.
2、产生原因:
      正常情况:
         假设g_num = 0
            第1次循环:  t1线程抢到资源, 对其累加1, 操作后 g_num = 1, t1线程本次操作完毕.
            第2次循环: 假设t2线程抢到了资源, 此时 g_num = 1, 操作之后(累加1), g_num = 2, t2线程本次操作完毕.
        这个是正常情况.

      非正常情况:
          1. 假设 g_num = 0
          2. 假设 t1 线程抢到了资源, 在还没有来得及对 g_num(全局变量)做 累加操作的时候, 被t2线程抢走了资源.
          3. t2线程也会去读取 g_num(全局变量)的值, 此时 g_num = 0
          4. 之后t1 和 t2线程分别开始了 累加操作:
              t1线程, 累加之后,   g_num = 0     ->    g_num = 1
              t2线程, 累加之后,   g_num = 0     ->    g_num = 1
          5. 上述一共累加了 2次, 但是 g_num的值最终只 累加了 1.
"""

代码如下（示例）：

import threading

# 需求: 定义两个函数, 分别对全局变量累加100W次, 并打印观察程序的最终运行结果.

# 1. 定义全局变量.
g_num = 0

# 2. 定义函数 get_sum1(), 实现对全局变量累加 100W次
def get_sum1():
    for i in range(1000000):
        global g_num
        g_num += 1      # 全局变量 + 1
    # 程序计算完毕后, 打印结果.
    print(f'get_sum1函数计算结果: {g_num}')       # 100W

# 3. 定义函数 get_sum2(), 实现对全局变量累加 100W次
def get_sum2():
    for i in range(1000000):
        global g_num
        g_num += 1      # 全局变量 + 1
    # 程序计算完毕后, 打印结果.
    print(f'get_sum2函数计算结果: {g_num}')       # 200W

# 4. 测试
if __name__ == '__main__':
    # 4.1 创建两个线程对象, 分别关联: 两个函数.
    t1 = threading.Thread(target=get_sum1)
    t2 = threading.Thread(target=get_sum2)

    # 4.2 启动线程.
    t1.start()
    t2.start()

3.4 互斥锁的使用

解释

"""
为了解决上述 数据安全出现的问题，我们采用的解决方案:

    		采用 线程同步 解决.

线程同步解释:
      1、概述:
           线程同步, 也叫线程安全, 它是用来解决 多线程操作共享变量, 可能出现非法值的问题的.
      2、解决思路:
            加锁.
      3、步骤:
          1). 创建锁.
          2). 加锁.
          3). 释放锁.
细节:
      1. 必须使用同一把锁, 否则可能出现锁不住的情况.
      2. 选择合适的时机要释放锁, 否则可能出现死锁的情况.


"""

代码如下（示例）：

import threading

# 需求: 定义两个函数, 分别对全局变量累加100W次, 并打印观察程序的最终运行结果.

# 1. 定义全局变量.
g_num = 0

# 核心细节, 创建: 锁(互斥锁)
mutex = threading.Lock()        # mutex是变量名, 符合规范即可. mutex单词 是 互斥的意思.
# mutex2 = threading.Lock()        # mutex是变量名, 符合规范即可. mutex单词 是 互斥的意思.

# 2. 定义函数 get_sum1(), 实现对全局变量累加 100W次
def get_sum1():

    # 加锁
    mutex.acquire()
    for i in range(1000000):
        global g_num
        g_num += 1      # 全局变量 + 1
    # 程序计算完毕后, 打印结果.
    # 解锁
    mutex.release()
    print(f'get_sum1函数计算结果: {g_num}')       # 100W

# 3. 定义函数 get_sum2(), 实现对全局变量累加 100W次
def get_sum2():
    # 加锁
    mutex.acquire()
    for i in range(1000000):
        global g_num
        g_num += 1      # 全局变量 + 1
    # 程序计算完毕后, 打印结果.
    # 解锁
    mutex.release()
    print(f'get_sum2函数计算结果: {g_num}')       # 200W

# 4. 测试
if __name__ == '__main__':
    # 4.1 创建两个线程对象, 分别关联: 两个函数.
    t1 = threading.Thread(target=get_sum1)
    t2 = threading.Thread(target=get_sum2)

    # 4.2 启动线程.
    t1.start()
    t2.start()

四、进程和线程的对比

4.1 关系对比

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

4.2 区别对比

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

4.3 优缺点对比

进程优缺点:
——优点：可以用多核
——缺点：资源开销大
线程优缺点:
——优点：资源开销小
——缺点：不能使用多核

总结

  • 我们将多进程跟多线程放在一起对比学习，能够更清楚的发现进程跟线程的相似点与不同点。
记得多吃点
关注
  • 35
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Python进阶——多进程多线程
欢迎来到我的知识星球！！！
08-13 664
前言 学习Python多进程多线程前，大家先要了解什么是线程，什么是进程、共享内存、锁等相关知识点，方便理解后续的内容。 进程和线程的区别 进程是系统进行资源分配和调度的一个独立单位，最小的资源管理单位。线程是进程的一个实体， 是 CPU 调度和分派的基本单位，它是比进程更小的能独立运行的基本单位，最小的 CPU 执行单元。线程拥有的资源：程序计数器、 寄存器、 栈 、状态字。...
python进阶——进程/线程/协程
adiaoxia8541的博客
01-15 237
1 python线程 python中Threading模块用于提供线程相关的操作，线程是应用程序中执行的最小单元。 1 #!/usr/bin/env python 2 # -*- coding:utf-8 -*- 3 4 import threading 5 import time 6 7 def show(arg): 8 t...
python多进程控制,python进阶——多进程
weixin_30910893的博客
03-26 475
因为GIL(全局解释器锁)的限制(GIL是用来保证在任意时刻只能有一个控制线程在执行)，所以python中的多线程并非真正的多线程。只有python程序是I/O密集型应用时，多线程才会对运行效率有显著提高(因在等待I/O的时，会释放GIL允许其他线程继续执行)，而在计算密集型应用中，多线程并没有什么用处。考虑到要充分利用多核CPU的资源，允许python可以并行处理一些任务，这里就用到了pytho...
python进阶6——线程和同步
weixin_45889256的博客
09-18 105
同步就是在发出一个调用后，如果没有得到结果，调用就不返回。调用返回，就一定得到返回值。换句话说，就是由调用者主动等待这个调用的结果。
Python进阶——线程的理解
可爱程序员
03-06 289
一、线程的调度机制 1、图解线程调度机制 注：1秒=1000毫秒，不同的线程不是同时运行的，只是因为其运行速度较快，让我们有一种它们在同时运行的错觉。 2、实例 因为线程是一个Python程序里面的子单元，它们是可以共享变量作用域的。 线程只是独立的执行单元，因此作用域是可以共享的 就算是100个线程，它也是跑在一个程序里 import threading a = 1 # 主线程 def...
python进阶——多进程
countofdane的博客
10-27 309
因为GIL（全局解释器锁）的限制（GIL是用来保证在任意时刻只能有一个控制线程在执行），所以python中的多线程并非真正的多线程。只有python程序是I/O密集型应用时，多线程才会对运行效率有显著提高（因在等待I/O的时，会释放GIL允许其他线程继续执行），而在计算密集型应用中，多线程并没有什么用处。考虑到要充分利用多核CPU的资源，允许python可以并行处理一些任务，这里就用到了pytho
Python入门自学进阶——10-线程进程
kaoa000的专栏——非淡泊无以明志，非宁静无以致远
11-26 597
线程是操作系统能够进行运算调度的最小单位，包含在进程之中，是进程中的实际运作单位。一条线程指的是进程中一个单一顺序的控制流，一个进程中可以并发多个线程，每条线程并行执行不同的任务。 进程是一个资源的集合集 进程 　　计算机的核心是CPU，它承担了所有的计算任务，而操作系统是计算机的管理者，它负责任务的调度，资源的分配和管理，统领整个计算机硬件；应用程序是具有某种功能的程序，程序是运行于操作系统之上的。 　　进程是一个具有一定独立功能的程序在一个数据集上的一次动态执行的过程，是操作系统进行资源分配和调
Python进阶教学——多线程高级应用
计算机硕士的博客
09-15 537
线程间的通讯机制：Queue消息队列、Event事件对象、Condition条件对象；线程中的消息隔离机制；线程同步信号量semaphore；线程池和进程池。
Python进阶——多线程，网络编程，正则表达式，递归（阶段八）
泰勒今天想展开的博客
03-28 193
Python中的多线程，网络编程：Socket实现服务端和客户端链接
Python进阶必备——HiKari为了拿捏Python整理的技术笔记
10-05
第二章“并发机制”深入探讨了Python在多线程、多进程以及异步I/O方面的处理： 1. **多线程与GIL（全局解释器锁）**：Python的多线程在CPython实现中受到GIL限制，无法实现真正的并行计算。理解GIL的存在可以帮助...
Python学习 Day53 爬虫进阶——进程线程 01
ShengXIABai的博客
05-14 1620
进程与线程 一、进程与线程概述 程序 程序（Program）是计算机指令的集合，用于实现特定功能 进程 1.启动后的程序称为进程，系统会为进程分配内存空间 2.一个进程中至少包含一个线程 线程 1.CPU调度执行的基本单元 2.一个进程中包含多个线程 3.进程结束，线程一定结束，线程结束，进程不一定结束 4.同一个进程中的多个线程，共享内存地址 二、进程与线程的区别 区别 进程 线程 根本区别 资源分配的单位 调度和执行的单位 开销 每个进程都有独立的代码和数据控价（寄存
Python进阶丨进程和线程 —— 进程 vs 线程
m0_45198298的博客
01-06 221
进程 vs 线程 - 描述 要实现多任务，通常会设计Master-Worker模式，Master负责分配任务，Worker负责执行任务。 多环境任务下，通常是一个Master，多个Worker 多进程最大的优点就是稳定性高，因为一个子进程崩溃了，不会影响主进程和其他子进程。缺点是创建进程的代价大，在Windows下创建进程开销巨大。 多线程模式通常比多进程快一点，但是也快不到哪去，而且多线程模式致...
Python进阶学习笔记之——多线程编程
前尘忆梦的博客
08-21 459
多线程编程 1、Python 的多线程支持模块简介 Python 提供了多个模块来支持多线程编程，包括 thread、threading 和 Queue 模块等。程序是可以使用 thread 和 threading 模块来创建与管理线程。thread 模块提供了基本的线程和锁定支持；而 threading 模块提供了更高级别、功能更全面的线程管理。使用 Queue 模块，用户可以创建一支队列数据结构，用于在多线程之间进行共享。 核心提示：避免使用 thread 模块 推荐使用更高级别的 threadin
【python】—— Python爬虫实战：爬取珠海市2011-2023年天气数据并保存为CSV文件
weixin_63106307的博客
09-05 949
本文将介绍如何使用Python编写一个简单的爬虫程序，以爬取珠海市2011年至2023年的天气数据，并将这些数据保存为CSV文件。
[Python]生成器和yield关键字
weixin_57336987的博客
09-07 356
概述:​ 它指的是 generator, 类似于以前学过的: 列表推导式, 集合推导式, 字典推导式…作用:​ 降低资源消耗, 快速(批量)生成数据.实现方式:​ 1.推导式写法.​ 2.yield写法.yield i # yield会记录每个生成的数据, 然后逐个的放到生成器对象中, 最终返回生成器对象.问题: 如何从生成器对象中获取数据?​ 答案:​ 1.for循环遍历​ 2.next()函数, 逐个获取.
基于人工智能的音乐情感分类系统
stm32d1219的博客
09-06 826
音乐作为一种强烈的情感表达方式，不同的音调、节奏和和声传递着不同的情感信息。通过人工智能技术，能够自动识别音乐中的情感，为用户提供个性化的音乐推荐或情感分析服务。通过使用MFCC特征提取与神经网络分类算法，音乐情感分类系统可以有效地分析音乐中的情感信息，并根据不同情感对音乐进行分类。随着深度学习技术的进一步发展，音乐情感分类系统的准确性和应用范围将得到进一步提升。音乐情感分类是通过对音乐音频信号进行分析，识别出音乐传递的情感，如“愉快”、“悲伤”、“愤怒”等。问题讨论，人工智能的资料领取可以私信！
数模原理精解【8】
最新发布
基础数学与物理学
09-10 703
假设有一个nnn维随机向量XX1X2XnTXX1​X2​Xn​T，它服从均值为μμ1μ2μnTμμ1​μ2​μn​T和协方差矩阵为ΣΣfXx12πn2∣Σ∣12exp⁡−12x−μTΣ−1x−μfX​x2πn/2∣Σ∣1/21​exp−21​x−μTΣ−1x−μxx1x2xnTxx1​x。
访问数组索引时超出边界引发 ArrayIndexOutOfBoundsException
Itmastergo的博客
09-05 1110
在 Java 中，数组是一种数据结构，用于存储固定数量的同类型元素。数组中的元素可以是基本数据类型（如intcharfloat等）或引用类型（如String、自定义类等）。数组是一种线性表数据结构，也就是说，数组中的元素可以通过一个整数索引来访问。数组的索引从0开始，这意味着对于长度为n的数组，合法的索引范围是从0到n-1。// 创建一个长度为 5 的整型数组在上面的例子中，numbers是一个包含 5 个整型元素的数组，索引从0到4。数组的大小在创建时就已经固定，因此无法动态扩展。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值