多线程编程简介

冰.封万里

于 2024-03-04 19:22:18 发布

阅读量1k

点赞数 14

分类专栏：后端文章标签：多线程编程并行执行顺序执行线程池 java python

本文链接：https://blog.csdn.net/weixin_46412417/article/details/136459627

版权

后端专栏收录该内容

1 篇文章 0 订阅

订阅专栏

并行执行与顺序执行：初学者指南

计算机科学中的并行执行是一项强大的优化技术，它可以显著提高程序的性能。
但是，什么样的语句和数据可以同时执行呢？为什么有时只能按顺序执行呢？

并行执行

什么是并行执行？
并行执行是指多个任务或操作同时进行，而不是按顺序一个接一个地执行。这在高性能计算、多核处理器和分布式系统中非常常见。

能够同时执行的语句

以下是能够同时执行的语句的条件：

独立性：语句之间不会相互影响。如果两个语句之间没有数据依赖关系，它们可以并行执行。例如，两个循环可以同时运行，因为它们不共享变量。
资源不冲突：语句需要的资源不会发生冲突。例如，如果两个语句都需要访问同一个共享内存区域，它们就不能同时执行，因为会发生竞争条件。

能够同时处理的数据

以下是能够同时处理的数据的条件：

数据独立性：数据之间没有依赖关系。如果数据之间相互独立，可以同时处理。例如，对一个数组的不同元素进行计算。
数据分区：将数据分成多个部分，每个部分可以独立处理。例如，将一个大型数据集分成多个块，每个块由不同的处理单元处理。

顺序执行的情况

有时，几条语句只能顺序执行而不能并行执行的原因包括：

数据依赖：如果一个语句的执行结果影响了另一个语句的执行，它们必须按顺序执行。例如，一个语句修改了某个变量的值，而另一个语句依赖于这个变量的值。
资源限制：如果资源（如内存、CPU核心）有限，多个语句可能无法同时执行，因此必须按顺序执行。

并行执行可以显著提高计算性能，但需要满足一定的条件。
在设计并行算法时，我们需要仔细考虑数据之间的依赖关系和资源的使用情况。

多线程编程：初学者指南

在计算机科学中，多线程编程是一种强大的优化技术，它可以显著提高程序的性能。
让我们一起探讨一下多线程编程的基本概念、线程生命周期、优先级、创建方法以及如何控制线程的执行。

在这里插入图片描述

什么是多线程？

线程是进程中的一个单一顺序的控制流。一个进程可以包含多个线程，每个线程并行执行不同的任务。
多线程是多任务的一种特别形式，但相比于多进程，多线程使用更小的资源开销。

线程的生命周期

新建状态：线程对象被创建后，处于新建状态，直到调用 start() 方法启动线程。
就绪状态：线程进入就绪状态等待调度器的调度，一旦获取 CPU 资源，就可以执行 run() 方法。
运行状态：线程执行 run() 方法，处于运行状态。它可以变为阻塞状态、就绪状态或死亡状态。
阻塞状态：线程执行了 sleep、suspend 等方法，失去资源后进入阻塞状态。可以分为等待阻塞、同步阻塞和其他阻塞。
死亡状态：线程完成任务或满足终止条件后切换到终止状态。

线程的优先级

每个线程都有一个优先级，帮助操作系统确定线程的调度顺序。
优先级取值范围是 1（最低优先级）到 10（最高优先级）。
优先级不能保证线程执行顺序，但影响资源分配。

创建线程的方法

实现 Runnable 接口：创建一个实现 Runnable 接口的类，重写 run() 方法，然后实例化线程对象。
继承 Thread 类：创建一个继承 Thread 类的新类，重写 run() 方法，实例化该类的对象。
使用 Callable 和 Future：创建线程的另一种方式。

示例[Java]：通过实现 `Runnable` 接口创建线程

class MyRunnable implements Runnable {
    public void run() {
        // 线程执行的任务
        System.out.println("Hello from a thread!");
    }
}

public class ThreadExample {
    public static void main(String[] args) {
        MyRunnable myRunnable = new MyRunnable();
        Thread thread = new Thread(myRunnable);
        thread.start(); // 启动线程
    }
}

示例[Java]：通过继承 `Thread` 类创建线程

class MyThread extends Thread {
    public void run() {
        // 线程执行的任务
        System.out.println("Hello from a thread!");
    }
}

public class ThreadExample {
    public static void main(String[] args) {
        MyThread myThread = new MyThread();
        myThread.start(); // 启动线程
    }
}

以上示例中，线程执行的任务是输出一条消息。你可以根据实际需求编写自己的线程任务。
多线程编程需要谨慎处理共享资源、同步和线程安全等问题，但它可以显著提高程序的效率。

控制线程执行顺序的方法

在多线程编程中，有许多方法可以控制线程的执行顺序。让我们一起探讨一些常用的技术。

在这里插入图片描述

1. 使用线程的 `join` 方法

join() 是 Thread 类的方法，作用是让一个线程等待另一个线程执行完成后再继续运行。
当一个线程必须等待另一个线程执行完毕才能执行时，可以使用 join 方法。

示例[Java]：使用 `join` 方法按顺序执行线程

public class ThreadJoinDemo {
    public static void main(String[] args) {
        Thread thread1 = new Thread(() -> System.out.println("产品经理规划新需求"));
        Thread thread2 = new Thread(() -> {
            try {
                thread1.join();
                System.out.println("开发人员开发新需求功能");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        Thread thread3 = new Thread(() -> {
            try {
                thread2.join();
                System.out.println("测试人员测试新功能");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        System.out.println("早上：");
        System.out.println("测试人员来上班了...");
        thread3.start();
        System.out.println("产品经理来上班了...");
        thread1.start();
        System.out.println("开发人员来上班了...");
        thread2.start();
    }
}

运行结果：

早上：
测试人员来上班了...
产品经理来上班了...
开发人员来上班了...
产品经理规划新需求
开发人员开发新需求功能
测试人员测试新功能

2. 使用主线程的 `join` 方法

在主线程中使用 join() 可以实现对线程的阻塞。
主线程调用子线程的 join() 方法后，主线程需要等待子线程运行完再继续运行。

示例[Java]：使用主线程的 `join` 方法

public class ThreadMainJoinDemo {
    public static void main(String[] args) throws Exception {
        Thread thread1 = new Thread(() -> System.out.println("产品经理正在规划新需求..."));
        Thread thread2 = new Thread(() -> System.out.println("开发人员开发新需求功能"));
        Thread thread3 = new Thread(() -> System.out.println("测试人员测试新功能"));

        System.out.println("早上:");
        System.out.println("产品经理来上班了");
        System.out.println("测试人员来上班了");
        System.out.println("开发人员来上班了");

        thread1.start();
        System.out.println("开发人员和测试人员休息会...");
        thread1.join();
        System.out.println("产品经理新需求规划完成!");

        thread2.start();
        System.out.println("测试人员休息会...");
        thread2.join();

        thread3.start();
    }
}

运行结果：

产品经理来上班了
测试人员来上班了
开发人员来上班了
开发人员和测试人员休息会...
产品经理正在规划新需求...
产品经理新需求规划完成!
测试人员休息会...
开发人员开发新需求功能
测试人员测试新功能

这些方法可以帮助你控制线程的执行顺序。根据实际需求，选择适合的方法来确保线程按照预期顺序执行。

多线程编程的 Python 实现

在计算机编程中，多线程是一种并发执行的方式，允许程序在同一时间段内执行多个任务，从而提高效率和执行速度。

Python 提供了多种方式来实现多线程编程，包括使用 threading 模块、concurrent.futures 模块、multiprocessing 模块以及 asyncio 模块。

在这里插入图片描述

1. 使用 `threading` 模块

threading 模块是 Python 中最常用的多线程模块之一。它允许创建和管理线程，使得程序可以并发执行。以下是使用 threading 模块实现多线程的示例代码：

import threading
import time

def worker(name, sec):
    print(f"Thread {name} started at {time.ctime()}")
    time.sleep(sec)
    print(f"Thread {name} finished at {time.ctime()}")

# 创建 Thread 实例
t1 = threading.Thread(target=worker, args=("第一个线程", 1))
t2 = threading.Thread(target=worker, args=("第二个线程", 2))

# 启动线程运行
t1.start()
t2.start()

# 等待所有线程执行完毕
t1.join()
t2.join()

在上面的代码中，我们定义了一个 worker 函数，该函数会在一个新的线程中执行。然后，我们创建了两个线程实例 t1 和 t2，并启动它们。主线程等待这两个线程执行完毕。

2. 使用 `concurrent.futures` 模块

concurrent.futures 模块是 Python 3 中的新模块，它提供了线程池和进程池的实现。以下是使用 concurrent.futures 模块实现多线程的示例代码：

import concurrent.futures

def worker():
    print("Worker thread started")
    time.sleep(1)
    print("Worker thread finished")

# 创建线程池
with concurrent.futures.ThreadPoolExecutor(max_workers=2) as executor:
    # 提交 worker 函数给线程池
    future = executor.submit(worker)

print("Main thread finished")

在上面的代码中，我们使用线程池来执行 worker 函数。线程池会自动管理线程的创建和销毁，从而使程序更加高效。

3. 使用 `multiprocessing` 模块

multiprocessing 模块提供了多进程编程的支持。以下是使用 multiprocessing 模块实现多线程的示例代码：

import multiprocessing

def worker():
    print("Worker process started")
    time.sleep(1)
    print("Worker process finished")

# 创建新进程
p = multiprocessing.Process(target=worker)

# 启动新进程
p.start()

print("Main process finished")

在上面的代码中，我们创建了一个新的进程 p，并在新进程中执行 worker 函数。主进程和新进程是并行执行的，从而提高了程序的执行速度。

4. 使用 `asyncio` 模块

asyncio 模块提供了异步编程的支持，可以在单线程中实现并发执行。以下是使用 asyncio 模块实现多线程的示例代码：

import asyncio

async def worker():
    print("Worker task started")
    await asyncio.sleep(1)
    print("Worker task finished")

# 创建事件循环
loop = asyncio.get_event_loop()

# 运行 worker 协程
loop.run_until_complete(worker())

# 关闭事件循环
loop.close()

在上面的代码中，我们定义了一个 worker 协程，它会在单线程中异步执行。asyncio 模块允许我们在单线程中实现并发，从而提高效率。

总结

线程池是一种有效的多线程编程方式，可以提高程序的性能。使用concurrent.futures模块，你可以轻松地创建和管理线程池。
无论你选择哪种方式，多线程编程都可以帮助你更好地提高程序的效率。

冰.封万里

关注

14
点赞
踩
31

收藏

觉得还不错? 一键收藏
打赏
3
评论
多线程编程简介

线程是进程中的一个单一顺序的控制流。一个进程可以包含多个线程，每个线程并行执行不同的任务。多线程是多任务的一种特别形式，但相比于多进程，多线程使用更小的资源开销。线程池是一种有效的多线程编程方式，可以提高程序的性能。使用模块，你可以轻松地创建和管理线程池。无论你选择哪种方式，多线程编程都可以帮助你更好地提高程序的效率。
复制链接

扫一扫