要设置多线程程序的执行顺序，可以使用以下几种方法：
使用 `join（）` 方法
在子线程中通过 `join（）` 方法指定顺序。调用 `join（）` 方法会使当前线程阻塞，直到指定的线程执行完毕后继续执行。这样可以确保线程按照预期的顺序执行。
```java
public class ThreadJoinDemo {
public static void main（String[] args） {
Thread thread1 = new Thread（（） -> System.out.println（"打开冰箱!!!"））；
Thread thread2 = new Thread（（） -> System.out.println（"产品经理来上班了."））；
Thread thread3 = new Thread（（） -> System.out.println（"开发人员来上班了."））；
Thread thread4 = new Thread（（） -> System.out.println（"测试人员来上班了..."））；
thread1.start（）；
try {
thread1.join（）；
} catch （InterruptedException e） {
e.printStackTrace（）；
}
thread2.start（）；
try {
thread2.join（）；
} catch （InterruptedException e） {
e.printStackTrace（）；
}
thread3.start（）；
try {
thread3.join（）；
} catch （InterruptedException e） {
e.printStackTrace（）；
}
thread4.start（）；
}
}
```
使用主线程的 `join（）` 方法
在主线程中使用 `join（）` 方法等待子线程执行完毕。这样可以确保主线程在子线程执行完毕后才继续执行。
```java
public class Main {
public static void main（String[] args） {
Thread thread1 = new Thread（（） -> System.out.println（"产品经理来上班了."））；
Thread thread2 = new Thread（（） -> System.out.println（"开发人员来上班了."））；
Thread thread3 = new Thread（（） -> System.out.println（"测试人员来上班了..."））；
thread1.start（）；
try {
thread1.join（）；
} catch （InterruptedException e） {
e.printStackTrace（）；
}
thread2.start（）；
try {
thread2.join（）；
} catch （InterruptedException e） {
e.printStackTrace（）；
}
thread3.start（）；
try {
thread3.join（）；
} catch （InterruptedException e） {
e.printStackTrace（）；
}
}
}
```
使用 `wait（）` 和 `notify（）` 方法
通过 `wait（）` 和 `notify（）` 方法实现线程间的协调和同步。`wait（）` 方法使线程等待，`notify（）` 方法唤醒等待的线程。
```java
public class WaitNotifyDemo {
public static void main（String[] args） {
final Object lock = new Object（）；
Thread thread1 = new Thread（（） -> {
synchronized （lock） {
System.out.println（"产品经理来上班了."）；
lock.notify（）；
}
}）；
Thread thread2 = new Thread（（） -> {
synchronized （lock） {
try {
lock.wait（）；
} catch （InterruptedException e） {
e.printStackTrace（）；
}
System.out.println（"开发人员来上班了."）；
}
}）；
thread1.start（）；
thread2.start（）；
}
}
```
使用线程池
通过线程池来管理线程，可以更方便地控制线程的执行顺序和并发度。Java 的 `ExecutorService` 接口和 `Executors` 类提供了方便的线程池管理功能。
```java
import java.util.concurrent.ExecutorService；
import java.util.concurrent.Executors；
public class ThreadPoolDemo {
public static void main（String[] args） {
ExecutorService executorService = Executors.newFixedThreadPool（4）；
executorService.submit（（） -> System.out.println（"产品经理来上班了."））；
executorService.submit（（） -> System.out.println（"开发人员来上班了."））；
executorService.submit（（） -> System.out.println（"测试人员来上班了..."））；
executorService.shutdown（）；
}
}
```
使用 `CountDownLatch`
`CountDownLatch` 是一个同步辅助类，允许
