java多线程基础知识

在大学的java课本上，或者是一些java理论知识里，都是这样子写着Java多线程的实现的：
1、继承java.lang.Thread，并重写它的run()方法。

public
class Thread implements Runnable {
...
@Override
    public void run() {
        if (target != null) {
            target.run();
        }
    }
...
}

2、实现java.lang.Runnable接口，实现它的run()方法。

public
interface Runnable {
    public abstract void run();
}

Thread本质上也是实现了Runnable接口的一个实例，也就是说实现多线程必须实现Runnable接口。但是这种实现方式有个弊端，那就是在执行完任务之后无法获取执行结果。因为void run()没有返回值。所以jdk1.5以后的版本，并非一定要实现了Runnable接口来实现多线程，JDK1.5提供了Callable和Future两个接口来实现多线程，通过它们可以在任务执行完毕之后得到任务执行结果。
Callable位于java.util.concurrent包下，它也是一个接口，里面也只声明了一个call()方法。

public interface Callable<V> {
    V call() throws Exception;
}

Future可以理解为用来表示Callable任务的执行操作，对线程任务的执行操作进行取消、查询是否完成、获取结果。绝大多数场景下，我们都是用get方法获取线程任务的执行结果，该方法会阻塞直到任务返回结果。用了Callable和Future会让多线程对我们而言变得非常透明。我们可以获得多线程的结果，在实际场景中应用广泛。

public interface Future<V> {
    /**
     * 取消任务（已经执行的任务肯定返回false,线程等待的任务肯定返回true）
     * mayInterruptIfRunning  是否允许取消正在执行却没有执行完毕的任务
     * return 是否取消任务成功    
     */
    boolean cancel(boolean mayInterruptIfRunning);
    /**
     * 任务是否被成功取消     
      */
    boolean isCancelled();
    /**
     * 任务是否已经完成     
      */
    boolean isDone();
    /**
     * 获取执行结果(主线程调用该方法时，会产生线程阻塞，等待任务完成返回结果)  
      */
    V get() throws InterruptedException, ExecutionException;
    /**
     * 用来获取执行结果，如果在指定时间内未返回结果，则返回null    
      */
    V get(long timeout, TimeUnit unit)
        throws InterruptedException, ExecutionException, TimeoutException;
}

Callable一般是和ExecutorService配合使用。ExecutorService线程池接口声明了<T> Future<T> submit(Callable<T> task)方法来执行Callable线程任务。

public class test {
	public static void main(String[] args) {
        ExecutorService executor = Executors.newCachedThreadPool();
        Future<String> result = executor.submit(new Callable<String>() {
			@Override
			public String call() throws Exception {
				Thread.sleep(5000);
				String s="succsss";
				return s;
			}
		});
        executor.shutdown();
        try {
            System.out.println("运行结果"+result.get());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}

在上面这个test代码中我们用到了Executors类，这个类很重要，它提供了一些工厂方法用于创建线程池，返回的线程池都实现了ExecutorService接口。

     /**
     * 创建固定数目线程的线程池    
     */
    public static ExecutorService newFixedThreadPool(int nThreads) {
        return new ThreadPoolExecutor(nThreads, nThreads,
                                      0L, TimeUnit.MILLISECONDS,
                                      new LinkedBlockingQueue<Runnable>());
    }
    /**
     * 创建一个单线程化的线程池    
     */
     public static ExecutorService newSingleThreadExecutor() {
        return new FinalizableDelegatedExecutorService
            (new ThreadPoolExecutor(1, 1,
                                    0L, TimeUnit.MILLISECONDS,
                                    new LinkedBlockingQueue<Runnable>()));
    }
    /**
     * 创建一个可缓存的线程池，调用execute 将重用以前构造的线程（如果线程可用）。如果现有线程没有可用的，则创建一个新线程并添加到池中。终止并从缓存中移除那些已有 60 秒钟未被使用的线程。
     */
     public static ExecutorService newCachedThreadPool() {
        return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                      60L, TimeUnit.SECONDS,
                                      new SynchronousQueue<Runnable>());
    }
    /**
     * 创建一个支持定时及周期性的任务执行的线程池，多数情况下可用来替代Timer类。    
     */
    public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) {
        return new ScheduledThreadPoolExecutor(corePoolSize);
    }

上面几个方法都返回了ThreadPoolExecutor类，它是ExecutorService的一个实现类，是线程池中最核心的一个类。使用Executors的工厂方法相当于调用了ThreadPoolExecutor类的构造方法，为我们配置好了ThreadPoolExecutor类的一些属性，方便我们的使用。下面是我查找的ThreadPoolExecutor的构造器中各个参数的含义：
1.corePoolSize：核心池的大小，这个参数跟后面讲述的线程池的实现原理有非常大的关系。在创建了线程池后，默认情况下，线程池中并没有任何线程，而是等待有任务到来才创建线程去执行任务，除非调用了prestartAllCoreThreads()或者prestartCoreThread()方法，从这2个方法的名字就可以看出，是预创建线程的意思，即在没有任务到来之前就创建corePoolSize个线程或者一个线程。默认情况下，在创建了线程池后，线程池中的线程数为0，当有任务来之后，就会创建一个线程去执行任务，当线程池中的线程数目达到corePoolSize后，就会把到达的任务放到缓存队列当中；
2.maximumPoolSize：线程池最大线程数，这个参数也是一个非常重要的参数，它表示在线程池中最多能创建多少个线程；
3.keepAliveTime：表示线程没有任务执行时最多保持多久时间会终止。默认情况下，只有当线程池中的线程数大于corePoolSize时，keepAliveTime才会起作用，直到线程池中的线程数不大于corePoolSize，即当线程池中的线程数大于corePoolSize时，如果一个线程空闲的时间达到keepAliveTime，则会终止，直到线程池中的线程数不超过corePoolSize。但是如果调用了allowCoreThreadTimeOut(boolean)方法，在线程池中的线程数不大于corePoolSize时，keepAliveTime参数也会起作用，直到线程池中的线程数为0；
4.参数keepAliveTime的时间单位，有7种取值，在TimeUnit类中有7种静态属性：

TimeUnit.DAYS;               //天
TimeUnit.HOURS;             //小时
TimeUnit.MINUTES;           //分钟
TimeUnit.SECONDS;           //秒
TimeUnit.MILLISECONDS;      //毫秒
TimeUnit.MICROSECONDS;      //微妙
TimeUnit.NANOSECONDS;       //纳秒

5.workQueue：一个阻塞队列，用来存储等待执行的任务，这个参数的选择也很重要，会对线程池的运行过程产生重大影响，一般来说，这里的阻塞队列有以下几种选择：

ArrayBlockingQueue;
LinkedBlockingQueue;
SynchronousQueue;

ArrayBlockingQueue和PriorityBlockingQueue使用较少，一般使用LinkedBlockingQueue和Synchronous。线程池的排队策略与BlockingQueue有关。
6.threadFactory：线程工厂，主要用来创建线程；
7.handler：表示当拒绝处理任务时的策略，有以下四种取值：

ThreadPoolExecutor.AbortPolicy:丢弃任务并抛出RejectedExecutionException异常。 
ThreadPoolExecutor.DiscardPolicy：也是丢弃任务，但是不抛出异常。 
ThreadPoolExecutor.DiscardOldestPolicy：丢弃队列最前面的任务，然后重新尝试执行任务（重复此过程）
ThreadPoolExecutor.CallerRunsPolicy：由调用线程处理该任务

任务提交给线程池之后的处理策略，这里总结一下主要有4点：
1.如果当前线程池中的线程数目小于corePoolSize，则每来一个任务，就会创建一个线程去执行这个任务；
2.如果当前线程池中的线程数目>=corePoolSize，则每来一个任务，会尝试将其添加到任务缓存队列当中，若添加成功，则该任务会等待空闲线程将其取出去执行；若添加失败（一般来说是任务缓存队列已满），则会尝试创建新的线程去执行这个任务；
3.如果当前线程池中的线程数目达到maximumPoolSize，则会采取任务拒绝策略进行处理；
4.如果线程池中的线程数量大于 corePoolSize时，如果某线程空闲时间超过keepAliveTime，线程将被终止，直至线程池中的线程数目不大于corePoolSize；如果允许为核心池中的线程设置存活时间，那么核心池中的线程空闲时间超过keepAliveTime，线程也会被终止。
顺便提下spring的线程池org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor。
一般用spring配置实例化。

<bean id="taskExecutor" class="org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor">
	  <!-- 核心线程数 -->	 
	  <property name="corePoolSize" value="10" />
	  <!-- 最大线程数 -->  
	  <property name="maxPoolSize" value="1000" />
	  <!-- 队列最大长度 -->
	  <property name="queueCapacity" value="1000" />
	  <!-- 线程池维护线程所允许的空闲时间，默认为60s -->
	  <property name="keepAliveSeconds" value="300" />
</bean>

对于spring管理的类调用线程池：

@Resource(name = "taskExecutor")
	private ThreadPoolTaskExecutor taskExecutor;

对于非spring管理的类调用线程池：

ApplicationContext ctx =  new ClassPathXmlApplicationContext("applicationContext.xml");
ThreadPoolTaskExecutor poolTaskExecutor = (ThreadPoolTaskExecutor)ctx.getBean("taskExecutor");

本文粗略介绍JAVA并发编程的基础知识，线程池相关知识引用了http://www.importnew.com/19011.html中的介绍。