一篇文章带你入门多进程、多线程

最新推荐文章于 2024-08-03 19:27:22 发布
最新推荐文章于 2024-08-03 19:27:22 发布
阅读量117 收藏 1
点赞数 1
分类专栏： 多线程、多进程、协程 常见问题汇总 文章标签： python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/love_521_/article/details/126640599
版权

多进程完成多任务

# 导入进程模块
import multiprocessing
import time


# 编写代码
def coding():
    for i in range(3):
        print(f"coding...{i}")
        time.sleep(0.2)


# 听音乐
def music():
    for i in range(3):
        print(f"music...{i}")
        time.sleep(0.2)


if __name__ == '__main__':
    # coding()
    # music()
    # 通过进程类创建进程对象
    coding_process = multiprocessing.Process(target=coding)
    # 通过进程类创建进程对象
    music_process = multiprocessing.Process(target=music)
    # 启动进程
    coding_process.start()
    music_process.start()

进程执行带有参数的任务

# 导入进程模块
import multiprocessing
import time


# 编写代码
def coding(num, name):
    for i in range(num):
        print(f"name:{name}00{i+1}")
        print("coding...")
        time.sleep(0.2)


# 听音乐
def music(count):
    for i in range(count):
        print("music...")
        time.sleep(0.2)


if __name__ == '__main__':
    # coding()
    # music()
    # 通过进程类创建进程对象
    coding_process = multiprocessing.Process(target=coding, args=(3, "不当大哥好多年"))
    # 通过进程类创建进程对象
    music_process = multiprocessing.Process(target=music, kwargs={"count": 2})
    # 启动进程
    coding_process.start()
    music_process.start()

获取进程编号

# 导入进程模块
import multiprocessing
import time
import os


# 编写代码
def coding():
    print("coding>>>%d" % os.getpid())
    for i in range(3):
        print("coding>>>%d" % os.getpid())
        print("coding...")
        time.sleep(0.2)


# 听音乐
def music():
    for i in range(3):
        print("music>>>%d" % os.getpid())
        print("music...")
        time.sleep(0.2)


if __name__ == '__main__':
    # coding()
    # music()
    # 通过进程类创建进程对象
    coding_process = multiprocessing.Process(target=coding)
    # 通过进程类创建进程对象
    music_process = multiprocessing.Process(target=music)
    # 启动进程
    coding_process.start()
    music_process.start()

进程间不共享全局变量

import multiprocessing
import time

# 全局变量
my_list = []


# 写入数据
def write_data():
    for i in range(3):
        my_list.append(i)
        print("add:", i)
    print("write_data", my_list)


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


if __name__ == '__main__':
    # 创建写入数据进程
    write_process = multiprocessing.Process(target=write_data)
    # 创建读取数据进程
    read_process = multiprocessing.Process(target=read_data)

    # 启动进程执行相应任务
    write_process.start()
    time.sleep(1)
    read_process.start()```

## 主进程和子进程的结束顺序

```python
import multiprocessing
import time


# 工作函数
def work():
    for i in range(10):
        print("工作中...")
        time.sleep(0.2)


if __name__ == '__main__':
    # 创建子进程
    work_process = multiprocessing.Process(target=work)
    # 启动子进程
    work_process.start()

    # 延时1秒
    time.sleep(1)
    print("主进程执行完毕")

设置守护主进程

import multiprocessing
import time


# 工作函数
def work():
    for i in range(10):
        print(f"工作中...{i}")
        # time.sleep(0.001)


# 工作函数
def work2():
    for i in range(30):
        print(f"work2工作中...{i}")
        time.sleep(0.1)
    print("over")

# 工作函数
def work3():
    for i in range(30):
        print(f"work3工作中...{i}")
        time.sleep(0.2)
    print("over")


if __name__ == '__main__':
    # 创建子进程
    work_process = multiprocessing.Process(target=work)
    work_process2 = multiprocessing.Process(target=work2)
    work_process3 = multiprocessing.Process(target=work3)
    # # 设置守护主进程
    # work_process.daemon = True
    # 启动子进程

    work_process.start()
    work_process2.start()
    work_process3.start()

    # 延时1秒
    # time.sleep(1)
    # 手动结束子进程
    work_process.terminate()
    print("主进程执行完毕")

多线程完成多任务

import time
import threading


# 编写代码
def coding():
    for i in range(3):
        print("coding...")
        time.sleep(0.2)


# 听音乐
def music():
    for i in range(3):
        print("music...")
        time.sleep(0.2)


if __name__ == '__main__':
    # coding()
    # music()
    # 创建子线程
    coding_thread = threading.Thread(target=coding)
    music_thread = threading.Thread(target=music)

    # 启动子线程执行任务
    coding_thread.start()
    music_thread.start()

线程执行带有参数的任务

import time
import threading


# 编写代码
def coding(num):
    for i in range(num):
        print("coding...")
        time.sleep(0.2)


# 听音乐
def music(count):
    for i in range(count):
        print("music...")
        time.sleep(0.2)


if __name__ == '__main__':
    # coding()
    # music()
    # 创建子线程
    coding_thread = threading.Thread(target=coding, args=(3,))
    music_thread = threading.Thread(target=music, kwargs={"count" : 1})

    # 启动子线程执行任务
    coding_thread.start()
    music_thread.start()

主线程和子线程的结束顺序

  
import time
import threading
def work():
    for i in range(10):
        print(f"work...{i}")
        time.sleep(0.2)


if __name__ == '__main__':
    # 创建子线程
    # 方式1 参数方式设置守护主线程
    # work_thread = threading.Thread(target=work, daemon=True)
    work_thread = threading.Thread(target=work)
    # 启动线程
    # 方式2
    work_thread.setDaemon(True)
    work_thread.start()

    # 延时一秒
    time.sleep(1)
    print("主线程执行完毕")

线程间执行顺序

 import threading
import time


# 获取线程信息函数
def get_info():
    time.sleep(0.5)
    # 获取线程信息
    current_thread = threading.current_thread()
    print(current_thread)


if __name__ == '__main__':
    # 创建子线程
    for i in range(10):
        sub_thread = threading.Thread(target=get_info)
        sub_thread.start()

线程间共享全局变量

 import threading
import time


# 全局变量
my_list = []


# 写入数据
def write_data():
    for i in range(3):
        print("add:", i)
        my_list.append(i)
    print("write:", my_list)


# 读取数据
def read_data():
    print("read:", 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)
    read_thread.start()

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

 import threading


# 全局变量
g_num = 0


# 对g_num进行加操作
def sum_num1():
    for i in range(1000000):
        global g_num
        g_num += 1

    print("g_num1:", g_num)


# 对g_num进行加操作
def sum_num2():
    for i in range(1000000):
        global g_num
        g_num += 1

    print("g_num2:", g_num)


if __name__ == '__main__':
    # 创建子线程
    sum1_thread = threading.Thread(target=sum_num1)
    sum2_thread = threading.Thread(target=sum_num2)

    # 启动线程
    sum1_thread.start()
    sum2_thread.start()

互斥锁

 import threading


# 全局变量
g_num = 0


# 对g_num进行加操作
def sum_num1():
    # 上锁
    mutex.acquire()

    for i in range(1000000):
        global g_num
        g_num += 1

    # 解锁
    mutex.release()

    print("g_num1:", g_num)


# 对g_num进行加操作
def sum_num2():
    # 上锁
    mutex.acquire()

    for i in range(1000000):
        global g_num
        g_num += 1

    # 解锁
    mutex.release()

    print("g_num2:", g_num)


if __name__ == '__main__':
    # 创建锁
    mutex = threading.Lock()
    # 创建子线程
    sum1_thread = threading.Thread(target=sum_num1)
    sum2_thread = threading.Thread(target=sum_num2)

    # 启动线程
    sum1_thread.start()
    sum2_thread.start()

死锁

import threading


# 全局变量
g_num = 0


# 对g_num进行加操作
def sum_num1():
    # 上锁
    print("sun_num1...")
    mutex.acquire()

    for i in range(1000000):
        global g_num
        g_num += 1
    # mutex.release()
    print("g_num1:", g_num)


# 对g_num进行加操作
def sum_num2():
    # 上锁
    print("sun_num2...")
    mutex.acquire()

    for i in range(1000000):
        global g_num
        g_num += 1
    # mutex.release()
    print("g_num2:", g_num)


if __name__ == '__main__':
    # 创建锁
    mutex = threading.Lock()
    # 创建子线程
    sum1_thread = threading.Thread(target=sum_num1)
    sum2_thread = threading.Thread(target=sum_num2)

    # 启动线程
    sum1_thread.start()
    sum2_thread.start()

多线程之join

 import time
from multiprocessing import Process


def task():
    for i in range(10):
        time.sleep(1)
        print(f'子 run--{i}')


if __name__ == '__main__':
    p = Process(target=task)
    p.start()  # 向操作系统发送指令
    p.join()  # 让主进程等待子进程执行完毕再继续向下执行
    time.sleep(3)
    print('over')
love_521_
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
认识多进程，多线程
m0_47792921的博客
08-11 181
在了解多进程，多线程前我们先来了解一下CPU时间片。 CPU时间片 实现程序间的切换 早期使用的电脑大多都是单核系统，就比如现在的Ubuntu，python等都是单核系统。在Linux系统中时间片切换程序的时间为5毫秒到800毫秒，1秒等于1000毫秒当时间很小时我们人眼是几乎感觉不到的。 并发是什么 在同一个时间点内只能有一个程序在运行。 在以前可能大家可以同时玩游戏，同时使用YY语音，在人体感受上来看这些程序是同时运行的，其实单核系统中不存在同时运行都是通过CPU时间片切换实现的。 优先度 其中还有个
多线程多进程
夜飞霜的博客
08-04 183
基本概念： 进程：执行程序的一次执行过程，是系统进行资源分配和调度的基本单位，其中，程序是指令和数据的有序集合 线程：CPU调度和执行的单元，最小的处理单元 进程和线程之间的关系： 一个进程可以有多个线程 资源分配给进程，同一进程的所有线程共享进程的所有资源 CPU运行的是线程 并发和并行： 并行：同一时刻，多个任务同时执行 并发：执行多个任务，能顺利的来回切换。并发包含并行 多核CPU能够支持多线程并行执行，单核CPU只能支持多线程的并发执行
详解Python进程与线程
黑马程序员官方博客
01-13 2829
另外，线程是进程中的一个实体，是被系统独立调度和分派的基本单位，线程自己不拥有系统资源，只拥有一点儿在运行中必不可少的资源，但它可与同属一个进程的其它线程共享进程所拥有的全部资源。CPU的时间片轮转，在不同的时间段切换执行不同的进程，但是切换进程是比较耗时的；就引来了轻量级进程，也就是所谓的线程，一个进程中包括多个线程（代码流，其实也就是进程中同时跑的多个方法体）当一个程序启动时，就有一个进程被操作系统（OS）创建，与此同时一个线程也立刻运行，该线程通常叫做程序的主线程。
深入理解Python中的进程与线程
weixin_45841831的博客
05-04 1054
今天我们使用的计算机早已进入多CPU或多核时代，而我们使用的操作系统都是支持“多任务”的操作系统，这使得我们可以同时运行多个程序，也可以将一个程序分解为若干个相对独立的子任务，让多个子任务并发的执行，从而缩短程序的执行时间，同时也让用户获得更好的体验。因此在当下不管是用什么编程语言进行开发，实现让程序同时执行多个任务也就是常说的“并发编程”，应该是程序员必备技能之一。为此，我们需要先讨论两个概念，一个叫进程，一个叫线程。
python-进程和线程
jjliu的博客
12-08 874
进程： 一个程序的执行实例就是一个进程，表现为程序是源代码编译后的文件，而这些文件存放在磁盘上。当程序被操作系统加载到内存中，就是进程。 进程中存放着指令和数据(资源)，它也是线程的容器。 进程( Process)是计算机中的程序关于某数据集合上的一次运行活动，是系统进行资源分配和调度的基本单位，是操作系统结构的基础。 Linux进程有父进程、子进程，Windows的进程是平等关系 线程： 线程是操作系统能够进行运算调度的最小单位。它被包含在进程之中，是进程中的实际运行单位。 线程，有时被称为轻量级进程
python的进程、线程详解
qq_42746084的博客
12-22 928
python世界中的进程和线程理解
Python基础入门自学——14--进程和线程
kaoa000的专栏——非淡泊无以明志，非宁静无以致远
06-30 1283
对于操作系统来说，一个任务就是一个进程（Process），比如打开一个浏览器就是启动一个浏览器进程，打开一个记事本就启动了一个记事本进程，打开两个记事本就启动了两个记事本进程，打开一个Word就启动了一个Word进程。 有些进程还不止同时干一件事，比如Word，它可以同时进行打字、拼写检查、打印等事情。在一个进程内部，要同时干多件事，就需要同时运行多个“子任务”，我们把进程内的这些“子任务”称为线程（Thread）。 由于每个进程至少要干一件事，所以，一个进程至少有一个线程。当然，像Word这种复杂的进
多线程编程的入门指导.zip
06-19
在计算机科学中，多线程编程是一种允许程序同时执行多个任务或子任务的技术。它能够提升应用程序的效率和响应性，特别是在多核处理器系统中。本篇将详细讲解多线程编程的基础概念、应用场景以及如何在不同的编程语言...
Linux多线程编程快速入门
09-15
这篇快速入门教程涵盖了多线程编程的基础，包括线程的基本概念、线程标识、线程创建以及线程的管理。 1. **线程基本知识** - **进程与线程**：在操作系统中，进程是资源分配的基本单位，而线程是执行调度的基本...
Linux系统编程第07期：多线程编程入门
06-17
1. **多线程概念**：多线程是指在一个进程中可以存在多个执行流，每个执行流被称为一个线程。在Linux中，线程共享进程的内存空间，包括全局变量、堆内存等，而拥有各自的栈空间和独立的程序计数器。这样，多个线程...
Net平台多线程编程入门
06-22
### .NET平台多线程编程入门 在.NET平台下进行多线程编程是软件开发中的一个关键技能，尤其是在处理复杂的用户交互、数据处理以及后台任务时尤为重要。本篇将详细介绍.NET平台多线程编程的基础知识和技术要点。 ##...
Python实现web服务器入门学习笔记（6）——多进程实现并发HTTP服务器的面向对象封装
12-20
在本篇《Python实现Web服务器入门学习笔记（6）——多进程实现并发HTTP服务器的面向对象封装》中，我们将深入探讨如何使用面向对象编程的方法来封装之前实现的多进程并发HTTP服务器。面向对象编程（Object-Oriented ...
[Python学习篇] Python进程和线程
又逢乱世
07-11 535
thread创建线程、线程共享变量、线程互斥Lock、进程Process、创建进程、杀死进程、进程之间共享数据、进程互斥Lock
python---进程与线程 学习笔记
weixin_30260399的博客
02-02 109
进程和线程 什么是线程（thread）什么是进程 线程：操作系统能够进行运算调度的最小单位。它被包含在进程中，是进程中的实际运作单位。是一串指令的集合 　　一个线程指的是进程中一个单一顺序的控制流，一个进程是中可以并发多个线程，每个线程并行执行不同的任务 进程：以一个整体的形式暴露给操作系统管理，里面包含对各种资源的调用，内存的管理，网络接口的调用等，对各种资源管理的集合，就可以称为进...
详解Python多线程、多进程
2301_76161259的博客
10-06 1763
在学习Python的过程中，有接触到多线程编程相关的知识点，先前一直都没有彻底的搞明白。今天准备花一些时间，把里面的细节尽可能的梳理清楚。
Python中线程、进程与异步的介绍和实现（非常详细，例子多多、注解多多，值得大家参考借鉴）
nfkjdx的博客
01-03 1736
一文讲透python高性能编程
Python入门教学——多进程和多线程
计算机硕士的博客
09-14 443
线程和进程、创建多个线程、锁、线程间通讯、创建多个进程、进程间通讯
python---多任务篇
Love_Lw
07-26 86
1.多进程完成多任务 import time import multiprocessing def coding(): “”“编写代码”"" for i in range(3): print(“正在编写代码====”) time.sleep(1) def music(): “”“听音乐”"" for i in range(3): print(“正在听音乐======”) time.sleep(1) if name == ‘main’: # coding() # music() # 通过进程类创建进程对象 c
Python爬虫与MongoDB的完美结合
最新发布
weixin_52392194的博客
08-03 678
我们掌握了在Windows和Linux系统下安装MongoDB，设计适合爬虫存储数据的写入规范，并通过实际爬虫示例展示了如何将爬取到的数据存储到MongoDB中。此外，还进行了MongoDB性能优化，提高了数据存储和查询的效率。
Java多线程基础解析：从入门到理解核心概念
"java多线程基础篇讲解" Java多线程是编程领域的重要概念，尤其在现代计算系统中，多线程模型对于充分利用系统资源、提高应用程序性能具有至关重要的作用。本文将对Java多线程的基础知识进行讲解，适合初学者入门。...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值