java多个线程抢占

原创

mob64ca12ecf3b4 2024-09-06 04:50:28 ©著作权

©著作权归作者所有：来自51CTO博客作者mob64ca12ecf3b4的原创作品，请联系作者获取转载授权，否则将追究法律责任

Java多个线程抢占的科普

在多线程编程中，线程抢占是一个重要的概念，尤其是在 Java 中。线程抢占意味着多个线程在共享资源时，会相互竞争，以获取对这些资源的访问权限。在这篇文章中，我们将探讨 Java 多线程的基本概念、线程抢占的机制，以及如何在实际编程中实现线程的抢占，最后通过甘特图和流程图的形式来展示线程的执行情况。

1. 什么是多线程？

多线程是指在单一进程中同时存在多个执行线程。这些线程可以并行执行，提升程序的效率。在 Java 中，通过 Thread 类或 Runnable 接口可以创建和管理线程。

1.1 线程的基本操作

在创建线程时，我们通常需要实现以下几个步骤：

创建一个实现了 Runnable 接口的类
创建一个线程实例
调用 start() 方法启动线程

以下是一个简单的多线程示例：

class MyRunnable implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println(Thread.currentThread().getName() + " - " + i);
            try {
                Thread.sleep(100); // 模拟执行耗时
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

public class MultiThreadExample {
    public static void main(String[] args) {
        Thread t1 = new Thread(new MyRunnable(), "Thread-1");
        Thread t2 = new Thread(new MyRunnable(), "Thread-2");

        t1.start();
        t2.start();
    }
}

在上述代码中，我们创建了两个线程 Thread-1 和 Thread-2，各自执行相同的 run 方法。每个线程循环打印自己的名字和当前的计数，模拟耗时操作。

2. 线程抢占

2.1 抢占定义

线程抢占是指多个线程同时竞争 CPU 资源，其中一个线程可以中断（抢占）另一个线程的执行，以获得 CPU 的处理权。在 Java 中，线程抢占主要依赖于线程调度器，后者根据线程优先级动态调整线程的执行和排队。

2.2 线程优先级

Java 线程具有优先级，我们可以设置每个线程的优先级，以便提高某些线程的执行频率。线程优先级范围从 1 到 10，以 5 为默认值。

可以通过 setPriority(int newPriority) 方法来设置线程优先级：

Thread t1 = new Thread(new MyRunnable(), "Thread-1");
t1.setPriority(Thread.MAX_PRIORITY); // 设置为最高优先级

尽管设置了线程优先级，但 JVM 的调度机制可能使其不具有预期的效果。

3. 示例：线程抢占的可视化

为了直观地展示多线程抢占的情况，我们构建一个场景，让两个线程共享一个计数器，进行抢占。

以下是一个简单的抢占示例，演示线程的执行过程：

class Counter {
    private int count = 0;

    synchronized void increment() {
        count++;
        System.out.println(Thread.currentThread().getName() + " - Count: " + count);
    }
}

public class ReentrantLockExample {
    public static void main(String[] args) {
        Counter counter = new Counter();
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 5; i++) {
                counter.increment();
                try {
                    Thread.sleep(50);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "Thread-1");

        Thread t2 = new Thread(() -> {
            for (int i = 0; i < 5; i++) {
                counter.increment();
                try {
                    Thread.sleep(50);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "Thread-2");

        t1.start();
        t2.start();
    }
}

在这个示例中，我们定义了一个 Counter 类，使用 synchronized 关键字来确保线程安全。两个线程均会尝试对同一个 Counter 对象进行加 1 操作，模拟抢占的过程。

3.1 甘特图

接下来，我们通过甘特图可视化线程的执行过程。以下是使用 Mermaid 语法的甘特图示例：

gantt
    title 执行时间表
    dateFormat  HH:mm
    section Thread-1
    执行任务    :a1, 00:00, 00:05
    section Thread-2
    执行任务    :after a1  , 00:05, 00:05

这个甘特图展示了 Thread-1 在抢占期间与其他线程的竞争关系。

3.2 流程图

我们还可以使用流程图来展示程序的基本执行流程：

flowchart TD
    A[开始] --> B[创建Counter对象]
    B --> C[启动Thread-1]
    B --> D[启动Thread-2]
    C --> E[Thread-1调用increment()]
    C --> F[Thread-2调用increment()]
    E --> G[输出当前计数]
    F --> G
    G --> H[结束]

以上流程图清晰地说明了在多个线程中调用共享资源时的基本流程。