Ndtyjky

I have 1,2,3 threads each have A,B,C sections to run sequentially like
1A, 2A, 3A, 1B, 2B, 3B, 1C, 2C, 3C. So after 1A finishes its run it waits for the signal of thread 3 to continue with its section B and so on. How could I achieve this? I have to reuse the threads so I cannot make threads from sections.

That's the job of a CyclicBarrier:

public class BarrierDemo {

    public static void main(String args) {

        CyclicBarrier barrier = new CyclicBarrier(3); // three threads



        new Thread(new Task(1, barrier)).start();

        new Thread(new Task(2, barrier)).start();

        new Thread(new Task(3, barrier)).start();

    }



    private static class Task implements Runnable {

        private final int number;

        private final CyclicBarrier barrier;



        public Task(int number, CyclicBarrier barrier) {

            this.number = number;

            this.barrier = barrier;

        }



        @Override

        public void run() {

            try {

                System.out.println(number + "A");

                barrier.await();

                System.out.println(number + "B");

                barrier.await();

                System.out.println(number + "C");

            }

            catch (InterruptedException e) {

                Thread.currentThread().interrupt();

            }

            catch(BrokenBarrierException e) {

                // too bad

            }

        }

    }

}

if order of 1,2,3 is not important , but order of all A,all B,all C is important, Then,
use 2 CountDownLatch.
you can start A section directly . when A section is done count down the CountDownLatch.

before B section starts await() the CountDownLatch.

so there should be 2 CountDownLatch latches to synchronize section B and section C.

    public class Test extends Thread

{



  CountDownLatch cdlA;

  CountDownLatch cdlB;

  int threadId;



  public Test(CountDownLatch cdlA, CountDownLatch cdlB,int threadNumber)

  {

    this.cdlA = cdlA;

    this.cdlB = cdlB;

    threadId = threadNumber;

  }



  @Override

  public void run()

  {

    test();

  }



  private   void test()

  {

    try

    {

      System.out.println("section A" +threadId);

      cdlA.countDown();



      cdlA.await();



      System.out.println("section B" +threadId);

      cdlB.countDown();



      cdlB.await();



      System.out.println("section C" +threadId);

    }

    catch (InterruptedException e)

    {



    }



  }



  public static void main(String args) throws InterruptedException

  {

    CountDownLatch a = new CountDownLatch(3);

    CountDownLatch b = new CountDownLatch(3);



    final Test test1 = new Test(a, b,1);



    final Test test2 = new Test(a, b,2);



    final Test test3 = new Test(a, b,3);



    test1.start();

    test2.start();

    test3.start();

  }

}

If you have a delegate that knows what to do then you can use an executor service to control execution. Eg. create an executors service for each thread, submit, then use Future.get to wait for the execution completes.

The otherway is to use a sort of ball.

static public void task(int no){

    System.out.println("task " + no + " on " + Thread.currentThread().getName());

}



public static void main(String args) throws Exception{

    BlockingQueue<Object> permissions = new ArrayBlockingQueue<>(1);



    var A = new Thread(){

        BlockingQueue<Object> waiting = new ArrayBlockingQueue<>(1);

        public void run(){

            for(int i = 0; i<3; i++){

                Object ball = null;

                try{

                    ball = waiting.take();

                    task(i);

                } catch(InterruptedException e){

                    throw new RuntimeException(e);

                }finally{

                    permissions.offer(ball);

                }

            }

        }

    };



    var B = new Thread(){

        BlockingQueue<Object> waiting = new ArrayBlockingQueue<>(1);

        public void run(){

            for(int i = 0; i<3; i++){

                Object ball = null;

                try{

                    ball = waiting.take();

                    task(i);

                } catch(InterruptedException e){

                    throw new RuntimeException(e);

                }finally{

                    permissions.offer(ball);

                }

            }

        }

    };



    A.start();

    B.start();

    Object ball = new Object();

    A.waiting.offer(ball);

    ball = permissions.take();

    B.waiting.offer(ball);

    ball = permissions.take();

    A.waiting.offer(ball);

    ball = permissions.take();

    B.waiting.offer(ball);

    ball = permissions.take();

    A.waiting.offer(ball);

    ball = permissions.take();

    B.waiting.offer(ball);

    ball = permissions.take();

    System.out.println("finished");

There are definitely better ways, I think you can see this is not extensible, you have to know the number of tasks. There is no actuall purpose for the Object ball, and a new Object(); could be used, or even null.

Here is my solution for the problem. I think the idea behind it is close to matt's solution. Thank you for all you guys.

 @Test

void test() throws InterruptedException {

    ExecutorService executor = Executors.newFixedThreadPool(3);

    SynchronousQueue<Integer> chromeQueue = new SynchronousQueue<>();

    SynchronousQueue<Integer> firefoxQueue = new SynchronousQueue<>();

    SynchronousQueue<Integer> ieQueue = new SynchronousQueue<>();



    Runnable ieRunnable = () -> {

        try {

            firefoxQueue.take();

            System.out.println("ieRunnable section 1");

            ieQueue.put(1);

            firefoxQueue.take();

            System.out.println("ieRunnable section 2");

        } catch (InterruptedException e) {

            Thread.currentThread().interrupt();

        }

    };



    Runnable firefoxRunnable = () -> {

        try {

            chromeQueue.take();

            System.out.println("firefoxRunnable section 1");

            firefoxQueue.put(1);

            chromeQueue.take();

            System.out.println("firefoxRunnable section 2");

            firefoxQueue.put(1);

        } catch (InterruptedException e) {

            e.printStackTrace();

        }

    };



    Runnable chromeRunnable = () -> {

        try {

            ieQueue.take();//waits    

            System.out.println("chromeRunnable section 1");

            chromeQueue.put(1);//starts firefoxRunnable

            ieQueue.take();//wait for ieRunnable to signal

            System.out.println("chromeRunnable section 2");

            chromeQueue.put(1);//makes firefoxRunnable to continue

        } catch (InterruptedException e) {

            e.printStackTrace();

        }

    };

    executor.execute(chromeRunnable);

    executor.execute(firefoxRunnable);

    executor.execute(ieRunnable);

    ieQueue.put(1);

    executor.shutdown();

    try {

        if (!executor.awaitTermination(5, TimeUnit.MINUTES)) {

            executor.shutdownNow();

        }

    } catch (InterruptedException e) {

        executor.shutdownNow();

    }

}