search

STIW3054-A182 / Main-Issues

5 stars 1 forks source link

Callable #13

Open zhamri opened 5 years ago

zhamri commented 5 years ago

Instruction:

  1. Download TWO (2) java files from the link below:

    https://github.com/zhamri/MyClass-STIW3054/tree/master/src/main/java/com/stiw3054/problem/p1

  2. Run the program and compare the output. Your output should display something like below:

main Main thread starts here...
Thread-1 start running ...
Thread-2 start running ...
Thread-2 sleeping for 1000 millis
Thread-1 sleeping for 100 millis
Thread-3 start running ...
Thread-3 sleeping for 500 millis
Result-1 = 0
Result-2 = 0
Result-3 = 0
main Main thread ends here...
Thread-1 done ...
Thread-3 done ...
Thread-2 done ...
  1. However the results are INCORRECT. Modify the programs by implementing Callable interface to fix the errors.

Submission

  1. Java code.
  2. Screenshot of the output.
  3. References
SINHUI commented 5 years ago

Java Code

AddTwoNumbers

package com.stiw3054.problem.p1;

import java.util.concurrent.Callable;
import java.util.concurrent.TimeUnit;

public class AddTwoNumbers implements Callable<Integer> {

    private int a;
    private int b;
    private long sleepTime;
    private Integer sum;

    public AddTwoNumbers(int a, int b, long sleepTime) {
        this.a = a;
        this.b = b;
        this.sleepTime = sleepTime;
    }
    public AddTwoNumbers(Integer sum) {
        this.sum=sum;
    }

    @Override
    public Integer call() throws Exception {
        System.out.println(Thread.currentThread().getName() + " start running ...");

        try {
            System.out.println(Thread.currentThread().getName() + " sleeping for " + sleepTime + " millis");
            TimeUnit.MILLISECONDS.sleep(sleepTime);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        sum = a + b;
        System.out.println(Thread.currentThread().getName() + " done ...");     
        return sum;
    }
}

App

package com.stiw3054.problem.p1;

import java.util.concurrent.Future;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class App {

    public static void main(String[] args) {
        ExecutorService executorService = Executors.newCachedThreadPool();

        System.out.println(Thread.currentThread().getName() + " Main thread starts here...");

        AddTwoNumbers task1 = new AddTwoNumbers(2, 3, 100);
        Future<Integer> future = executorService.submit(task1);

        AddTwoNumbers task2 = new AddTwoNumbers(4, 5, 1000);
        Future<Integer> future2 = executorService.submit(task2);

        AddTwoNumbers task3 = new AddTwoNumbers(6, 7, 500);
        Future<Integer> future3 = executorService.submit(task3);

        try {
            System.out.println("Result-1 = " + future.get());
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        }
        try {
            System.out.println("Result-2 = " + future2.get());
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        }
        try {
            System.out.println("Result-3 = " + future3.get());
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        }

        System.out.println(Thread.currentThread().getName() + " Main thread ends here...");
    }
}

Output

output

References

  1. https://www.developer.com/java/data/understanding-callable-and-future-interfaces-in-java.html
  2. https://www.youtube.com/watch?v=ysP07P_B88w
ChongMeiYong commented 5 years ago

AddTwoNumbers

package com.stiw3054.problem.p1;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;

public class AddTwoNumbers implements Callable <Integer>{

    private int a;
    private int b;
    private long sleepTime;
    private int sum;

    public AddTwoNumbers(int a, int b, long sleepTime) {
        this.a = a;
        this.b = b;
        this.sleepTime = sleepTime;
    }

    public Integer call() throws Exception {
        // TODO Auto-generated method stub
        System.out.println(Thread.currentThread().getName() + " start running ...");

        try {
            System.out.println(Thread.currentThread().getName() + " sleeping for " + sleepTime + " millis");
            TimeUnit.MILLISECONDS.sleep(sleepTime);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        sum = a+b;
        System.out.println(Thread.currentThread().getName() + " done ...");
    return sum;
    }  
}

Add

package com.stiw3054.problem.p1;

import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

public class App {

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        ExecutorService executor = Executors.newFixedThreadPool(500);

        System.out.println(Thread.currentThread().getName() + " Main thread starts here...");

        AddTwoNumbers task1 = new AddTwoNumbers(2, 3, 100);
        Future <Integer> future1 = executor.submit(task1);

        AddTwoNumbers task2 = new AddTwoNumbers(4, 5, 1000);
        Future <Integer> future2 = executor.submit(task2);

        AddTwoNumbers task3 = new AddTwoNumbers(6, 7, 500);
        Future <Integer> future3 = executor.submit(task3);

        try {
            System.out.println("Result-1 = " + future1.get());
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        try {
            System.out.println("Result-2 = " + future2.get());
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        try {
            System.out.println("Result-3 = " + future3.get());
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println(Thread.currentThread().getName() + " Main thread ends here...");  
    }
}

Output image

References

  1. https://dzone.com/articles/java-callable-future-understanding
  2. http://tutorials.jenkov.com/java-util-concurrent/executorservice.html
  3. https://www.youtube.com/watch?v=Adv6d29Ohkg
lingzhongli commented 5 years ago 
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.ExecutionException;

public class App {

    public static void main(String[] args) throws InterruptedException, ExecutionException {
        ExecutorService executor= Executors.newCachedThreadPool();

        System.out.println(Thread.currentThread().getName() + " Main thread starts here...");

        Future <Integer> future = executor.submit(new AddTwoNumbers(2, 3, 100));

        Future<Integer> future2 = executor.submit(new AddTwoNumbers(4, 5, 1000));

        Future<Integer> future3 = executor.submit(new AddTwoNumbers(6, 7, 500));

        System.out.println("Result-1 = " + future.get());
        System.out.println("Result-2 = " + future2.get());
        System.out.println("Result-3 = " + future3.get());

        System.out.println(Thread.currentThread().getName() + " Main thread ends here...");
    }
}
import java.util.concurrent.TimeUnit;
import java.util.concurrent.Callable;

public class AddTwoNumbers implements Callable<Integer> {

    private int a;
    private int b;
    private long sleepTime;
    private int sum;

    public AddTwoNumbers(int a, int b, long sleepTime) {
        this.a = a;
        this.b = b;
        this.sleepTime = sleepTime;
    }

    public Integer call() throws Exception {
        System.out.println(Thread.currentThread().getName() + " start running ...");

        try {
            System.out.println(Thread.currentThread().getName() + " sleeping for " + sleepTime + " millis");
            TimeUnit.MILLISECONDS.sleep(sleepTime);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        sum = a + b;

        System.out.println(Thread.currentThread().getName() + " done ...");
        return sum;
    }
}

OUTPUT image

Reference

  1. https://www.youtube.com/watch?v=lnbWFV4b7M4&t=386s
  2. https://stackoverflow.com/questions/30965339/executorcompletionservice-is-not-applicable-for-the-given-arguments
limxinyii commented 5 years ago

1. Java code

import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

public class App {
    public static void main(String[] args) throws ExecutionException,InterruptedException{

        ExecutorService executor = Executors.newCachedThreadPool();

        System.out.println(Thread.currentThread().getName() + " Main thread starts here...");

        AddTwoNumbers task1 = new AddTwoNumbers(2, 3, 100);
        Future<Integer> future1 = executor.submit(task1);

        AddTwoNumbers task2 = new AddTwoNumbers(4, 5, 1000);
        Future<Integer> future2 = executor.submit(task2);

        AddTwoNumbers task3 = new AddTwoNumbers(6, 7, 500);
        Future<Integer> future3 = executor.submit(task3);

        try {
            System.out.println("Result-1 = " + future1.get());
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        try {
            System.out.println("Result-2 = " + future2.get());
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        try {
            System.out.println("Result-3 = " + future3.get());
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println(Thread.currentThread().getName() + " Main thread ends here...");
    }
}
import java.util.concurrent.Callable;
import java.util.concurrent.TimeUnit;

public class AddTwoNumbers implements Callable<Integer> {

    private int a;
    private int b;
    private long sleepTime;
    private int sum;

    public AddTwoNumbers(int a, int b, long sleepTime) {
        this.a = a;
        this.b = b;
        this.sleepTime = sleepTime;
    }

    @Override
    public Integer call() throws Exception {
        System.out.println(Thread.currentThread().getName() + " start running ...");

        try {
            System.out.println(Thread.currentThread().getName() + " sleeping for " + sleepTime + " millis");
            TimeUnit.MILLISECONDS.sleep(sleepTime);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        sum = a + b;

        System.out.println(Thread.currentThread().getName() + " done ...");
        return sum;
    }
}

2. Screenshot of the output

image

3. References

  1. https://netjs.blogspot.com/2016/04/callable-and-future-in-java-concurrency.html
  2. https://dzone.com/articles/skps-javajee-gotchas-revisiting-java-se-5-features
  3. https://www.youtube.com/watch?v=NEZ2ASoP_nY
AhKitt commented 5 years ago

Java Code

Issue13


import java.util.concurrent.Future;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class Issue13 {

    public static void main(String[] args) {
        ExecutorService executorService = Executors.newCachedThreadPool();

        System.out.println(Thread.currentThread().getName() + " Main thread starts here...");

        AddTwoNumbers task1 = new AddTwoNumbers(2, 3, 100);
        Future<Integer> future1 = executorService.submit(task1);

        AddTwoNumbers task2 = new AddTwoNumbers(4, 5, 1000);
        Future<Integer> future2 = executorService.submit(task2);

        AddTwoNumbers task3 = new AddTwoNumbers(6, 7, 500);
        Future<Integer> future3 = executorService.submit(task3);

        try {
            System.out.println("Result-1 = " + future1.get());
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        }
        try {
            System.out.println("Result-2 = " + future2.get());
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        }
        try {
            System.out.println("Result-3 = " + future3.get());
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        }

        System.out.println(Thread.currentThread().getName() + " Main thread ends here...");

    }
}

AddTwoNumbers


import java.util.concurrent.Callable;
import java.util.concurrent.TimeUnit;

public class AddTwoNumbers implements Callable<Integer> {

    private int a;
    private int b;
    private long sleepTime;
    private Integer sum;

    public AddTwoNumbers(int a, int b, long sleepTime) {
        this.a = a;
        this.b = b;
        this.sleepTime = sleepTime;
    }
    public AddTwoNumbers(Integer sum) {
        this.sum=sum;
    }

    @Override
    public Integer call() throws Exception {
        System.out.println(Thread.currentThread().getName() + " start running ...");

        try {
            System.out.println(Thread.currentThread().getName() + " sleeping for " + sleepTime + " millis");
            TimeUnit.MILLISECONDS.sleep(sleepTime);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        sum = a + b;
        System.out.println(Thread.currentThread().getName() + " done ...");     
        return sum;
    }
}

Output

is3

Reference

  1. https://www.callicoder.com/java-callable-and-future-tutorial/
  2. https://www.youtube.com/watch?v=lnbWFV4b7M4&t=184s
  3. https://www.tutorialspoint.com/Callable-and-Future-in-Java
Yvevonwen commented 5 years ago

JavaCode

import java.util.concurrent.Future;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class App {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
ExecutorService executorService = Executors.newCachedThreadPool();

        System.out.println(Thread.currentThread().getName() + " Main thread starts here...");

        AddTwoNumber task1 = new AddTwoNumber(2, 3, 100);
        Future<Integer> future1 = executorService.submit(task1);
        AddTwoNumber task2 = new AddTwoNumber(4, 5, 1000);
        Future<Integer> future2 = executorService.submit(task2);
        AddTwoNumber task3 = new AddTwoNumber(6, 7, 500);
        Future<Integer> future3 = executorService.submit(task3);

        try {
            System.out.println("Result-1 = " + future1.get());
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        }
        try {
            System.out.println("Result-2 = " + future2.get());
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        }
        try {
            System.out.println("Result-3 = " + future3.get());
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        }

        System.out.println(Thread.currentThread().getName() + " Main thread ends here...");

    }
}
import java.util.concurrent.Callable;
import java.util.concurrent.TimeUnit;

public class AddTwoNumber implements Callable<Integer> {

    private int a;
    private int b;
    private long sleepTime;
    private Integer sum;

    public AddTwoNumber(int a, int b, long sleepTime) {
        this.a = a;
        this.b = b;
        this.sleepTime = sleepTime;
    }
    public AddTwoNumber(Integer sum) {
        this.sum=sum;
    }

    @Override
    public Integer call() throws Exception {
        System.out.println(Thread.currentThread().getName() + " start running ...");

        try {
            System.out.println(Thread.currentThread().getName() + " sleeping for " + sleepTime + " millis");
            TimeUnit.MILLISECONDS.sleep(sleepTime);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        sum = a + b;
        System.out.println(Thread.currentThread().getName() + " done ...");     
        return sum;
    }   
}

Output

image

References

  1. https://www.journaldev.com/1090/java-callable-future-example
  2. https://www.geeksforgeeks.org/callable-future-java/
  3. http://tutorials.jenkov.com/java-util-concurrent/executorservice.html
mimiothman commented 5 years ago

Java Code

import java.util.concurrent.Future;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class App {

    public static void main(String[] args) throws ExecutionException {
        ExecutorService executorServ = Executors.newCachedThreadPool();

        System.out.println(Thread.currentThread().getName() + " Main thread starts here...");

        AddTwoNumbers task1 = new AddTwoNumbers(2, 3, 100);
        Future<Integer> f1 = executorServ.submit(task1);

        AddTwoNumbers task2 = new AddTwoNumbers(4, 5, 1000);
        Future<Integer> f2 = executorServ.submit(task2);

        AddTwoNumbers task3 = new AddTwoNumbers(6, 7, 500);
        Future<Integer> f3 = executorServ.submit(task3);

        try {
            System.out.println("Result-1 = " + f1.get());
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        try {
            System.out.println("Result-2 = " + f2.get());
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        try {
            System.out.println("Result-3 = " + f3.get());
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println(Thread.currentThread().getName() + " Main thread ends here...");
    }
}

import java.util.concurrent.Callable;
import java.util.concurrent.TimeUnit;

public class AddTwoNumbers implements Callable<Integer> {

    private int a;
    private int b;
    private long sleepTime;
    private Integer sum;

    public AddTwoNumbers(int a, int b, long sleepTime) {
        this.a = a;
        this.b = b;
        this.sleepTime = sleepTime;
    }

    @Override
    public Integer call() throws Exception {
        System.out.println(Thread.currentThread().getName() + " start running ...");

        try {
            System.out.println(Thread.currentThread().getName() + " sleeping for " + sleepTime + " millis");
            TimeUnit.MILLISECONDS.sleep(sleepTime);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        sum = a + b;
        System.out.println(Thread.currentThread().getName() + " done ...");     
        return sum;
    }
}

Output

image

References

  1. https://www.journaldev.com/1090/java-callable-future-example
  2. https://howtodoinjava.com/java/multi-threading/java-callable-future-example/
  3. https://www.callicoder.com/java-callable-and-future-tutorial/
  4. https://www.tutorialspoint.com/Callable-and-Future-in-Java
raihanwidia commented 5 years ago 
package issues13;

import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

public class App {
     public static void main(String[] args) throws InterruptedException, ExecutionException {

            System.out.println(Thread.currentThread().getName() + " Main thread starts here...");

            int coreCount = Runtime.getRuntime().availableProcessors();
            ExecutorService service = Executors.newFixedThreadPool(coreCount); 

            Future <Integer> future1 = service.submit(new AddTwoNumbers(2, 3, 100));
            Future <Integer> future2 = service.submit(new AddTwoNumbers(4, 5, 1000));
            Future <Integer> future3 = service.submit(new AddTwoNumbers(6, 7, 500));

            System.out.println("Result-1 = " + future1.get());
            System.out.println("Result-2 = " + future2.get());
            System.out.println("Result-3 = " + future3.get());

            System.out.println(Thread.currentThread().getName() + " Main thread ends here...");

        }
}
package issues13;
import java.util.concurrent.Callable;
import java.util.concurrent.TimeUnit;

public class AddTwoNumbers implements Callable<Integer> {
        private int a;
        private int b;
        private long sleepTime;
        private int sum;

        public AddTwoNumbers(int a, int b, long sleepTime) {
            this.a = a;
            this.b = b;
            this.sleepTime = sleepTime;
        }

        @Override
        public Integer call() throws Exception {
             System.out.println(Thread.currentThread().getName() + " start running ...");

                try {
                    System.out.println(Thread.currentThread().getName() + " sleeping for " + sleepTime + " millis");
                    TimeUnit.MILLISECONDS.sleep(sleepTime);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

                sum = a + b;

                System.out.println(Thread.currentThread().getName() + " done ...");         

                return sum;
        }
}

image

roflinasuha commented 5 years ago 
import java.util.concurrent.ExecutorService;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

public class Add {

    public static void main(String[] args) throws ExecutionException {
        System.out.println(Thread.currentThread().getName() + " Main thread starts here...");

        ExecutorService executor = Executors.newCachedThreadPool();

        AddTwoNumbers task1 = new AddTwoNumbers(2, 3, 100);
        Future<Integer> future1 = executor.submit(task1);

        AddTwoNumbers task2 = new AddTwoNumbers(4, 5, 1000);
        Future<Integer> future2 = executor.submit(task2);

        AddTwoNumbers task3 = new AddTwoNumbers(6, 7, 500);
        Future<Integer> future3 = executor.submit(task3);

        try {
            System.out.println("Result-1 = " + future1.get());
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        try {
            System.out.println("Result-2 = " + future2.get());
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        try {
            System.out.println("Result-3 = " + future3.get());
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println(Thread.currentThread().getName() + " Main thread ends here...");
    }
}

package issues12;

import java.util.concurrent.TimeUnit;
import java.util.concurrent.Callable;

public class AddTwoNumbers implements Callable<Integer> {

    private int a;
    private int b;
    private long sleepTime;
    private int sum;

    public AddTwoNumbers(int a, int b, long sleepTime) {
        this.a = a;
        this.b = b;
        this.sleepTime = sleepTime;
    }

    public AddTwoNumbers(Integer sum) {
        this.sum=sum;
    }

    public Integer call() throws Exception {
        System.out.println(Thread.currentThread().getName() + " start running ...");

        try {
            System.out.println(Thread.currentThread().getName() + " sleeping for " + sleepTime + " millis");
            TimeUnit.MILLISECONDS.sleep(sleepTime);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        sum = a + b;

        System.out.println(Thread.currentThread().getName() + " done ...");
        return sum;
    }

}

Output image

References 1) https://www.codota.com/code/java/classes/java.util.concurrent.Callable 2) https://www.journaldev.com/1090/java-callable-future-example 3) https://www.geeksforgeeks.org/callable-future-java/ 4) https://howtodoinjava.com/java/multi-threading/java-callable-future-example/

prevenkumar commented 5 years ago 
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Executors;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Future;

public class App {

    public static void main(String[] args) throws ExecutionException, InterruptedException {

        ExecutorService executor = Executors.newFixedThreadPool(500);
        System.out.println(Thread.currentThread().getName() + " Main thread starts here...");

        AddTwoNumbers task1 = new AddTwoNumbers(2, 3, 100);
        Future <Integer> f1 = executor.submit(task1);

        AddTwoNumbers task2 = new AddTwoNumbers(4, 5, 1000);
        Future <Integer> f2 = executor.submit(task2);

        AddTwoNumbers task3 = new AddTwoNumbers(6, 7, 500);
        Future <Integer> f3 = executor.submit(task3);

        try { 
            System.out.println("Result-1 = "+ f1.get());
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        try { 
            System.out.println("Result-2 = "+ f2.get());
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        try { 
            System.out.println("Result-3 = "+ f3.get());
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println(Thread.currentThread().getName() + " Main thread ends here...");
    }
}
import java.util.concurrent.Callable;
import java.util.concurrent.TimeUnit;

public class AddTwoNumbers implements Callable<Integer> {

    private int a;
    private int b;
    private long sleepTime;
    private int sum;

    public AddTwoNumbers(int a, int b, long sleepTime) {
        this.a = a;
        this.b = b;
        this.sleepTime = sleepTime;
    }

    public Integer call() throws Exception {
        System.out.println(Thread.currentThread().getName() + " start running ...");

        try {
            System.out.println(Thread.currentThread().getName() + " sleeping for " + sleepTime + " millis");
            TimeUnit.MILLISECONDS.sleep(sleepTime);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        sum = a + b;

        System.out.println(Thread.currentThread().getName() + " done ...");

        return sum;
    }
}

Output

callable

Reference

https://www.developer.com/java/data/understanding-callable-and-future-interfaces-in-java.html https://www.journaldev.com/1090/java-callable-future-example https://howtodoinjava.com/java/multi-threading/java-callable-future-example/ https://javarevisited.blogspot.com/2015/06/how-to-use-callable-and-future-in-java.html

lishaobin commented 5 years ago

App.class

package issue13;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

public class App {

    public static void main(String[] args)  {
        ExecutorService executor = Executors.newCachedThreadPool();
        System.out.println(Thread.currentThread().getName() + " Main thread starts here...");

         Future <Integer> future = executor.submit(new AddTwoNumbers(2, 3, 100));

         Future<Integer> future2 = executor.submit(new AddTwoNumbers(4, 5, 1000));

         Future<Integer> future3 = executor.submit(new AddTwoNumbers(6, 7, 500));

         try {
        System.out.println("Result-1 = " + future.get());
        System.out.println("Result-2 = " + future2.get());
        System.out.println("Result-3 = " + future3.get());
         }
         catch(Exception e){

         }

        System.out.println(Thread.currentThread().getName() + " Main thread ends here...");
    }
}

AddTwoNumbers.class

package issue13;

import java.util.concurrent.Callable;
import java.util.concurrent.TimeUnit;

public class AddTwoNumbers implements Callable <Integer> {

    private int a;
    private int b;
    private long sleepTime;
    private int sum;

    public AddTwoNumbers(int a, int b, long sleepTime) {
        this.a = a;
        this.b = b;
        this.sleepTime = sleepTime;
    }
    @Override
    public Integer call() {
        System.out.println(Thread.currentThread().getName() + " start running ...");

        try {
            System.out.println(Thread.currentThread().getName() + " sleeping for " + sleepTime + " millis");
            TimeUnit.MILLISECONDS.sleep(sleepTime);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        sum = a + b;
        System.out.println(Thread.currentThread().getName() + " done ...");

        return sum;
    }
}

output

image

Reference

https://www.cnblogs.com/dolphin0520/p/3949310.html

rahimahsahar commented 5 years ago

AddTwoNumbers

import java.util.concurrent.Callable;
import java.util.concurrent.TimeUnit;

public class AddTwoNumbers implements Callable<Integer> {

    private int a;
    private int b;
    private long sleepTime;
    private Integer sum;

    public AddTwoNumbers(int a, int b, long sleepTime) {
        this.a = a;
        this.b = b;
        this.sleepTime = sleepTime;
    }
    public AddTwoNumbers(Integer sum) {
        this.sum=sum;
    }

    @Override
    public Integer call() throws Exception {
        System.out.println(Thread.currentThread().getName() + " start running ...");

        try {
            System.out.println(Thread.currentThread().getName() + " sleeping for " + sleepTime + " millis");
            TimeUnit.MILLISECONDS.sleep(sleepTime);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        sum = a + b;
        System.out.println(Thread.currentThread().getName() + " done ...");     
        return sum;
    }
}

App

import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

public class App {
    import java.util.concurrent.Future;
    import java.util.concurrent.ExecutionException;
    import java.util.concurrent.ExecutorService;
    import java.util.concurrent.Executors;

    public class App {

        public static void main(String[] args) {
            ExecutorService executorService = Executors.newCachedThreadPool();

            System.out.println(Thread.currentThread().getName() + " Main thread starts here...");

            AddTwoNumbers task1 = new AddTwoNumbers(2, 3, 100);
            Future<Integer> future = executorService.submit(task1);

            AddTwoNumbers task2 = new AddTwoNumbers(4, 5, 1000);
            Future<Integer> future2 = executorService.submit(task2);

            AddTwoNumbers task3 = new AddTwoNumbers(6, 7, 500);
            Future<Integer> future3 = executorService.submit(task3);

            try {
                System.out.println("Result-1 = " + future.get());
            } catch (InterruptedException | ExecutionException e) {
                e.printStackTrace();
            }
            try {
                System.out.println("Result-2 = " + future2.get());
            } catch (InterruptedException | ExecutionException e) {
                e.printStackTrace();
            }
            try {
                System.out.println("Result-3 = " + future3.get());
            } catch (InterruptedException | ExecutionException e) {
                e.printStackTrace();
            }

            System.out.println(Thread.currentThread().getName() + " Main thread ends here...");
        }
    }

}

Output image

References https://www.cnblogs.com/dolphin0520/p/3949310.html https://www.journaldev.com/1090/java-callable-future-example https://howtodoinjava.com/java/multi-threading/java-callable-future-example/

lancelot9927 commented 5 years ago

App

package issue12.p1;

import java.util.concurrent.Future;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class App {

    public static void main(String[] args) {
        ExecutorService executorService = Executors.newCachedThreadPool();

        System.out.println(Thread.currentThread().getName() + " Main thread starts here...");

        AddTwoNumbers task1 = new AddTwoNumbers(2, 3, 100);
        Future<Integer> future = executorService.submit(task1);

        AddTwoNumbers task2 = new AddTwoNumbers(4, 5, 1000);
        Future<Integer> future2 = executorService.submit(task2);

        AddTwoNumbers task3 = new AddTwoNumbers(6, 7, 500);
        Future<Integer> future3 = executorService.submit(task3);

        try {
            System.out.println("Result-1 = " + future.get());
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        }
        try {
            System.out.println("Result-2 = " + future2.get());
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        }
        try {
            System.out.println("Result-3 = " + future3.get());
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        }

        System.out.println(Thread.currentThread().getName() + " Main thread ends here...");  
    }
}

AddTwoNumbers

package issue12.p1;

import java.util.concurrent.Callable;
import java.util.concurrent.TimeUnit;

public class AddTwoNumbers implements Callable<Integer> {

    private int a;
    private int b;
    private long sleepTime;
    private int sum;

    public AddTwoNumbers(int a, int b, long sleepTime) {
        this.a = a;
        this.b = b;
        this.sleepTime = sleepTime;
    }

    public Integer call() throws Exception {
           System.out.println(Thread.currentThread().getName() + " start running ...");

           try {
               System.out.println(Thread.currentThread().getName() + " sleeping for " + sleepTime + " millis");
               TimeUnit.MILLISECONDS.sleep(sleepTime);
           } catch (InterruptedException e) {
               e.printStackTrace();
           }
           sum = a + b;
           System.out.println(Thread.currentThread().getName() + " done ...");     
           return sum;
       }
   }

Output

issues13

References

1.https://www.developer.com/java/data/understanding-callable-and-future-interfaces-in-java.html 2.https://www.codota.com/code/java/classes/java.util.concurrent.Callable

shyyahcheang commented 5 years ago

1. Java code

package Issue13;

import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

public class App {
    public static void main( String[] args ) throws ExecutionException, InterruptedException {
        int coreCount = Runtime.getRuntime().availableProcessors();
        ExecutorService executorService = Executors.newFixedThreadPool(coreCount);

        System.out.println(Thread.currentThread().getName() + " Main thread starts here...");

        Future<Integer> future1 = executorService.submit(new AddTwoNumbers(2, 3, 100));
        Future<Integer> future2 = executorService.submit(new AddTwoNumbers(4, 5, 1000));
        Future<Integer> future3 = executorService.submit(new AddTwoNumbers(6, 7, 500));

        System.out.println("Result-1 --> " + future1.get());
        System.out.println("Result-2 --> " + future2.get());
        System.out.println("Result-3 --> " + future3.get());

        System.out.println(Thread.currentThread().getName() + " Main thread ends here...");
    }
}
package Issue13;

import java.util.concurrent.Callable;
import java.util.concurrent.TimeUnit;

public class AddTwoNumbers implements Callable<Integer> {
    private int a;
    private int b;
    private long sleepTime;
    private int sum;

    public AddTwoNumbers(int a, int b, long sleepTime) {
        this.a = a;
        this.b = b;
        this.sleepTime = sleepTime;
    }

    @Override
    public Integer call() {
        System.out.println(Thread.currentThread().getName() + " start running ...");

        try {
            System.out.println(Thread.currentThread().getName() + " sleeping for " + sleepTime + " millis");
            TimeUnit.MILLISECONDS.sleep(sleepTime);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        sum = a + b;

        System.out.println(Thread.currentThread().getName() + " done ...");

        return sum;
    }
}

2. Screenshot of the output

issue 13 - output

3. References

mwng97 commented 5 years ago

JavaCode

import java.util.concurrent.*;

public class callable implements Callable<Integer> {
    private int a;
    private int b;
    private long sleepTime;

    callable(int a, int b, long sleepTime) {
        this.a = a;
        this.b = b;
        this.sleepTime = sleepTime;
    }

    @Override
    public Integer call() {
        System.out.println(Thread.currentThread().getName() + " start running ...");
        try {
            System.out.println(Thread.currentThread().getName() + " sleeping for " + sleepTime + " millis");
            TimeUnit.MILLISECONDS.sleep(sleepTime);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + " done ...");
        return a + b;
    }
}

class futureTask {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        System.out.println(Thread.currentThread().getName() + " Main thread starts here...");

        ExecutorService executorService = Executors.newCachedThreadPool();

        callable task1 = new callable(2, 3, 100);
        FutureTask<Integer> FT1 = new FutureTask<Integer>(task1);

        callable task2 = new callable(4, 5, 1000);
        FutureTask<Integer> FT2 = new FutureTask<Integer>(task2);

        callable task3 = new callable(6, 7, 500);
        FutureTask<Integer> FT3 = new FutureTask<Integer>(task3);

        executorService.submit(FT1);
        executorService.submit(FT2);
        executorService.submit(FT3);

        if (FT1.get() != null && FT2.get() != null && FT3.get() != null) {
            System.out.println("Result-1 = " + FT1.get());
            System.out.println("Result-2 = " + FT2.get());
            System.out.println("Result-3 = " + FT3.get());
        }

        System.out.println(Thread.currentThread().getName() + " Main thread ends here...");
        executorService.shutdown();
    }
}

Output

FutureTask1

Reference https://docs.oracle.com/javase/7/docs/api/java/util/concurrent/FutureTask.html

trinanda98 commented 5 years ago

App.java

package Callable;

import java.util.concurrent.Future;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class App {

    public static void main(String[] args) {
        ExecutorService executorService = Executors.newCachedThreadPool();

        System.out.println(Thread.currentThread().getName() + " Main thread starts here...");

        AddTwoNumbers task1 = new AddTwoNumbers(2, 3, 100);
        Future<Integer> future = executorService.submit(task1);

        AddTwoNumbers task2 = new AddTwoNumbers(4, 5, 1000);
        Future<Integer> future2 = executorService.submit(task2);

        AddTwoNumbers task3 = new AddTwoNumbers(6, 7, 500);
        Future<Integer> future3 = executorService.submit(task3);

        try {
            System.out.println("Result-1 = " + future.get());
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        }
        try {
            System.out.println("Result-2 = " + future2.get());
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        }
        try {
            System.out.println("Result-3 = " + future3.get());
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        }

        System.out.println(Thread.currentThread().getName() + " Main thread ends here...");
    }
}

AddTwoNumbers

package Callable;

import java.util.concurrent.Callable;
import java.util.concurrent.TimeUnit;

public class AddTwoNumbers implements Callable<Integer> {

    private int a;
    private int b;
    private long sleepTime;
    private Integer sum;

    public AddTwoNumbers(int a, int b, long sleepTime) {
        this.a = a;
        this.b = b;
        this.sleepTime = sleepTime;
    }
    public AddTwoNumbers(Integer sum) {
        this.sum=sum;
    }

    @Override
    public Integer call() throws Exception {
        System.out.println(Thread.currentThread().getName() + " start running ...");

        try {
            System.out.println(Thread.currentThread().getName() + " sleeping for " + sleepTime + " millis");
            TimeUnit.MILLISECONDS.sleep(sleepTime);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        sum = a + b;
        System.out.println(Thread.currentThread().getName() + " done ...");     
        return sum;
    }
}

Output

Screenshot (94)

References

muhammadbimo1 commented 5 years ago

Explanation: Implementing Callable means you now can pass data on threads, therefore populating result-1,2,and 3.

fetching the variables were done by the Future , which then displayed by using future.get().

import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

public class App {

    public static void main(String[] args) {
        ExecutorService executorService = Executors.newCachedThreadPool();
        System.out.println(Thread.currentThread().getName() + " Main thread starts here...");

        AddTwoNumbers task1 = new AddTwoNumbers(2, 3, 100);
        Future<Integer> future = executorService.submit(task1);

        AddTwoNumbers task2 = new AddTwoNumbers(4, 5, 1000);
        Future<Integer> future2 = executorService.submit(task2);

        AddTwoNumbers task3 = new AddTwoNumbers(6, 7, 500);
        Future<Integer> future3 = executorService.submit(task3);

        try {
            System.out.println("Result-1 = " + future.get());
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        }
        try {
            System.out.println("Result-2 = " + future2.get());
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        }
        try {
            System.out.println("Result-3 = " + future3.get());
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        }
        System.out.println("Result-1 = " + task1.getSum());
        System.out.println("Result-2 = " + task2.getSum());
        System.out.println("Result-3 = " + task3.getSum());

        System.out.println(Thread.currentThread().getName() + " Main thread ends here...");
    }
}
import java.util.concurrent.Callable;
import java.util.concurrent.TimeUnit;

public class AddTwoNumbers implements Callable<Integer> {

    private int a;
    private int b;
    private long sleepTime;
    private int sum;

    public AddTwoNumbers(int a, int b, long sleepTime) {
        this.a = a;
        this.b = b;
        this.sleepTime = sleepTime;
    }
    public int getSum() {
        return sum;
    }

    @Override
    public Integer call() throws Exception {
        System.out.println(Thread.currentThread().getName() + " start running ...");

        try {
            System.out.println(Thread.currentThread().getName() + " sleeping for " + sleepTime + " millis");
            TimeUnit.MILLISECONDS.sleep(sleepTime);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        sum = a + b;

        System.out.println(Thread.currentThread().getName() + " done ...");
        return sum;
    }
}

Output: 

main Main thread starts here...
pool-1-thread-1 start running ...
pool-1-thread-1 sleeping for 100 millis
pool-1-thread-2 start running ...
pool-1-thread-2 sleeping for 1000 millis
pool-1-thread-3 start running ...
pool-1-thread-3 sleeping for 500 millis
pool-1-thread-1 done ...
Result-1 = 5
pool-1-thread-3 done ...
pool-1-thread-2 done ...
Result-2 = 9
Result-3 = 13
Result-1 = 5
Result-2 = 9
Result-3 = 13
main Main thread ends here...

Process finished with exit code 0
alfmrza commented 5 years ago

MAIN

package COM.STIW3054.Test;

import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.TimeUnit;

public class issue13Main {
    private int a;
    private int b;
    private long sleepTime;
    private int sum;

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        int coreCount = Runtime.getRuntime().availableProcessors();
        ExecutorService executorService = Executors.newFixedThreadPool(coreCount);

        System.out.println(Thread.currentThread().getName() + " Main thread starts here...");

        Future<Integer> future1 = executorService.submit(new issue13AddTwoNumbers(2, 3, 100));
        System.out.println("Result-1 --> " + future1.get());
        Future<Integer> future2 = executorService.submit(new issue13AddTwoNumbers(4, 5, 1000));
        System.out.println("Result-2 --> " + future2.get());
        Future<Integer> future3 = executorService.submit(new issue13AddTwoNumbers(6, 7, 500));
        System.out.println("Result-3 --> " + future3.get());

        System.out.println(Thread.currentThread().getName() + " Main thread ends here...");
    }
}

ADDTWONUMBERS

package COM.STIW3054.Test;

import java.util.concurrent.Callable;
import java.util.concurrent.TimeUnit;

public class issue13AddTwoNumbers implements Callable<Integer> {
    private int a;
    private int b;
    private long sleepTime;
    private int sum;

    public issue13AddTwoNumbers(int a, int b, long sleepTime) {
        this.a = a;
        this.b = b;
        this.sleepTime = sleepTime;
    }

    public Integer call() {
        System.out.println(Thread.currentThread().getName() + " start running ...");

        try {
            System.out.println(Thread.currentThread().getName() + " sleeping for " + sleepTime + " millis");
            TimeUnit.MILLISECONDS.sleep(sleepTime);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        sum = a + b;

        System.out.println(Thread.currentThread().getName() + " done ...");

        return sum;
    }
}

image

FatihahFauzi commented 5 years ago 
import java.util.concurrent.Callable;
import java.util.concurrent.TimeUnit;

public class AddTwoNumbers implements Callable<Integer> {

    private int a;
    private int b;
    private long sleepTime;
    private Integer sum;

    public AddTwoNumbers(int a, int b, long sleepTime) {
        this.a = a;
        this.b = b;
        this.sleepTime = sleepTime;
    }
    public AddTwoNumbers(Integer sum) {
        this.sum=sum;
    }

    @Override
    public Integer call() throws Exception {
        System.out.println(Thread.currentThread().getName() + " start running ...");

        try {
            System.out.println(Thread.currentThread().getName() + " sleeping for " + sleepTime + " millis");
            TimeUnit.MILLISECONDS.sleep(sleepTime);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        sum = a + b;
        System.out.println(Thread.currentThread().getName() + " done ...");
        return sum;
    }
}

import java.util.concurrent.Future;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class App {

    public static void main(String[] args) {
        ExecutorService executorService = Executors.newCachedThreadPool();

        System.out.println(Thread.currentThread().getName() + " Main thread starts here...");

        AddTwoNumbers task1 = new AddTwoNumbers(2, 3, 100);
        Future<Integer> future = executorService.submit(task1);

        AddTwoNumbers task2 = new AddTwoNumbers(4, 5, 1000);
        Future<Integer> future2 = executorService.submit(task2);

        AddTwoNumbers task3 = new AddTwoNumbers(6, 7, 500);
        Future<Integer> future3 = executorService.submit(task3);

        try {
            System.out.println("Result-1 = " + future.get());
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        }
        try {
            System.out.println("Result-2 = " + future2.get());
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        }
        try {
            System.out.println("Result-3 = " + future3.get());
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        }

        System.out.println(Thread.currentThread().getName() + " Main thread ends here...");
    }
}

output: image

reference: https://www.geeksforgeeks.org/callable-future-java/ http://tutorials.jenkov.com/java-util-concurrent/java-callable.html