线程池例子

1：Java通过Executors提供四种线程池，分别为：
newCachedThreadPool创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。
newFixedThreadPool 创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。
newScheduledThreadPool 创建一个定长线程池，支持定时及周期性任务执行。
newSingleThreadExecutor 创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。

2：编写多线程程序一般有三种方法，Thread,Runnable,Callable.

Runnable和Callable的区别是，
(1)Callable规定的方法是call(),Runnable规定的方法是run().
(2)Callable的任务执行后可返回值，而Runnable的任务是不能返回值得
(3)call方法可以抛出异常，run方法不可以

(4)运行Callable任务可以拿到一个Future对象，Future 表示异步计算的结果。它提供了检查计算是否完成的方法，以等待计算的完成，并获取计算的结果。计算完成后只能使用 get 方法来获取结果，如果线程没有执行完，Future.get()方法可能会阻塞当前线程的执行；如果线程出现异常，Future.get()会throws InterruptedException或者ExecutionException；如果线程已经取消，会跑出CancellationException。取消由cancel 方法来执行。isDone确定任务是正常完成还是被取消了。一旦计算完成，就不能再取消计算。如果为了可取消性而使用 Future 但又不提供可用的结果，则可以声明Future<?> 形式类型、并返回 null 作为底层任务的结果。Future接口的定义如下：

 

Future模式
Future模式在请求发生时，会先产生一个Future凭证给发出请求的客户，它的作用就像是Proxy物件，同时，由一个新的执行线程持续进行目标物件的生成（Thread-Per-Message），真正的目标物件生成之后，将之设定至Future之中，而当客户端真正需要目标物件时，目标物件也已经准备好，可以让客户提取使用。
结合JDK的Future来看，就是你run线程后，你可以把线程的返回值赋给Future并返回一个Future对象。这时你可以立即拿到这个对象，然后进行下面的逻辑。但是如果你要get这个Future中的线程结果，就会被阻塞直到线程结束。
就相当于现在的期房，你把手续和钱都交上去了，就可以马上拿到合同，但只有合同没有房子。这个时候你已经是有房一族了，你可以先去买家电买装修（走下面的其他逻辑）。但是你要把家电和装修放进去，就必须等到房子完工（阻塞）。

 

               下面是一个线程池例子：

      计算1-100的和，分为10个线程来做，每个线程计算10个数的和。然后相加。

先定义callable<T>

package com.wanwan.common.util.threadpool;

import java.util.concurrent.Callable;

/**
 * Created by c_zhangyayun-001 on 2017/10/13.
 */
public class MyCallable implements Callable<Integer> {
    private Integer start;
    private Integer end;
    public MyCallable(Integer start, Integer end){
        this.start = start;
        this.end = end;
    }
    /**
     * Computes a result, or throws an exception if unable to do so.
     *
     * @return computed result
     * @throws Exception if unable to compute a result
     */
    @Override
    public Integer call() throws Exception {
        Integer sum = 0;
        for(int i = start; i <= end; i++){
            sum += i;
        }
        System.out.println(Thread.currentThread().getName() + " " +start + "-" + end + "=" + sum);
        return sum;
    }
}

线程方法：

package com.wanwan.common.util.threadpool;

import java.util.ArrayList;
import java.util.List;

import java.util.concurrent.*;

/**
 * Created by c_zhangyayun-001 on 2017/10/13.
 */
public class TestThreadPool {
    private static final int NTHREDS = 10;

    // 计算 1-100 的和 分给10个线程来做
    public static void main(String[] args) {
        //声明10个线程
        ExecutorService executor = Executors.newFixedThreadPool(10);
        List<Future<Integer>> futureList = new ArrayList<Future<Integer>>();
        //每个线程执行 10个数的和，10个线程并发
        for(int i=0; i < NTHREDS; i++){

            Future<Integer> submit = executor.submit(new MyCallable(i*NTHREDS+1, (i+1)*NTHREDS));
            futureList.add(submit);
        }
        long sum = 0;
        // 把十个结果相加
        for(Future<Integer> future : futureList){
            try{
                sum += future.get();
            }catch (InterruptedException e1){
                e1.printStackTrace();
            }catch(ExecutionException e2){
                e2.printStackTrace();
            }
        }
        executor.shutdown();
        System.out.println("sum = " + sum);
    }
}

转载于:https://my.oschina.net/u/559562/blog/1550355