JAVA synchronize 按顺序执行

在多线程编程中，有时我们希望某些任务按照顺序执行，即每个任务必须在前一个任务完成后才能开始执行。为了实现这一目标，我们可以使用 Java 中的 synchronize 关键字。

synchronize 关键字

在 Java 中，synchronize 关键字用于实现线程的同步。当一个方法或一个代码块被 synchronize 关键字修饰时，它被称为同步方法或同步代码块。

同步方法：将 synchronize 关键字直接应用在方法上，表示该方法是一个同步方法。当一个线程调用同步方法时，它会自动获得该方法的锁，并保证同一时刻只有一个线程能够执行该方法。

同步代码块：将 synchronize 关键字应用在代码块中，表示该代码块是一个同步代码块。同步代码块使用一个对象作为锁，只有获得该对象的线程才能执行该代码块。

按顺序执行示例

为了更好地理解 synchronize 按顺序执行的原理，我们假设有三个任务 A、B 和 C，它们需要按照 A、B、C 的顺序执行。我们可以通过为每个任务设置一个锁对象，并使用 synchronize 关键字实现这个顺序执行的需求。

代码示例如下：

class Worker implements Runnable {
    private String name;
    private Object lock;

    public Worker(String name, Object lock) {
        this.name = name;
        this.lock = lock;
    }

    public void run() {
        synchronized (lock) {
            try {
                if (name.equals("A")) {
                    // 第一个任务 A 的逻辑
                    System.out.println("Task A is running");
                    Thread.sleep(1000);
                } else if (name.equals("B")) {
                    // 第二个任务 B 的逻辑
                    System.out.println("Task B is running");
                    Thread.sleep(1000);
                } else if (name.equals("C")) {
                    // 第三个任务 C 的逻辑
                    System.out.println("Task C is running");
                    Thread.sleep(1000);
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

public class Main {
    public static void main(String[] args) {
        Object lock = new Object();
        Thread threadA = new Thread(new Worker("A", lock));
        Thread threadB = new Thread(new Worker("B", lock));
        Thread threadC = new Thread(new Worker("C", lock));

        threadA.start();
        threadB.start();
        threadC.start();
    }
}

上述代码中，我们创建了一个 Worker 类来表示每个任务，并在其 run 方法中使用 synchronize 关键字来实现任务的同步。在 main 方法中，我们创建了三个线程并分别传入了对应的任务和锁对象。

这样，由于每个线程在执行任务时都会先获取锁对象，因此它们会按照 A、B、C 的顺序执行任务，保证了任务的顺序执行。

序列图

下面是使用 mermaid 语法绘制的按顺序执行的序列图：

sequenceDiagram
    participant ThreadA
    participant ThreadB
    participant ThreadC
    ThreadA->>ThreadA: 获取锁对象
    ThreadA->>ThreadA: 执行任务 A
    ThreadA->>ThreadA: 释放锁对象
    ThreadB->>ThreadB: 获取锁对象
    ThreadB->>ThreadB: 执行任务 B
    ThreadB->>ThreadB: 释放锁对象
    ThreadC->>ThreadC: 获取锁对象
    ThreadC->>ThreadC: 执行任务 C
    ThreadC->>ThreadC: 释放锁对象

类图

下面是使用 mermaid 语法绘制的类图：

classDiagram
    class Worker {
        - String name
        - Object lock
        --
        + Worker(name: String, lock: Object)
        + run()
    }
    class Main {
        --
        + main(args: String[])
    }
    class Thread {
        --
        + Thread(target: Runnable)
        + start()
    }
    interface Runnable {
        --
        + run()
    }

总结

使用 synchronize 关键字可以实现按顺序执行多个任务的需求。通过为每个任务设置一个锁对象，并在任务的 run 方法中使用 synchronize 关键字，我们可以保证任务按