隻要了解過多線程，我們就知道線程開始的順序跟執行的順序是不一樣的。如果隻是建立三個線程然後執行，最後的執行順序是不可預期的。這是因為在建立完線程之後，線程執行的開始時間取決于CPU何時配置設定時間片，線程可以看成是相對于的主線程的一個異步操作。
public class FIFOThreadExample {
public synchronized static void foo(String name) {
System.out.print(name);
}
public static void main(String[] args) {
Thread thread1 = new Thread(() -> foo("A"));
Thread thread2 = new Thread(() -> foo("B"));
Thread thread3 = new Thread(() -> foo("C"));
thread1.start();
thread2.start();
thread3.start();
}
}
輸出結果：ACB/ABC/CBA...
那麼我們該如何保證線程的順序執行呢？
如何保證線程的順序執行?
1. 使用Thread.join()實作
Thread.join()
的作用是讓父線程等待子線程結束之後才能繼續運作。以上述例子為例，
main()
方法所在的線程是父線程，在其中我們建立了3個子線程A,B,C，子線程的執行相對父線程是異步的，不能保證順序性。而對子線程使用
Thread.join()
方法之後就可以讓父線程等待子線程運作結束後，再開始執行父線程，這樣子線程執行被強行變成了同步的，我們用
Thread.join()
方法就能保證線程執行的順序性。
public class FIFOThreadExample {
public static void foo(String name) {
System.out.print(name);
}
public static void main(String[] args) throws InterruptedException{
Thread thread1 = new Thread(() -> foo("A"));
Thread thread2 = new Thread(() -> foo("B"));
Thread thread3 = new Thread(() -> foo("C"));
thread1.start();
thread1.join();
thread2.start();
thread2.join();
thread3.start();
}
}
輸出結果：ABC
2. 使用單線程線程池來實作
另一種保證線程順序執行的方法是使用一個單線程的線程池，這種線程池中隻有一個線程，相應的，内部的線程會按加入的順序來執行。
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class FIFOThreadExample {
public static void foo(String name) {
System.out.print(name);
}
public static void main(String[] args) throws InterruptedException{
Thread thread1 = new Thread(() -> foo("A"));
Thread thread2 = new Thread(() -> foo("B"));
Thread thread3 = new Thread(() -> foo("C"));
ExecutorService executor = Executors.newSingleThreadExecutor();
executor.submit(thread1);
executor.submit(thread2);
executor.submit(thread3);
executor.shutdown();
}
}
輸出結果：ABC
3. 使用volatile關鍵字修飾的信号量實作
上面兩種的思路都是讓保證線程的執行順序，讓線程按一定的順序執行。這裡介紹第三種思路，那就是線程可以無序運作，但是執行結果按順序執行。
你應該可以想到，三個線程都被建立并
start()
，這時候三個線程随時都可能執行
run()
方法。是以為了保證
run()
執行的順序性，我們肯定需要一個信号量來讓線程知道在任意時刻能不能執行邏輯代碼。
另外，因為三個線程是獨立的，這個信号量的變化肯定需要對其他線程透明，是以volatile關鍵字也是必須要的。
public class TicketExample2 {
//信号量
static volatile int ticket = 1;
//線程休眠時間
public final static int SLEEP_TIME = 1;
public static void foo(int name){
//因為線程的執行順序是不可預期的，是以需要每個線程自旋
while (true) {
if (ticket == name) {
try {
Thread.sleep(SLEEP_TIME);
//每個線程循環列印3次
for (int i = 0; i < 3; i++) {
System.out.println(name + " " + i);
}
} catch (InterruptedException e) {
e.printStackTrace();
}
//信号量變更
ticket = name%3+1;
return;
}
}
}
public static void main(String[] args) throws InterruptedException {
Thread thread1 = new Thread(() -> foo(1));
Thread thread2 = new Thread(() -> foo(2));
Thread thread3 = new Thread(() -> foo(3));
thread1.start();
thread2.start();
thread3.start();
}
}
執行結果：
1 0
1 1
1 2
2 0
2 1
2 2
3 0
3 1
3 2
4. 使用Lock和信号量實作
此種方法的思想跟第三種方法是一樣的，都是不考慮線程執行的順序而是考慮用一些方法控制線程執行業務邏輯的順序。這裡我們同樣用一個原子類型信号量
ticket
，當然你可以不用原子類型，這裡我隻是為了保證自增操作的線程安全。然後我們用了一個可重入鎖
ReentrantLock
。用來給方法加鎖，當一個線程拿到鎖并且辨別位正确的時候開始執行業務邏輯，執行完畢後喚醒下一個線程。
這裡我們不需要使用while進行自旋操作了，因為Lock可以讓我們喚醒指定的線程，是以改成if就可以實作順序的執行。
public class TicketExample3 {
//信号量
AtomicInteger ticket = new AtomicInteger(1);
public Lock lock = new ReentrantLock();
private Condition condition1 = lock.newCondition();
private Condition condition2 = lock.newCondition();
private Condition condition3 = lock.newCondition();
private Condition[] conditions = {condition1, condition2, condition3};
public void foo(int name) {
try {
lock.lock();
//因為線程的執行順序是不可預期的，是以需要每個線程自旋
System.out.println("線程" + name + " 開始執行");
if(ticket.get() != name) {
try {
System.out.println("目前辨別位為" + ticket.get() + ",線程" + name + " 開始等待");
//開始等待被喚醒
conditions[name - 1].await();
System.out.println("線程" + name + " 被喚醒");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println(name);
ticket.getAndIncrement();
if (ticket.get() > 3) {
ticket.set(1);
}
//執行完畢，喚醒下一次。1喚醒2,2喚醒3
conditions[name % 3].signal();
} finally {
//一定要釋放鎖
lock.unlock();
}
}
public static void main(String[] args) throws InterruptedException {
TicketExample3 example = new TicketExample3();
Thread t1 = new Thread(() -> {
example.foo(1);
});
Thread t2 = new Thread(() -> {
example.foo(2);
});
Thread t3 = new Thread(() -> {
example.foo(3);
});
t1.start();
t2.start();
t3.start();
}
}
輸出結果：
線程2 開始執行
目前辨別位為1,線程2 開始等待
線程1 開始執行
1
線程3 開始執行
目前辨別位為2,線程3 開始等待
線程2 被喚醒
2
線程3 被喚醒
3
上述的執行結果并非唯一，但可以保證列印的順序一定是123這樣的順序。
參考文章
java 多線程 實作多個線程的順序執行 - Hoonick - 部落格園 (cnblogs.com)
Java lock鎖的一些細節_筆記小屋-CSDN部落格
VolatileCallSite (Java Platform SE 8 ) (oracle.com)
java保證多線程的執行順序 - james.yj - 部落格園 (cnblogs.com)