java中的循环屏障

我有一个需要由三方（比如线程）填充的列表。我使用循环屏障来实现这个功能。一切都很好，除了我不能使用结果列表而不引起强迫睡眠。代码如下：

public class Test{

List<Integer> item = new Vector<Integer>();

public void returnTheList(){
       CyclicBarrier cb = new CyclicBarrier(3, new Runnable() {

                @Override
                public void run() {

                    System.out.println("All parties are arrived at barrier, lets play -- : " + CyclicBarrierTest.getTheList().size());
                    //Here I am able to access my resulted list

                }
            });


            CyclicBarrierTest sw1 = new CyclicBarrierTest(cb, new ZetaCode(1500), s);
            CyclicBarrierTest sw2 = new CyclicBarrierTest(cb, new ZetaCode(1500),s);
            CyclicBarrierTest sw3 = new CyclicBarrierTest(cb, new ZetaCode(1500),s);
            Thread th1 = new Thread(sw1, "ZetaCode1");
            Thread th2 = new Thread(sw2, "ZetaCode2");
            Thread th3 = new Thread(sw3, "ZetaCode3");
            th1.start();
            th2.start();
            th3.start();

    }

public static void main(String args[]){
    System.out.println("asdfasd");
    Test test = new Test();
    //ActionClass ac = new ActionClass();
    test.returnTheList();
    System.out.println("Inside the main method...size of the final list : " +test.item.size() );
}

公共类测试{
列表项=新向量（）；
公共无效返回列表（）{
CyclicBarrier cb=新的CyclicBarrier（3，新的可运行（）{
@凌驾
公开募捐{
println（“各方都到了障碍，让我们来玩——：”+CyclicBarrierTest.getTheList（）.size（））；
//在这里，我可以访问我的结果列表
}
});
CyclicBarrierTest sw1=新的CyclicBarrierTest（cb，新ZetaCode（1500），s）；
CyclicBarrierTest sw2=新的CyclicBarrierTest（cb，新ZetaCode（1500），s）；
CyclicBarrierTest sw3=新的CyclicBarrierTest（cb，新ZetaCode（1500），s）；
螺纹th1=新螺纹（sw1，“ZetaCode1”）；
螺纹th2=新螺纹（sw2，“ZetaCode2”）；
螺纹th3=新螺纹（sw3，“ZetaCode3”）；
th1.start（）；
th2.start（）；
th3.start（）；
}
公共静态void main（字符串参数[]）{
System.out.println（“asdfasd”）；
测试=新测试（）；
//ActionClass ac=新的ActionClass（）；
test.returnTheList（）；
System.out.println（“在主方法内部…最终列表的大小：”+test.item.size（））；
}

下面是我最喜欢的自行车课：

public class CyclicBarrierTest implements Runnable{

private CyclicBarrier barrier;
private Object obj;
 static volatile String s = "";
 volatile List<Integer> finalIntList = new Vector<Integer>();

public CyclicBarrierTest(CyclicBarrier barrier, Object obj, String s){
    this.barrier = barrier;
    this.obj = obj;
}

@Override
public void run(){
    try{
        System.out.println(Thread.currentThread().getName() + " is waiting on barrier and s is now  : " + finalIntList.size());
        ZetaCode simple = (ZetaCode)obj;

        finalIntList.addAll(simple.getTheItemList());
        barrier.await();

        System.out.println(Thread.currentThread().getName() + " has crossed the barrier");

    }catch(InterruptedException ex){
        System.out.println("Error.." + ex.getMessage());

    }catch(Exception e){
        System.out.println("Error.." + e.getMessage());
    }
}
    public  List<Integer> getTheList(){
    return finalIntList;
}

公共类CyclicBarrierTest实现可运行{
私人自行车运载障碍；
私有对象对象；
静态易失性字符串s=“”；
volatile List finalIntList=新向量（）；
公共CyclicBarrierTest（CyclicBarrier屏障、对象obj、字符串s）{
这个障碍=障碍；
this.obj=obj；
}
@凌驾
公开募捐{
试一试{
System.out.println（Thread.currentThread（）.getName（）+）正在等待barrier，而s现在是：“+finalIntList.size（）”；
ZetaCode simple=（ZetaCode）obj；
addAll（simple.getTheItemList（））；
障碍。等待（）；
System.out.println（Thread.currentThread（）.getName（）+“已越过障碍”）；
}捕获（中断异常例外）{
System.out.println（“错误..”+ex.getMessage（））；
}捕获（例外e）{
System.out.println（“错误..”+e.getMessage（））；
}
}
公共列表gethelist（）{
返回最终列表；
}

因此，如果我在没有任何延迟的情况下运行这段代码，我的main方法中的print语句会将我的列表长度设置为零，但是在进行适当的睡眠后，它会给出预期的输出。我希望在没有任何延迟的情况下实现同样的结果。如果有任何帮助，我们将不胜感激。

---

提前感谢。

您似乎想在这里使用一个，而不是

CyclicBarrier

。

CyclicBarrier

完全按照预期工作-您的主方法只是不等待它被所有3个线程触发。当您给它一个sleep语句时，其他3个线程恰好在

main

唤醒一个线程之前完成获得

当您需要

N

工作人员在继续之前到达同一个“检查点”时，

CyclicBarrier

非常有用，而工作人员本身是唯一关心的人。但是，您这里有一个

N+1

用户，即

main

线程，他想知道他们什么时候都完成了，而

CyclicBarrier

没有支持该用例

---

请注意，当然，您也可以同时使用这两个任务。

在这段代码中，我们有4个任务。Task1、Task2、Task3生成int值，Task4将添加所有int值。Task4在为Task1、Task2、Task3调用wait（）生成值后正在等待。当它们生成值时，将调用wait（）方法和任务4将添加它们的值，并打印o/p和调用reset（）方法，以便屏障将重置。重置后，此过程将再次继续

package practice;

import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;

public class CyclicbarrierExample {

    public static void main(String[] args) {

        CyclicBarrier c = new CyclicBarrier(4);
        Task1 t1 = new Task1(c);
        Task2 t2 = new Task2(c);
        Task3 t3 = new Task3(c);
        Task4 t4 = new Task4(c);
        t1.start();
        t2.start();
        t3.start();
        t4.start();
    }
 }


class Task1 extends Thread {
    CyclicBarrier c;
    static int t1 ;

    public Task1(CyclicBarrier c) {
        this.c = c;
    }

    @Override
    public void run() {
        while (true) {
            t1 = t1 + 1;
            try {
                c.await();
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (BrokenBarrierException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    }

}

class Task2 extends Thread {
    CyclicBarrier c;

    static int t2;

    public Task2(CyclicBarrier c) {
        this.c = c;
    }

    @Override
    public void run() {
        while (true) {
            t2 = t2 + 1;
            try {
                c.await();
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (BrokenBarrierException e) {
                e.printStackTrace();
            }
        }
    }

}

class Task3 extends Thread {
    CyclicBarrier c;
    static int t3;

    public Task3(CyclicBarrier c) {
        this.c = c;
    }

    @Override
    public void run() {
        while (true) {
            t3 = t3 + 1;
            try {
                c.await();
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (BrokenBarrierException e) {
                e.printStackTrace();
            }
        }
    }

}

class Task4 extends Thread {
    CyclicBarrier c;
     static int t4;
    static int count=0;

    public Task4(CyclicBarrier c) {
        this.c = c;
    }

    @Override
    public void run() {
        while (count<10) {
            try {
                c.await();
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (BrokenBarrierException e) {
                e.printStackTrace();
            }
            t4 = Task1.t1 + Task2.t2 + Task3.t3;
            System.out.println(t4);
            try {
                c.reset();
            } catch (Exception e) {
                System.out.println("yo");
            }
            count++;

        }
    }

}

包装实践；
导入java.util.concurrent.BrokenBarrierException；
导入java.util.concurrent.CyclicBarrier；
公共类cyclicBarrier示例{
公共静态void main（字符串[]args）{
CyclicBarrier c=新的CyclicBarrier（4）；
Task1 t1=新Task1（c）；
Task2 t2=新Task2（c）；
Task3 t3=新Task3（c）；
Task4 t4=新Task4（c）；
t1.start（）；
t2.start（）；
t3.start（）；
t4.开始（）；
}
}
类Task1扩展线程{
循环载体c；
静态int-t1；
公共任务1（自行车承运人c）{
这个.c=c；
}
@凌驾
公开募捐{
while（true）{
t1=t1+1；
试一试{
c、 等待（）；
睡眠（1000）；
}捕捉（中断异常e）{
e、 printStackTrace（）；
}捕获（断线承运人例外）{
//TODO自动生成的捕捉块
e、 printStackTrace（）；
}
}
}
}
类Task2扩展线程{
循环载体c；
静态int-t2；
公共任务2（自行车承运人c）{
这个.c=c；
}
@凌驾
公开募捐{
while（true）{
t2=t2+1；
试一试{
c、 等待（）；
睡眠（1000）；
}捕捉（中断异常e）{
e、 printStackTrace（）；
}捕获（断线承运人例外）{
e、 printStackTrace（）；
}
}
}
}
类Task3扩展线程{
循环载体c；
静态int-t3；
公共任务3（自行车承运人c）{
这个.c=c；
}
@凌驾
公开募捐{
while（true）{
t3=t3+1；
试一试{
c、 等待（）；
睡眠（1000）；
}捕捉（中断异常e）{
e、 printStackTrace（）；
}捕获（断线承运人例外）{
e、 printStackTrace（）；
}
}
}
}
课堂任务4分机