Java并发34:Callable+Future系列--Callable接口学习笔记

本章主要学习Callable接口。

1.Callable接口概述

Callable接口是一种能够返回计算结果并且可以抛出异常的任务。
Callable接口的实现类需要定义一个无参数的方法：call()。

@FunctionalInterface
public interface Callable<V> {
    /**
     * Computes a result, or throws an exception if unable to do so.
     *
     * @return computed result
     * @throws Exception if unable to compute a result
     */
    V call() throws Exception;
}

Callable接口与Runnable接口类似，都是为了实现多线程而设计的。
但是，Runnable接口并不能返回结果，也不能抛出一个可检查的异常。

Executors工具类包含一些工具方法，这些方法能够将一些其他常见的形式转换成Callable接口的实现类。
关于这些转换方法，可以参考后续文章。

2.Callable与Runnable对比

类似之处：

• 都是为了实现多线程而设计的
• 都可以在Executor框架中使用

区别之处：

• Callable接口可以返回结果；Runnable接口不能返回结果
• Callable接口可以抛出异常；Runnable接口不能抛出异常
• Callable接口是泛型接口；Runnable接口是普通接口
• Callable接口常常与Future结合使用

3.实例练习

练习目的：

• 加深对Callable接口和Runnable接口的理解。
• 了解两种多线程编程方式的区别：Thread和Executor。
• 了解Callable 和Future 的基本用法，理解返回结果的优势。

练习说明：

• 分别以下面三种方式实现随机数的获取：
• 1.Runnable + Thread
• 2.Runnable + Executor
• 3.Callable + Future + Executor

实例代码：

Runnable编程方式：

/**
 * 多线程示例-获取随机值-实现Runnable接口
 */
//定义一个共享变量
static AtomicInteger value = new AtomicInteger(0);

//实现Runnable
static class RandomByRunnable implements Runnable{
    @Override
    public void run() {
        //模拟计算
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        //CAS赋值
        value.compareAndSet(0,RandomUtils.nextInt(100,200));
    }
}

Callable编程方式：

/**
 * 多线程示例-获取随机值-实现Callable接口
 */
static class RandomByCallable implements Callable<Integer>{

    @Override
    public Integer call() throws Exception {
        Thread.sleep(1000);
        return RandomUtils.nextInt(100,200);
    }
}

三种多线程方式：

import java.util.Random;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.atomic.AtomicInteger;

public class Thread34 {
    static AtomicInteger value = new AtomicInteger(0);
    public static void main(String[] args) throws Exception{
        //实现Runnable接口的方式
        new Thread(new RandomByRunnable()).start();
        //通过while去循环查询是否获取了值
        while (value.get() == 0);
        System.out.println("实现Runnable接口的线程（裸线程），获取了结果：" + value.get());

        //实现Runnable接口 + Executor框架的方式
        ExecutorService executorService = Executors.newCachedThreadPool();
        //重新初始化
        value = new AtomicInteger(0);
        executorService.submit(new RandomByRunnable());
        //通过while去循环查询是否获取了值
        while (value.get() == 0);
        System.out.println("实现Runnable接口的线程 + Executor框架，获取了结果：" + value.get());

        //实现Callable接口 + Executor框架
        Future<Integer> result = executorService.submit(new RandomByCallable());
        System.out.println("实现Callable接口 + Executor框架，获取了结果：" + result.get());
        executorService.shutdown();


    }


    static class RandomByRunnable implements Runnable{
        @Override
        public void run() {
            //模拟计算
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            Random random=new Random();
            //CAS赋值
            value.compareAndSet(0,random.nextInt(200));
        }
    }

    /**
     * 多线程示例-获取随机值-实现Callable接口
     */
    static class RandomByCallable implements Callable<Integer> {

        @Override
        public Integer call() throws Exception {
            Thread.sleep(1000);
            Random random=new Random();
            return random.nextInt(200);
        }
    }
}

线程池不允许使用Executors去创建，而是通过ThreadPoolExecutor的方式，这样的处理方式让写的同学更加明确线程池的运行规则，规避资源耗尽的风险。 说明：Executors返回的线程池对象的弊端如下：
1）FixedThreadPool和SingleThreadPool:
  允许的请求队列长度为Integer.MAX_VALUE，可能会堆积大量的请求，从而导致OOM。
2）CachedThreadPool:
  允许的创建线程数量为Integer.MAX_VALUE，可能会创建大量的线程，从而导致OOM。
            
Positive example 1：
    //org.apache.commons.lang3.concurrent.BasicThreadFactory
    ScheduledExecutorService executorService = new ScheduledThreadPoolExecutor(1,
        new BasicThreadFactory.Builder().namingPattern("example-schedule-pool-%d").daemon(true).build());
       
        
            
Positive example 2：
    ThreadFactory namedThreadFactory = new ThreadFactoryBuilder()
        .setNameFormat("demo-pool-%d").build();

    //Common Thread Pool
    ExecutorService pool = new ThreadPoolExecutor(5, 200,
        0L, TimeUnit.MILLISECONDS,
        new LinkedBlockingQueue<Runnable>(1024), namedThreadFactory, new ThreadPoolExecutor.AbortPolicy());

    pool.execute(()-> System.out.println(Thread.currentThread().getName()));
    pool.shutdown();//gracefully shutdown
       
        
            
Positive example 3：
    <bean id="userThreadPool"
        class="org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor">
        <property name="corePoolSize" value="10" />
        <property name="maxPoolSize" value="100" />
        <property name="queueCapacity" value="2000" />

    <property name="threadFactory" value= threadFactory />
        <property name="rejectedExecutionHandler">
            <ref local="rejectedExecutionHandler" />
        </property>
    </bean>
    //in code
    userThreadPool.execute(thread);c

 

运行结果：

实现Runnable接口的线程（裸线程），获取了结果：175
实现Runnable接口的线程 + Executor框架，获取了结果：163
实现Callable接口 + Executor框架，获取了结果：162