Confused about the "Print in Order" problem on LeetCode

This should be an easy problem on multithreading: https://leetcode.com/problems/print-in-order/
"The same instance of Foo will be passed to three different threads. Thread A will call first(), thread B will call second(), and thread C will call third(). Design a mechanism and modify the program to ensure that second() is executed after first(), and third() is executed after second()" And they give this code:

public Foo() {}
    public void first(Runnable printFirst) throws InterruptedException {
        // printFirst.run() outputs "first". Do not change or remove this line.
        printFirst.run();
    }
    public void second(Runnable printSecond) throws InterruptedException {
        // printSecond.run() outputs "second". Do not change or remove this line.
        printSecond.run();
    }
    public void third(Runnable printThird) throws InterruptedException {
        // printThird.run() outputs "third". Do not change or remove this line.
        printThird.run();
    }

**Seems I can solve it using Thread.join as below, but what I don't understand is why they pass the instance of Runnable to each method, and how to properly do it because the below code will print each message twice - once because Thread.start() will invoke the corresponding run() method, and once from calling that method directly. I understand that this is the wrong way to do it, but can't figure out what is the right solution, if we try to utilize the join method. **

public Foo() throws InterruptedException {
		Runnable r1 = () -> {
			System.out.println("first ");
		};
		first(r1);
		
		Runnable r2 = () -> {
			System.out.println("second ");
		};
		second(r2);
		
		Runnable r3 = () -> {
			System.out.println("third ");
		};
		third(r3);
		
		Thread t1 = new Thread(r1);
		t1.start();
		try {
			t1.join(); // wait for this thread to finish before starting #2
		}
		catch(Exception e) {
			System.err.println("Thread 1 error");
		}
		
		Thread t2 = new Thread(r2);
		t2.start();
		
		try {
			t2.join();
		}
		catch(Exception e) {
			System.err.println("Thread 2 error");
		}
		
		Thread t3 = new Thread(r3);
		t3.start();
		
		try {
			t3.join();
		}
		catch(Exception e) {
			System.err.println("Thread 3 error");
		}
	}```

</details>


# 答案1
**得分**: 3

一个更简单的方法是只使用`Semaphore`以及其中的`run`、`acquire`、`release`方法：

```java
class Foo {
    Semaphore runSecond;
    Semaphore runThird;

    public Foo() {
        runSecond = new Semaphore(0);
        runThird = new Semaphore(0);
    }

    public void first(Runnable printFirst) throws InterruptedException {
        printFirst.run();
        runSecond.release();
    }

    public void second(Runnable printSecond) throws InterruptedException {
        runSecond.acquire();
        printSecond.run();
        runThird.release();
    }

    public void third(Runnable printThird) throws InterruptedException {
        runThird.acquire();
        printThird.run();
    }
}

class Foo {
    Semaphore runSecond;
    Semaphore runThird;

    public Foo() {
        runSecond = new Semaphore(0);
        runThird = new Semaphore(0);
    }

    public void first(Runnable printFirst) throws InterruptedException {
        printFirst.run();
        runSecond.release();
    }

    public void second(Runnable printSecond) throws InterruptedException {
        runSecond.acquire();
        printSecond.run();
        runThird.release();
    }

    public void third(Runnable printThird) throws InterruptedException {
        runThird.acquire();
        printThird.run();
    }
}

答案2

得分: 2

Leetcode 用于代码挑战，所以我们不应该提供完整的解决方案，因为那样对你来说就不会是一个挑战了。

这里有一个提示： 使用两个 CountDownLatch 对象，一个用于通知 second() 方法已经完成了 first() 方法，另一个用于通知 third() 方法已经完成了 second() 方法。阅读 文档 以了解如何使用它。

当你阅读文档时，我建议你阅读 包文档，以了解有关处理多线程代码的可用功能的更多信息。

更新

为了更好地理解这个挑战，假设 Leetcode 使用了类似这样的类来测试 Foo 类。

public class Test {
    public static void main(String[] args) throws Exception {
        Foo foo = new Foo();
        Thread t1 = new Thread(() -> call(foo::first, "first,"));
        Thread t2 = new Thread(() -> call(foo::second, "second,"));
        Thread t3 = new Thread(() -> call(foo::third, "third."));

        // 以无序的方式启动线程，并在它们之间添加延迟，以便每个线程有足够的时间来完成，如果没有足够的编码来确保执行顺序。
        t2.start();
        Thread.sleep(500);
        t3.start();
        Thread.sleep(500);
        t1.start();

        // 等待线程完成
        t2.join();
        t3.join();
        t1.join();

        // 在这一点上，程序的输出应该是 "first,second,third."
    }
    interface FooMethod {
        public void call(Runnable printFirst) throws InterruptedException;
    }
    private static void call(FooMethod method, String text) {
        try {
            method.call(() -> System.out.print(text));
        } catch (InterruptedException e) {
            System.out.println(e);
        }
    }
}

你不能修改这段代码，因为它对你是隐藏的。你必须在 Foo 类中添加一些代码，以确保这 3 个 Runnable 对象按正确的顺序被调用。

简单地向这 3 个方法中添加 Thread.sleep() 调用并不是正确的解决方案，因为无论在测试下面的线程启动之间添加了多长的延迟，这段代码都应该正常运行。

你必须使用某种形式的线程同步特性，例如 monitors、Locks 或 Synchronizers。

public class Test {
	public static void main(String[] args) throws Exception {
		Foo foo = new Foo();
		Thread t1 = new Thread(() -> call(foo::first, "first,"));
		Thread t2 = new Thread(() -> call(foo::second, "second,"));
		Thread t3 = new Thread(() -> call(foo::third, "third."));
		
		// Start threads out of order, with delay between them, giving each thread
		// enough time to complete, if not adequately coded to ensure execution order.
		t2.start();
		Thread.sleep(500);
		t3.start();
		Thread.sleep(500);
		t1.start();
		
		// Wait for threads to complete
		t2.join();
		t3.join();
		t1.join();
		
		// At this point, the program output should be "first,second,third."
	}
	interface FooMethod {
		public void call(Runnable printFirst) throws InterruptedException;
	}
	private static void call(FooMethod method, String text) {
		try {
			method.call(() -> System.out.print(text));
		} catch (InterruptedException e) {
			System.out.println(e);
		}
	}
}