等待同步块的线程的执行顺序

Question

>我有一些线程正在运行，并且都试图进入同步块。

我注意到线程以随机顺序运行（当我调用 Thread.start（） 时），没关系

当第一个线程执行并进入同步方法时，它会进入睡眠状态。

在此期间，其他线程来了并开始等待同步块被释放。

我的问题是等待的最后一个线程首先获取同步块。

以下是代码。

 import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import javax.sql.rowset.Joinable;

public class ThreadOrdering{  public static void main(String... args) {
    Results results = new Results();
    Thread a=   new Thread(new Task(0, "red", results));
    a.start();
    Thread b=  new Thread(new Task(1, "orange", results));
    b.start();
    Thread c=    new Thread(new Task(2, "yellow", results));
    c.start();
    Thread d= new Thread(new Task(3, "green", results));
    d.start();
    Thread e= new Thread(new Task(4, "blue", results));
    e.start();

}
}
class Results {
private List<String> results = new ArrayList<String>();
private int i = 0;
public synchronized void submit(int order, String result) {
     System.out.println("synchronized accupied by: " + order + " " + result);
       try {
        Thread.sleep((long)(Math.random() *1000));
         System.out.println("synchronized released by: " + order + " " + result);
    } catch (InterruptedException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }

}
}

class Task implements Runnable {
private final int order;
private final String result;
private final Results results;
public Task(int order, String result, Results results) {
    this.order = order;
    this.result = result;
    this.results = results;
}
public void run() {
     System.out.println("run  by: " + order + " " + result);
    results.submit(order, result);
}
}

示例输出为：

运行者： 1 橙子

同步累积：1 个橙色

运行方式： 2 黄色

运行者： 4 蓝色

运行方式： 0 红色

运行者： 3 绿色

同步发布者：1 橙色

同步设置：3 绿色

同步发布者：3

绿色

同步累积者：0 红色

同步发布者： 0 红色

同步配置：4 蓝色

同步发布者： 4 蓝色

同步配置：2 黄色

同步发布者：2黄色

正如我们所看到的，线程执行的顺序是随机的..没关系.. 1 2 4 0 3

所以 1 得到同步块，在它结束之后 3（最后一个）得到它，然后 0 和 4 和 2....

如何使该顺序颠倒,,,在 1 之后它必须是 2 然后是 4 然后是 0 然后是 3

Answer 1

如果你想公平地访问同步块，你应该使用ReentrantLock。

Answer 2

我的问题是最后一个线程在等待同步 先阻止？

简短的回答是否定的。

多线程机制不提供管理唤醒顺序的这种能力。这取决于许多因素，哪个线程被唤醒以及以什么顺序被唤醒。您必须手动管理它。创建一些共享变量或堆栈，如果线程还不能工作 - 大喊大叫并等到下次它有控制权时。然后再做一次，直到时间/顺序正确。