Bdtjtk

I would like to run thread one after another.
Is there any alternative way to Marathon with Java 8?
Without using ExecuterService:

public class Marathon {



    public static void main(String args) throws InterruptedException {



        Runnable task = () -> {

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



                System.out.println(Thread.currentThread().getName()+ " is running... " + i);

                try {

                    Thread.sleep(200);

                } catch (InterruptedException e) {

                }

            }

        };



        Thread t1 = new Thread(task, "Mary");

        Thread t2 = new Thread(task, "David");

        t1.start();

        t1.join(100);

        t2.start();

    }

}

Output:

Mary is running... 0 

David is running... 0 

Mary is running... 1 

David is running... 1 

...

Following code doesn't work as Marathon :

public class Marathon2 {



    public static void main(String args)

            throws InterruptedException, ExecutionException, TimeoutException {



        ExecutorService service = null;



        Runnable task = () -> {

            try {

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

                    System.out.println(Thread.currentThread().getName()

                            + " is running... " + i);

                }

                TimeUnit.MILLISECONDS.sleep(100);



            } catch (InterruptedException e) {

            }

        };

        try {

            service = Executors.newFixedThreadPool(4);



            Future<?> job1 = service.submit(task);

            job1.get(500, TimeUnit.MILLISECONDS);

            Future<?> job2 = service.submit(task);

        } finally {

            if (service != null)

                service.shutdown();

        }

    }

}

Output:

pool-1-thread-1 is running... 0

...

pool-1-thread-1 is running... 9

pool-1-thread-2 is running... 0

...

pool-1-thread-2 is running... 9

Is it possible to do with ExecuterService?

Expected:

pool-1-thread-1 is running... 0

pool-1-thread-2 is running... 0

...

pool-1-thread-1 is running... 9

pool-1-thread-2 is running... 9

The two classes are not doing the same thing. You can probably reach the solution yourself by comparing them closely. First, do you know exactly how your first class (Marathon) works? In particular, what do you think the following line does?

t1.join(100);

The thread t1, which has just started running, has just gone into a loop which counts up once every 200 milliseconds. The join(100) call simply causes the current (main) thread to wait 100 milliseconds. You will achieve exactly the same results by replacing that line with this one:

Thread.sleep(100);

Now that the main thread has slept for 100 milliseconds, it starts thread t2. Now the two threads are running in parallel, and every 200 milliseconds both threads output a line, the second thread delayed by 100 milliseconds so that they appear evenly interleaved.

Now let's look at your second method, Marathon2. A few differences from the first class are immediately obvious:

1. The sleep in the Runnable is outside the loop, instead of inside.


2. The sleep in the Runnable is only 100 milliseconds, instead of 200.


3. The maximum wait in the main thread is 500 milliseconds, instead of 100.


4. The Future.get method causes a TimeoutException instead of just continuing. We can simply replace this call with a sleep anyway, since that's all that the first class does.

So, ironing out the differences, we get the following Marathon2 class which behaves in a similar manner to the other class (Marathon), with interleaved threads:

public class Marathon2 {



    public static void main(String args)

            throws InterruptedException, ExecutionException, TimeoutException {



        ExecutorService service = null;



        Runnable task = () -> {

            try {

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

                    System.out.println(Thread.currentThread().getName()

                            + " is running... " + i);

                    TimeUnit.MILLISECONDS.sleep(200);

                }



            } catch (InterruptedException e) {

            }

        };

        try {

            service = Executors.newFixedThreadPool(4);



            Future<?> job1 = service.submit(task);

            TimeUnit.MILLISECONDS.sleep(100);

            Future<?> job2 = service.submit(task);

        } finally {

            if (service != null)

                service.shutdown();

        }

    }

}

Without dealing with any threads nor with Executors directly you can do it with a CompletableFuture

 Runnable runnable = () -> System.out.println("hi");

 Runnable runnable1 = () -> System.out.println("there");

 CompletableFuture<Void> all = CompletableFuture.runAsync(runnable).thenRun(runnable1);



 all.whenComplete((x,th) -> {

        System.out.println("both done");

 });

Note that this would use the common ForkJoin pool but you can still provide your own.