• Java Concurrency


    One of the advantages of the Executor framework is that you can run concurrent tasks that return a result. The Java Concurrency API achieves this with the following two interfaces:

    • Callable: This interface is similar to the Runnable interface. It has the call() method which you have to implement the logic of a task. The Callable interface is a parameterized interface, meaning you have to indicate the type of data the call() method will return.
    • Future: This interface has some methods to obtain the result generated by a Callable object and to manage its state.
    /**
     * This class calculates if a number is a prime number. 
     * It can be executed in an executor because it implements the Callable interface.
     * The call() method will return a String
     */
    public class PrimesCalculator implements Callable<String> {
    
        private int num;
    
        public PrimesCalculator(int num) {
            this.num = num;
        }
    
        /**
         * Method called by the executor to execute this task 
         * and calculate if a number is a prime number
         */
        @Override
        public String call() throws Exception {
            String msg = Primes.isPrime(num) ? String.format("%d is a prime number.", num)
                    : String.format("%d is not a prime number.", num);
            TimeUnit.SECONDS.sleep(new Random().nextInt(3));
            return msg;
        }
    }
    
    
    public class Main {
    
        /**
         * @param args
         */
        public static void main(String[] args) {
            
            // Create a ThreadPoolExecutor with fixed size. It has a maximun of two threads
            ThreadPoolExecutor executor=(ThreadPoolExecutor)Executors.newFixedThreadPool(2);
            // List to store the Future objects that control the execution of  the task and
            // are used to obtain the results
            List<Future<Integer>> resultList=new ArrayList<>();
    
            // Create a random number generator
            Random random=new Random();
            // Create and send to the executor the ten tasks
            for (int i=0; i<10; i++){
                Integer number=new Integer(random.nextInt(10));
                FactorialCalculator calculator=new FactorialCalculator(number);
                Future<Integer> result=executor.submit(calculator);
                resultList.add(result);
            }
            
            // Wait for the finalization of the ten tasks
            do {
                System.out.printf("Main: Number of Completed Tasks: %d
    ",executor.getCompletedTaskCount());
                for (int i=0; i<resultList.size(); i++) {
                    Future<Integer> result=resultList.get(i);
                    System.out.printf("Main: Task %d: %s
    ",i,result.isDone());
                }
                try {
                    Thread.sleep(50);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            } while (executor.getCompletedTaskCount()<resultList.size());
            
            // Write the results
            System.out.printf("Main: Results
    ");
            for (int i=0; i<resultList.size(); i++) {
                Future<Integer> result=resultList.get(i);
                Integer number=null;
                try {
                    number=result.get();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } catch (ExecutionException e) {
                    e.printStackTrace();
                }
                System.out.printf("Core: Task %d: %d
    ",i,number);
            }
            
            // Shutdown the executor
            executor.shutdown();
    
        }
    
    }

    In this case, you have learned how to use the Callable interface to launch concurrent tasks that return a result. You have implemented the PrimesCalculator class that implements the Callable interface with String as the type of the result. Hence, it returns before type of the call() method.

    The other critical point of this example is in the Main class. You send a Callable object to be executed in an executor using the submit() method. This method receives a Callable object as a parameter and returns a Future object that you can use with two main objectives:

    • You can control the status of the task: you can cancel the task and check if it has finished. For this purpose, you have used the isDone() method to check if the tasks had finished.
    • You can get the result returned by the call() method. For this purpose, you have used the get() method. This method waits until the Callable object has finished the execution of the call() method and has returned its result. If the thread is interrupted while the get() method is waiting for the result, it throws an InterruptedException exception. If the call() method throws an exception, this method throws an ExecutionException exception.

    When you call the get() method of a Future object and the task controlled by this object hasn't finished yet, the method blocks until the task finishes. The Future interface provides another version of the get() method.

    • get(long timeout, TimeUnit unit): This version of the get method, if the result of the task isn't available, waits for it for the specified time. If the specified period of time passes and the result isn't yet available, the method returns a null value. The TimeUnit class is an enumeration with the following constants: DAYS, HOURS, MICROSECONDS, MILLISECONDS, MINUTES, NANOSECONDS, and SECONDS.
  • 相关阅读:
    MyBatis中传入参数parameterType类型详解
    mybatis逆向工程无法生成带有_表明的解决办法。
    sql server 正则匹配查询数据
    Kibana按时间(小时,分钟,天)统计数据 ,
    AutoCAD 多重引线 文本 左右对齐的问题
    ObjectARXWizard2022安装
    综合练习:词频统计
    powerDesigner设计表自动生成sql语句,设置携带注释
    打jar包后,无法获取resources目录下的word模板文件
    solr新建core,并配置schema
  • 原文地址:https://www.cnblogs.com/huey/p/6032951.html
Copyright © 2020-2023  润新知