Java 如何为两个不同的线程使用CountDownLatch每个线程都具有相同的可运行类

如何为两个不同的线程使用

condownlatch

，每个线程都具有相同的可运行类？？我希望FICS和FICS_R7具有相同的可运行类FICS，但当FICS_R3完成时，FICS_R7将启动

我该怎么做呢

代码：

    public FICSFilter(Mat bgrMat, int csRadius) {
        // TODO Auto-generated constructor stub
        this.bgrMat = bgrMat;
        this.csRadius = csRadius;

        CountDownLatch latch = new CountDownLatch(1);

        this.fiCS_R3 = new Thread(new FICS(this.bgrMat, 3), "FICS_R" + this.csRadius);
        fiCS_R3.start();

        this.fiCS_R3 = new Thread(new FICS(this.bgrMat, 7), "FICS_R" + this.csRadius);
        fiCS_R7.start();

        //How to use the CounDownLatch for two different threads each of them has the same runnable class
        }

    private class FICS implements Runnable {

    private Mat bgrMat;
    private int csRadius;

    public FICS(Mat bgrMat, int csRadius) {
        // TODO Auto-generated constructor stub
        this.bgrMat = bgrMat;
        this.csRadius = csRadius;
    }

    public void run() {
        // TODO Auto-generated method stub
        calcFICS(this.bgrMat, this.csRadius);
    }

    public static void calcFICS(Mat bgrMat, int csRadius) {
    // TODO Auto-generated method stub

    ArrayList<Mat> onOffCSActRegMatsList = null;
    ArrayList<Mat> offOnCSActRegMatsList = null;

    ArrayList<Mat> onOffCSFullMatsList = null;
    ArrayList<Mat> offOnCSFullMatsList = null;

    onOffCSActRegMatsList = new ArrayList<Mat>();
    offOnCSActRegMatsList = new ArrayList<Mat>();

公共FICSFilter（Mat bgrMat，int csRadius）{
//TODO自动生成的构造函数存根
this.bgrat=bgrat；
this.csRadius=csRadius；
CountDownLatch闩锁=新的CountDownLatch（1）；
this.fiCS_R3=新螺纹（新fiCS（this.bgrat，3），“fiCS_R”+此.csRadius）；
fiCS_R3.start（）；
this.fiCS_R3=新螺纹（新fiCS（this.bgrat，7），“fiCS_R”+此.csRadius）；
fiCS_R7.start（）；
//如何为两个不同的线程使用ConcountDownLatch每个线程都具有相同的可运行类
}
私有类FICS实现可运行{
私人Mat bgrMat；
私人互联网半径；
公共FICS（Mat bgrMat、int csRadius）{
//TODO自动生成的构造函数存根
this.bgrat=bgrat；
this.csRadius=csRadius；
}
公开募捐{
//TODO自动生成的方法存根
calcFICS（this.bgrat，this.csRadius）；
}
公共静态空隙计算（材料边界、内部半径）{
//TODO自动生成的方法存根
ArrayList onOffCSActRegMatsList=null；
ArrayList offOnCSActRegMatsList=null；
ArrayList onOffCSFullMatsList=null；
ArrayList offOnCSFullMatsList=null；
onOffCSActRegMatsList=新的ArrayList（）；
offOnCSActRegMatsList=newarraylist（）；
给定类型为
Runnable
的两个引用
r1
和
r2
（注意
r1
也可以等于
r2
），很容易按顺序运行它们，因此
r1
发生在
r2
之前：

r1.run();
r2.run(); // will start when r1 has finished

这种技术称为“顺序执行”，允许您重用运行
r1
（当前执行线程）的线程对于以后运行
r2
，无需任何线程同步机制，如
倒计时闩锁
，如果出于某种原因，您有义务使用
倒计时闩锁
执行该任务。诀窍是第一个线程必须在不等待闩锁的情况下运行，然后减少其计数器，第二种方法必须等待闩锁。有很多种方法可以实现细节，但这里有一种：

class FICSFilter {
    Mat bgrMat;
    int csRadius;

    public FICSFilter(Mat bgrMat, int csRadius) {
        this.bgrMat = bgrMat;
        this.csRadius = csRadius;
    }

    public void doFilter() {
        CountDownLatch openLatch = new CountDownLatch(0);
        CountDownLatch latch = new CountDownLatch(1);
        Thread fiCS_R3_Thread = new Thread(
                new FICS(3, openLatch, latch), "FICS_R3");
        Thread fiCS_R7_Thread = new Thread(
                new FICS(7, latch, latch), "FICS_R7");

        fiCS_R3.start();
        fiCS_R7.start();
        fics_R7.join();
    }

    private class FICS implements Runnable {

        private Mat bgrMat;
        private int csRadius;
        private CountDownLatch startLatch;
        private CountDownLatch signalLatch;

        public FICS(int csRadius, CountDownLatch startLatch,
                CountDownLatch signalLatch) {
            this.bgrMat = FICSFilter.this.bgrMat; // for clarity only
            this.csRadius = csRadius;
            this.startLatch = startLatch;         // assumed non-null
            this.signalLatch = signalLatch;       // assumed non-null
        }

        public void run() {
            startLatch.await();

            // ... perform the calculation ...

            signalLatch.countDown();
        }
    }
}

但是，如果您只需要按顺序运行作业，而
CountDownLatch
只是实现这一点的一个想法，那么这是一个非常好的解决方案：

class FICSFilter {
    Mat bgrMat;

    public FICSFilter(Mat bgrMat) {
        this.bgrMat = bgrMat;
    }

    public void doFilter() {
        Runnable fiCS_R3 = new FICS(this.bgrMat, 3);
        Runnable fiCS_R7 = new FICS(this.bgrMat, 7);

        fiCS_R3.run();
        fiCS_R7.run();
    }

    private class FICS implements Runnable {
        // As originally written ...
    }
}

倒计时闩锁
的主要目的是实现检查点，即希望多个线程在工作中都达到同一点，然后再继续。在这种情况下，您可以使用线程数初始化闩锁，在检查点处，每个线程首先递减闩锁，然后等待：

latch.countDown();
latch.await();

该构造可以应用于其他任务，例如您询问的任务，但对于某些任务来说，它比其他任务更自然。对于您的特定任务来说，它非常不自然。
导入java.util.ArrayList；
导入java.util.concurrent.CountDownLatch

公共类FICSFilter{

Mat bgrMat;
int csRadius;


public FICSFilter(Mat bgrMat, int csRadius) {
    this.bgrMat = bgrMat;
    this.csRadius = csRadius;
    //How to use the CounDownLatch for two different threads each of them has the same runnable class
}

public static void main(String args[]){

    // CountDownLatch startLatch = new CountDownLatch(1);

    CountDownLatch doneLatch = new CountDownLatch(1);

    Mat lbgrmat = new Mat();

    Thread fiCS_R3 = new Thread(new FICS(lbgrmat, 10, doneLatch));
    Thread fiCS_R7 = new Thread(new FICS(lbgrmat, 20, null));

    fiCS_R3.start();

    try {
        System.out.println("\n Going into block state in main");
        doneLatch.await();
        System.out.println("\n Out of block state in main");

    } catch (InterruptedException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }
    fiCS_R7.start();
}

}

类FICS实现可运行{

CountDownLatch doneSignal;

Mat bgrMat;
int csRadius;

public FICS(Mat bgrMat, int csRadius, CountDownLatch llatch ) {
    this.bgrMat = bgrMat;
    this.csRadius = csRadius;
    this.doneSignal = llatch;
}

public void run() {
    calcFICS(this.bgrMat, this.csRadius);

}

public void calcFICS(Mat bgrMat, int csRadius)   {
    System.out.println("\n Radius : " + csRadius + " Thread : "+ Thread.currentThread().getName());
    try {
        Thread.sleep(5000);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    if (doneSignal != null )
        doneSignal.countDown();
}

}

上述代码在主线程中的锁存器上阻塞，并且只有当第一个线程FICS3执行其工作并释放锁存器时，主线程才会执行此操作
启动下一个线程。
如果不希望线程同时运行，那么使用线程有什么意义？@JohnBollinger我希望线程同时运行，但我想在上述情况下使用倒计时锁存器。或者换句话说，当第一个线程完成后，第二个线程应该开始解释这两句话“我希望它们同时运行”和“当fiCS_R3完成fiCS_R7启动时”“一起去吧。@realponsignist噢，对不起……我刚才说并发是因为如果我没有弄错的话，我知道countDownLatch是一种并发技术……但在我的问题中，我想使用countDownLatch……是否可能使用倒计时闩锁可能是可能的，但它很愚蠢。要连续运行两个作业，只需执行它们的
run（）
方法在主线程中按顺序排列。