多线程：按序打印

class FirstThread extends Thread {
    final Foo foo;
    final Runnable runnable;

    FirstThread(Foo foo, Runnable runnable) {
        this.foo = foo;
        this.runnable = runnable;
    }

    @Override
    public void run() {
        try {
            foo.first(runnable);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

class SecondThread extends Thread {
    final Foo foo;
    final Runnable runnable;

    SecondThread(Foo foo, Runnable runnable) {
        this.foo = foo;
        this.runnable = runnable;
    }

    @Override
    public void run() {
        try {
            foo.second(runnable);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

class ThirdThread extends Thread {
    final Foo foo;
    final Runnable runnable;

    ThirdThread(Foo foo, Runnable runnable) {
        this.foo = foo;
        this.runnable = runnable;
    }

    @Override
    public void run() {
        try {
            foo.third(runnable);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

public class Main {
    public static void main(String[] args) {
        Runnable first = () -> {
            System.out.println("First");
        };
        Runnable second = () -> {
            System.out.println("Second");
        };
        Runnable third = () -> {
            System.out.println("Third");
        };

        Foo foo = new Foo();

        FirstThread ft = new FirstThread(foo, first);
        SecondThread st = new SecondThread(foo, second);
        ThirdThread tt = new ThirdThread(foo, third);

        ft.start();
        st.start();
        tt.start();
    }
}

第一种方法：

class Foo1 {
    private volatile int step = 1;

    public Foo1() { }

    public void first(Runnable printFirst) throws InterruptedException {
        // printFirst.run() outputs "first". Do not change or remove this line.
        synchronized (this){
            while (step != 1){
                this.wait();
            }
        }
        printFirst.run();
        synchronized (this) {
            step = 2;
            this.notifyAll();
        }
    }

    public void second(Runnable printSecond) throws InterruptedException {
        // printSecond.run() outputs "second". Do not change or remove this line.
        synchronized (this){
            while (step != 2){
                this.wait();
            }
        }
        printSecond.run();
        synchronized (this) {
            step = 3;
            this.notifyAll();
        }
    }

    public void third(Runnable printThird) throws InterruptedException {
        // printThird.run() outputs "third". Do not change or remove this line.
        synchronized (this){
            while (step != 3){
                this.wait();
            }
        }
        printThird.run();
        synchronized (this) {
            step = 1;
            this.notifyAll();
        }
    }
}

第二种方法：

public class Foo2 {
    private volatile int step = 1;

    public Foo2() {
    }

    public void first(Runnable printFirst) throws InterruptedException {
        // printFirst.run() outputs "first". Do not change or remove this line.
        while (true) {
            synchronized (this) {
                if (step == 1) {
                    break;
                }
            }
            Thread.yield();
        }
        printFirst.run();
        synchronized (this) {
            step = 2;
        }
    }

    public void second(Runnable printSecond) throws InterruptedException {
        // printSecond.run() outputs "second". Do not change or remove this line.
        while (true) {
            synchronized (this) {
                if (step == 2) {
                    break;
                }
            }
            Thread.yield();
        }
        printSecond.run();
        synchronized (this) {
            step = 3;
        }
    }

    public void third(Runnable printThird) throws InterruptedException {
        // printThird.run() outputs "third". Do not change or remove this line.

        while (true) {
            synchronized (this) {
                if (step == 3) {
                    break;
                }
            }
            Thread.yield();
        }
        printThird.run();
        synchronized (this) {
            step = 1;
        }
    }
}