問題:
有first,second,third,forth四個執行緒,first輸出1，second輸出2，third輸出3，forth輸出4。要求, 同時啟動四個執行緒, 按順序輸出1234, 且未無限迴圈輸出。

這是一個多執行緒協同的問題，本身多執行緒是沒有執行順序的, 順序不一定。
但是可以採取一定方式使多執行緒按一定順序執行。

ReentrantLock

ReentrantLock來解決, 還有個state整數用來判斷輪到誰執行了。

public class PrintTwo {
    private static Lock lock = new ReentrantLock();//通過JDK5中的鎖來保證執行緒的訪問的互斥
 

    private static int state = 0; 
    static class First extends Thread {
        @Override
        public void run() {
            while (true) {
                lock.lock();
                if (state % 4 == 0) {
                    System.out.println("1");
                    state++;
                }
                lock.unlock();
            }
        }
    }

    static
 
 class Second extends Thread {
        @Override
        public void run() {
            while (true) {
                lock.lock();
                if (state % 4 == 1) {
                    System.out.println("2");
                    state++;
                }
                lock.unlock();
            }
        }
    }

    static
 
 class Third extends Thread {
        @Override
        public void run() {
            while (true) {
                lock.lock();
                if (state % 4 == 2) {
                    System.out.println("3");
                    state++;
                }
                lock.unlock();
            }
        }
    }

    static class Forth extends Thread {
        @Override
        public void run() {
            while (true) {
                lock.lock();
                if (state % 4 == 3) {
                    System.out.println("4");
                    state++;
                }
                lock.unlock();
            }
        }
    }

    public static void main(String[] args) {
        First first = new First();
        Second second = new Second();
        Third third = new Third();
        Forth forth = new Forth();
        first.start();
        second.start();
        third.start();
        forth.start();
     }     
}

Semphore

Semphore,完成對訊號量的控制，可以控制某個資源可以被同時訪問的個數，通過acquire()獲取一個許可，如果沒有就等待，而release()釋放一個許可。（另外，semphore還可以用來控制同時訪問一個方法的執行緒數：https://blog.csdn.net/anhenzhufeng/article/details/70225415 ）

package Thread;

import java.util.concurrent.Semaphore;

public class Print1234 {
    public static Semaphore sem1;
    public static Semaphore sem2;
    public static Semaphore sem3;
    public static Semaphore sem4;

    static class FirstThread extends Thread {
        public void run() {
            try {
                while (true) {
                    sem1.acquire();
                    System.out.println("1");
                    sem2.release();
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    static class SecondThread extends Thread {
        public void run() {
            try {
                while (true) {
                    sem2.acquire();
                    System.out.println("2");
                    sem3.release();
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    static class ThirdThread extends Thread {
        public void run() {
            try {
                while (true) {
                    sem3.acquire();
                    System.out.println("3");
                    sem4.release();
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    static class ForthThread extends Thread {
        public void run() {
            try {
                while (true) {
                    sem4.acquire();
                    System.out.println("4");
                    sem1.release();
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) {
        sem1 = new Semaphore(1);
        sem2 = new Semaphore(1);
        sem3 = new Semaphore(1);
        sem4 = new Semaphore(1);
        try {
            // 不要有sem1.acquire()
            sem2.acquire();
            sem3.acquire();
            sem4.acquire();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        new FirstThread().start();
        new SecondThread().start();
        new ThirdThread().start();
        new ForthThread().start();

    }
}

volatile

volatile，保證被修飾的變數在讀寫前都會與主存互動更新。一個變數被volatile修飾後，則不同執行緒對這個變數進行操作時，總是從記憶體中讀取最新值，即每次更新對其他執行緒都是立即可見的。

public class PrintThree {
    volatile static int state = 0;

    static class First extends Thread {
        @Override
        public void run() {
            while (true) {
                if (state % 4 == 0) {
                    System.out.println("1");
                    state++;
                }
            }
        }
    }

    static class Second extends Thread {
        @Override
        public void run() {
            while (true) {
                if (state % 4 == 1) {
                    System.out.println("2");
                    state++;
                }
            }
        }
    }

    static class Third extends Thread {
        @Override
        public void run() {
            while (true) {
                if (state % 4 == 2) {
                    System.out.println("3");
                    state++;
                }
            }
        }
    }

    static class Forth extends Thread {
        @Override
        public void run() {
            while (true) {
                if (state % 4 == 3) {
                    System.out.println("4");
                    state++;
                }
            }
        }
    }

    public static void main(String[] args) {
        First first = new First();
        Second second = new Second();
        Third third = new Third();
        Forth forth = new Forth();
        first.start();
        second.start();
        third.start();
        forth.start();
    }
}