Question

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

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

当第一个Thread执行并进入同步方法时，它会进入休眠状态..

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

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

以下是代码。

 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

如果您希望公平访问synchronized块，则应使用ReentrantLock。

Answer 2

我的问题是等待的最后一个线程获得同步阻止第一个？

简短回答是否。

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

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

2 个答案: