Java 多线程顺序执行，只知道两种

阅读更多：Java 教程

在本文中，我们将介绍Java多线程顺序执行的两种方式：使用join()方法和使用Lock和Condition。

1. 使用join()方法

在Java中，线程的执行顺序是不确定的，因此在某些情况下，我们希望线程按照既定的顺序执行。一个常用的方式就是使用join()方法。线程中的join()方法用于等待该线程执行完成。

下面是一个简单的示例，展示了如何使用join()方法实现多线程顺序执行：

public class JoinExample implements Runnable {

    private String name;
    private Thread prevThread;

    public JoinExample(String name, Thread prevThread) {
        this.name = name;
        this.prevThread = prevThread;
    }

    @Override
    public void run() {
        try {
            if (prevThread != null) {
                prevThread.join();
            }
            System.out.println(name + "开始执行");
            // 线程执行的逻辑
            System.out.println(name + "执行完成");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        Thread thread1 = new Thread(new JoinExample("线程1", null));
        Thread thread2 = new Thread(new JoinExample("线程2", thread1));
        Thread thread3 = new Thread(new JoinExample("线程3", thread2));

        thread3.start();
        thread2.start();
        thread1.start();
    }
}

在这个示例中，我们创建了三个线程，分别是”线程1″，”线程2″和”线程3″。在每个线程中，我们都调用了join方法，等待上一个线程执行完成。这样就可以保证线程的顺序执行。

2. 使用Lock和Condition

除了使用join()方法，我们还可以利用Java的Lock和Condition机制来实现多线程的顺序执行。

Lock和Condition是Java并发包中的一部分，用于实现比synchronized关键字更灵活的线程同步。我们可以使用Condition的await()和signal()方法来控制线程的顺序执行。

下面是一个使用Lock和Condition实现多线程顺序执行的示例：

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class LockConditionExample implements Runnable {

    private String name;
    private Lock lock;
    private Condition condition;

    public LockConditionExample(String name, Lock lock, Condition condition) {
        this.name = name;
        this.lock = lock;
        this.condition = condition;
    }

    @Override
    public void run() {
        try {
            lock.lock();
            System.out.println(name + "开始执行");
            // 线程执行的逻辑
            System.out.println(name + "执行完成");
            condition.signalAll();
        } finally {
            lock.unlock();
        }
    }

    public static void main(String[] args) {
        Lock lock = new ReentrantLock();
        Condition condition = lock.newCondition();

        Thread thread1 = new Thread(new LockConditionExample("线程1", lock, condition));
        Thread thread2 = new Thread(new LockConditionExample("线程2", lock, condition));
        Thread thread3 = new Thread(new LockConditionExample("线程3", lock, condition));

        thread1.start();
        thread2.start();
        thread3.start();

        try {
            lock.lock();
            condition.await();
            condition.await();
            System.out.println("所有线程执行完毕");
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
}

在这个示例中，我们使用ReentrantLock来创建一个Lock对象，并使用newCondition()方法创建Condition对象。在每个线程中，我们首先获取锁，然后执行线程的逻辑，最后通过signalAll()方法通知其他线程。

同时，我们使用await()方法让主线程等待所有子线程执行完毕。一旦所有线程都执行完成，主线程会打印出”所有线程执行完毕”的消息。

总结

本文介绍了Java中多线程顺序执行的两种方式：使用join()方法和使用Lock和Condition。这些方法都可以实现线程的顺序执行，根据具体的需求选择合适的方式。在实际开发中，我们需要考虑多线程带来的并发安全性，以及对性能的影响。通过合理的设计和使用，我们可以充分发挥多线程的优势，提高程序的效率和性能。