Java 为什么SynchronousQueue允许其他线程以随机顺序执行？

我正在尝试实现一个小程序，它将使用SynchronousQueue按升序排序整数数组/向量

我采用的方法是创建一个线程池，每个线程只按升序对元素排序一次，方法是迭代元素，比较位置I和I+1上的元素并交换它们

因此，我创建了一个执行此交换的类，并将迭代数、两个SynchronousQueues和数组本身作为参数，如下所示：

class OrderAsc extends Thread {
int length;
int iteration;
SynchronousQueue<ArrayList> st, dr; 
ArrayList<Integer> vector;
boolean swapMade;

    OrderAsc( int iteration, SynchronousQueue<ArrayList> st, SynchronousQueue<ArrayList> dr, ArrayList<Integer> vector) throws InterruptedException{

        this.length = vector.size();
        this.st = st;
        this.dr = dr;
        this.vector = vector;
        this.iteration = iteration;
        this.swapMade = false;
    }

    // Rularea thread-ului
    @Override
    public void run(){

        if(iteration > 0){

            try {
                vector = st.take();
                System.out.println(iteration + " get " + vector);
            } catch (InterruptedException ex) {
                System.out.println(ex);
            }
        }

        // System.out.println(iteration + " >>> " + vector);


        for(int i = 0; i < length-1; i++){
            if(vector.get(i) > vector.get(i+1)){

                int tmp = vector.get(i);
                vector.set(i, vector.get(i+1));
                vector.set(i+1, tmp);

                swapMade = true;
            }
        }

        if(swapMade){
            try {

                dr.put(vector);
                System.out.println(iteration + " put " + vector);
            } catch (InterruptedException ex) {
                System.out.println(ex);
            }
        } else { 
            // Display result
            System.out.println(vector);
        }
        System.exit(0);

    }

}

ArrayList<OrderAsc> orderFilter = new ArrayList<OrderAsc>(n+2);
            for(int i = 0; i < n + 2; i++){
                orderFilter.add(i, new OrderAsc(i, st, dr, vector));
                st = dr;
                dr = new SynchronousQueue<ArrayList>();                    

            }

            for(int i=0; i < n + 2; i++){
                orderFilter.get(i).setDaemon(true);
                orderFilter.get(i).start();
            }

---

SynchronousQueue是否有另一种工作方式，而我的实现是错误的？

我尝试用一个同步队列重写您的程序。。。 简言之，线程0放入初始未排序向量并 其余线程开始以迭代方式排序

import java.util.ArrayList;
import java.util.concurrent.SynchronousQueue;


class OrderAsc extends Thread {
    int length;
    int iteration;
    SynchronousQueue<ArrayList> st, dr; 
    ArrayList<Integer> vector;
    boolean swapMade;

    OrderAsc( int iteration, SynchronousQueue<ArrayList> st, SynchronousQueue<ArrayList> dr, ArrayList<Integer> vector) throws InterruptedException{
        this.length = vector.size();
        this.st = st;
        this.dr = dr;
        this.vector = vector;
        this.iteration = iteration;
        this.swapMade = false;
    }

    @Override
    public void run(){

        if ( iteration == 0 ){
            try {

                System.out.println("\n  " + iteration  + " put " + vector);

                st.put(vector);

                Thread.currentThread().interrupt();
                return;
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
        else{

            try {
                vector = st.take();
                // System.out.println("\n Take in Thread : " + Thread.currentThread().getName());
                System.out.println(iteration + " take " + vector);
            } catch (InterruptedException ex) {
                System.out.println(ex);
            }

        } 


        for(int i = 0; i < vector.size() - 1; i++){

            if(vector.get(i) > vector.get(i+1)){
                int tmp = vector.get(i);
                vector.set(i, vector.get(i+1));
                vector.set(i+1, tmp);

                swapMade = true;
            }

        }


        if(swapMade){
                //System.out.println("\n Swap Done in  Thread : " + Thread.currentThread().getName());

            try {
                st.put(vector);

                System.out.println(iteration + " sorted " + vector);

            } catch (InterruptedException ex) {
                System.out.println(ex);
            }
        }  

        //System.out.println("\n Exiting Thread : " + Thread.currentThread().getName());
        // System.exit(0);

    }


    public static void main(String args[]){
        ArrayList<OrderAsc> orderFilter = new ArrayList<OrderAsc>(5);

        ArrayList<Integer> vector = new ArrayList<Integer>(6);
        vector.add(4);
        vector.add(1);
        vector.add(3);
        vector.add(5);
        vector.add(6);
        vector.add(2);


        System.out.println("\n Unsorted Array " + vector + "\n\n");

        int n = vector.size();

        //vector.add(1);
        //vector.add(5);

        SynchronousQueue<ArrayList> st1 = new SynchronousQueue<ArrayList>();
        SynchronousQueue<ArrayList> dr1 = new SynchronousQueue<ArrayList>();

        for(int i = 0; i < n ; i++){
            try {

                orderFilter.add(i, new OrderAsc(i, st1, dr1, vector));

            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            //st1 = dr1;
            //dr1 = new SynchronousQueue<ArrayList>();                    
        }

        for(int i=0; i < n - 1; i++){
            //orderFilter.get(i).setDaemon(true);
             orderFilter.get(i).start();
        }


        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

        System.out.println("\n Voila Thanks Threads and the  Sorted Array Is ");

        for(int i = 0; i < vector.size(); i++){
            System.out.print(" " + vector.get(i) +  " ");
        }   

    }

}

import java.util.ArrayList；
导入java.util.concurrent.SynchronousQueue；
类OrderAsc扩展线程{
整数长度；
整数迭代；
同步队列st，dr；
阵列列表向量；
布尔交换码；
OrderAsc（int迭代、SynchronousQueue st、SynchronousQueue dr、ArrayList vector）抛出InterruptedException{
this.length=vector.size（）；
this.st=st；
this.dr=dr；
这个向量=向量；
this.iteration=迭代；
this.swapMade=false；
}
@凌驾
公开募捐{
如果（迭代==0）{
试一试{
System.out.println（“\n”+迭代+“put”+向量）；
圣普特（矢量）；
Thread.currentThread（）.interrupt（）；
返回；
}捕捉（中断异常e）{
//TODO自动生成的捕捉块
e、 printStackTrace（）；
}
}
否则{
试一试{
向量=圣塔克（）；
//System.out.println（“\n接收线程：”+Thread.currentThread（）.getName（））；
System.out.println（迭代+取+向量）；
}捕获（中断异常例外）{
系统输出打印项次（ex）；
}
} 
对于（int i=0；ivector.get（i+1））{
int tmp=vector.get（i）；
vector.set（i，vector.get（i+1））；
向量集（i+1，tmp）；
swapMade=true；
}
}
if（swapMade）{
//System.out.println（“\n在线程中完成交换：”+Thread.currentThread（）.getName（））；
试一试{
圣普特（矢量）；
System.out.println（迭代+排序+向量）；
}捕获（中断异常例外）{
系统输出打印项次（ex）；
}
}  
//System.out.println（“\n退出线程：”+Thread.currentThread（）.getName（））；
//系统出口（0）；
}
公共静态void main（字符串参数[]）{
ArrayList orderFilter=新的ArrayList（5）；
ArrayList向量=新的ArrayList（6）；
向量。添加（4）；
向量。添加（1）；
向量。添加（3）；
向量。添加（5）；
向量。添加（6）；
向量。添加（2）；
System.out.println（“\n未排序数组”+vector+”\n\n”）；
int n=vector.size（）；
//向量。添加（1）；
//向量。添加（5）；
SynchronousQueue st1=新的SynchronousQueue（）；
SynchronousQueue dr1=新的SynchronousQueue（）；
对于（int i=0；i

您想做什么？您似乎有一个线程链，其中每个线程对两个元素进行一次交换。我想你想要一些低效的东西，这样你就可以看到线程如何处理队列了？@PeterLawrey是的，我想要一些低效的东西来看看线程如何工作。在每次迭代中，我都会交换元素，这将是ASC sortTricky程序的下一次迭代……我注意到您正在尝试对不同的Synque类型对象进行“put”和“take”……您是否尝试过单个Synque程序……我尝试过使用单个synchronousqueue，但似乎每次都会触发线程，而且它们不会像预期的那样等待从队列中读/写。他们只是随机地做。顺便说一句……老实说……没有太多的重写……实际上是你的代码，除了synchroqueue dr现在已经失效……而thread-0 ie第一次迭代只将未排序的arraylist放入队列对象中，并让剩下的线程开始排序……顺便说一句……编码不错……不错问题…帮助我理解了同步队列的概念

import java.util.ArrayList;
import java.util.concurrent.SynchronousQueue;


class OrderAsc extends Thread {
    int length;
    int iteration;
    SynchronousQueue<ArrayList> st, dr; 
    ArrayList<Integer> vector;
    boolean swapMade;

    OrderAsc( int iteration, SynchronousQueue<ArrayList> st, SynchronousQueue<ArrayList> dr, ArrayList<Integer> vector) throws InterruptedException{
        this.length = vector.size();
        this.st = st;
        this.dr = dr;
        this.vector = vector;
        this.iteration = iteration;
        this.swapMade = false;
    }

    @Override
    public void run(){

        if ( iteration == 0 ){
            try {

                System.out.println("\n  " + iteration  + " put " + vector);

                st.put(vector);

                Thread.currentThread().interrupt();
                return;
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
        else{

            try {
                vector = st.take();
                // System.out.println("\n Take in Thread : " + Thread.currentThread().getName());
                System.out.println(iteration + " take " + vector);
            } catch (InterruptedException ex) {
                System.out.println(ex);
            }

        } 


        for(int i = 0; i < vector.size() - 1; i++){

            if(vector.get(i) > vector.get(i+1)){
                int tmp = vector.get(i);
                vector.set(i, vector.get(i+1));
                vector.set(i+1, tmp);

                swapMade = true;
            }

        }


        if(swapMade){
                //System.out.println("\n Swap Done in  Thread : " + Thread.currentThread().getName());

            try {
                st.put(vector);

                System.out.println(iteration + " sorted " + vector);

            } catch (InterruptedException ex) {
                System.out.println(ex);
            }
        }  

        //System.out.println("\n Exiting Thread : " + Thread.currentThread().getName());
        // System.exit(0);

    }


    public static void main(String args[]){
        ArrayList<OrderAsc> orderFilter = new ArrayList<OrderAsc>(5);

        ArrayList<Integer> vector = new ArrayList<Integer>(6);
        vector.add(4);
        vector.add(1);
        vector.add(3);
        vector.add(5);
        vector.add(6);
        vector.add(2);


        System.out.println("\n Unsorted Array " + vector + "\n\n");

        int n = vector.size();

        //vector.add(1);
        //vector.add(5);

        SynchronousQueue<ArrayList> st1 = new SynchronousQueue<ArrayList>();
        SynchronousQueue<ArrayList> dr1 = new SynchronousQueue<ArrayList>();

        for(int i = 0; i < n ; i++){
            try {

                orderFilter.add(i, new OrderAsc(i, st1, dr1, vector));

            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            //st1 = dr1;
            //dr1 = new SynchronousQueue<ArrayList>();                    
        }

        for(int i=0; i < n - 1; i++){
            //orderFilter.get(i).setDaemon(true);
             orderFilter.get(i).start();
        }


        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

        System.out.println("\n Voila Thanks Threads and the  Sorted Array Is ");

        for(int i = 0; i < vector.size(); i++){
            System.out.print(" " + vector.get(i) +  " ");
        }   

    }

}