Java中保证线程顺序执行的四种实现方式_Java

前言

在多线程编程中，线程的并发执行通常是不可预知的，然而在某些应用场景中，我们需要确保多个线程按特定的顺序执行。保证线程按顺序执行可以避免资源竞争、避免逻辑错误并提高程序的可控性。本文将介绍几种常见的方式，帮助我们在多线程中保证执行顺序。

1. 使用thread.join()方法

join()方法是java中一种常用的线程控制方法，用来让一个线程等待另一个线程执行完成后再继续执行。通过join()方法，我们可以确保多个线程按顺序执行。

示例：

class mythread extends thread {
    private string name;

    mythread(string name) {
        this.name = name;
    }

    @override
    public void run() {
        system.out.println(name + " is running.");
    }
}

public class threadjoinexample {
    public static void main(string[] args) throws interruptedexception {
        mythread thread1 = new mythread("thread 1");
        mythread thread2 = new mythread("thread 2");
        mythread thread3 = new mythread("thread 3");

        thread1.start();
        thread1.join();  // 让主线程等待thread1执行完成

        thread2.start();
        thread2.join();  // 让主线程等待thread2执行完成

        thread3.start();
        thread3.join();  // 让主线程等待thread3执行完成
    }
}

解释：

thread1.start()启动线程1。
thread1.join()主线程会等待线程1执行完成后才会继续执行。
thread2.start()启动线程2，依此类推。

这样，线程将会按顺序（thread 1 -> thread 2 -> thread 3）执行。

2. 使用executorservice和countdownlatch

executorservice提供了线程池的实现，而countdownlatch则允许多个线程互相等待直到某个条件被满足。通过这种机制，我们可以精确控制线程的执行顺序。

示例：

import java.util.concurrent.*;

public class threadorderwithcountdownlatch {
    public static void main(string[] args) throws interruptedexception {
        executorservice executor = executors.newfixedthreadpool(3);
        countdownlatch latch1 = new countdownlatch(1);
        countdownlatch latch2 = new countdownlatch(1);

        executor.submit(() -> {
            try {
                system.out.println("thread 1 is running.");
                latch1.countdown();  // 释放线程2
            } catch (exception e) {
                e.printstacktrace();
            }
        });

        executor.submit(() -> {
            try {
                latch1.await();  // 等待线程1完成
                system.out.println("thread 2 is running.");
                latch2.countdown();  // 释放线程3
            } catch (interruptedexception e) {
                e.printstacktrace();
            }
        });

        executor.submit(() -> {
            try {
                latch2.await();  // 等待线程2完成
                system.out.println("thread 3 is running.");
            } catch (interruptedexception e) {
                e.printstacktrace();
            }
        });

        executor.shutdown();
    }
}

解释：

通过countdownlatch的await()和countdown()方法，线程2必须等待线程1执行完毕，线程3必须等待线程2执行完毕。
这种方法非常适合复杂的线程执行顺序控制，尤其是在多个线程之间存在依赖关系时。

3. 使用semaphore

semaphore是一个计数信号量，用于控制多个线程对共享资源的访问。在保证顺序执行时，我们可以利用semaphore来协调线程之间的执行顺序。

示例：

import java.util.concurrent.*;

public class threadorderwithsemaphore {
    public static void main(string[] args) throws interruptedexception {
        semaphore semaphore1 = new semaphore(0);  // 初始化为0，表示线程2需要等待线程1
        semaphore semaphore2 = new semaphore(0);  // 初始化为0，表示线程3需要等待线程2

        new thread(() -> {
            system.out.println("thread 1 is running.");
            semaphore1.release();  // 释放线程2
        }).start();

        new thread(() -> {
            try {
                semaphore1.acquire();  // 等待线程1完成
                system.out.println("thread 2 is running.");
                semaphore2.release();  // 释放线程3
            } catch (interruptedexception e) {
                e.printstacktrace();
            }
        }).start();

        new thread(() -> {
            try {
                semaphore2.acquire();  // 等待线程2完成
                system.out.println("thread 3 is running.");
            } catch (interruptedexception e) {
                e.printstacktrace();
            }
        }).start();
    }
}

解释：

semaphore通过acquire()和release()方法协调线程执行顺序，确保线程按指定顺序执行。

4. 使用synchronized和wait/notify

通过synchronized和wait/notify机制，线程可以通过同步和通知机制来等待和唤醒。wait()会使线程进入等待状态，而notify()或notifyall()可以唤醒等待的线程。

示例：

public class threadorderwithwaitnotify {
    private static final object lock = new object();

    public static void main(string[] args) {
        thread thread1 = new thread(() -> {
            synchronized (lock) {
                system.out.println("thread 1 is running.");
                lock.notify();  // 唤醒线程2
            }
        });

        thread thread2 = new thread(() -> {
            synchronized (lock) {
                try {
                    lock.wait();  // 等待线程1执行
                    system.out.println("thread 2 is running.");
                    lock.notify();  // 唤醒线程3
                } catch (interruptedexception e) {
                    e.printstacktrace();
                }
            }
        });

        thread thread3 = new thread(() -> {
            synchronized (lock) {
                try {
                    lock.wait();  // 等待线程2执行
                    system.out.println("thread 3 is running.");
                } catch (interruptedexception e) {
                    e.printstacktrace();
                }
            }
        });

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