一，详解并发包使用及其原理之线程池篇

线程池

一 , java.util.concurrent

 

1，首先，为什么要用线程池包？

 

1，用线程池包和数据库连接池一样，为了节省线程的创建和关闭时间

2，扩充了返回类型，实现runable只能通过共享数据和主线程通讯，通过callable 可以接受返回类型，并可以抛出异常在主线程捕获

3，扩充了些工具类

4，atomic支持计数 

 

 

线程池最常用代码应用方式，

1，实现Callable

2.  创建线程池

3.  执行并接收future参数

4.  关闭线程池，停止接收新的线程task

代码如下

 

 

package org.benson.concurrent;

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

/**
 * 
 * @author qq277803242
 *
 */
public class Test4ConcurrentPool implements Callable<String> {
	public static int result = 0;
	public final static int LOOP_COUNT = 500000;

	@Override
	public String call() throws Exception {
		System.out.println("run..");
		for (int i = 0; i < LOOP_COUNT; i++)
			result++;
		if(result>4500000)
		throw new Exception("my exception");
		return "result is " + result;
	}

	public static void main(String[] args) throws ExecutionException {
		ExecutorService execu = Executors.newFixedThreadPool(10);
		Future<String> future = null;
		for (int i = 0; i < 10; i++) {
			future = execu.submit(new Test4ConcurrentPool());
			try {
				System.out.println(future.get());
			} catch (Exception e) {
				System.out.println("here can catch Exception,the exception is "+e.getMessage());
				execu.shutdownNow();
				
			}
		}
		execu.shutdown();//reduce accept new task
//		execu.shutdownNow();//reduce accept new task and try to stop exit task
	}
}

 

　　

看代码这段可看到是调用了线程池创建了线程

 

//        ExecutorService execu = Executors.newFixedThreadPool(10);
        ExecutorService execu = new ThreadPoolExecutor(10, 10,
                0L, TimeUnit.MILLISECONDS,
                new LinkedBlockingQueue<Runnable>());

 

 

线程池的原理，工作流程如下

1，检查基本线程是否已满，如果未满创建新的线程

2，检查线程队列是否已满，如果未满创建新的等待线程填入队列

3，检查最大线程数是否已满，如果满了执行饱和线程策略

 

如此再返回看线程池的参数，很明确

 /**
     * Creates a new {@code ThreadPoolExecutor} with the given initial
     * parameters.
     *
     * @param corePoolSize the number of threads to keep in the pool, even
     *        if they are idle, unless {@code allowCoreThreadTimeOut} is set
     * @param maximumPoolSize the maximum number of threads to allow in the
     *        pool
     * @param keepAliveTime when the number of threads is greater than
     *        the core, this is the maximum time that excess idle threads
     *        will wait for new tasks before terminating.
     * @param unit the time unit for the {@code keepAliveTime} argument
     * @param workQueue the queue to use for holding tasks before they are
     *        executed.  This queue will hold only the {@code Runnable}
     *        tasks submitted by the {@code execute} method.
     * @param threadFactory the factory to use when the executor
     *        creates a new thread
     * @param handler the handler to use when execution is blocked
     *        because the thread bounds and queue capacities are reached
     * @throws IllegalArgumentException if one of the following holds:<br>
     *         {@code corePoolSize < 0}<br>
     *         {@code keepAliveTime < 0}<br>
     *         {@code maximumPoolSize <= 0}<br>
     *         {@code maximumPoolSize < corePoolSize}
     * @throws NullPointerException if {@code workQueue}
     *         or {@code threadFactory} or {@code handler} is null
     */
    public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue,
                              ThreadFactory threadFactory,
                              RejectedExecutionHandler handler)

按参数顺序解释如下:

corePoolSize 在线程池中的基本大小数

maximumPoolSize 线程池所允许的最大线程数目（包括队列中的线程数和基本线程中的）

keepAliveTime 线程空闲后，线程在线程池的保存时间。 线程池的作用就是为了减少创建和销毁线程池的时间，所以当运行线程很短，但很多，间隔时间长时，此个值可以设置大点

workQueue 线程池队列，runnableTaskQueue，阻塞线程，可选如下
runnableTaskQueue（任务队列）：用于保存等待执行的任务的阻塞队列。 可以选择以下几个阻塞队列。

• ArrayBlockingQueue：是一个基于数组结构的有界阻塞队列，此队列按 FIFO（先进先出）原则对元素进行排序。
• LinkedBlockingQueue：一个基于链表结构的阻塞队列，此队列按FIFO （先进先出） 排序元素，吞吐量通常要高于ArrayBlockingQueue。静态工厂方法Executors.newFixedThreadPool()使用了这个队列。
• SynchronousQueue：一个不存储元素的阻塞队列。每个插入操作必须等到另一个线程调用移除操作，否则插入操作一直处于阻塞状态，吞吐量通常要高于LinkedBlockingQueue，静态工厂方法Executors.newCachedThreadPool使用了这个队列。
• PriorityBlockingQueue：一个具有优先级的无限阻塞队列。

ThreadFactory，用于设置创建线程的工厂，可以通过线程工厂给每个创建出来的线程设置更有意义的名字。

RejectedExecutionHandler，饱和处理策略，用于处理线程饱和后的机制，有如下类型

• AbortPolicy：直接抛出异常。
• CallerRunsPolicy：只用调用者所在线程来运行任务。
• DiscardOldestPolicy：丢弃队列里最近的一个任务，并执行当前任务。
• DiscardPolicy：不处理，丢弃掉。

关于shutdownNow会循环线程池所有的线程，然后调用中断方法，中断方法抛出异常中断当前线程。

2，并发包提供的一些工具类，使用方法及其原理

 

java.util.concurrent.Semaphore信号灯，固定执行线程数量，每次执行5个线程，应用例子如下

package org.benson.concurrent;

import java.util.concurrent.Semaphore;

/**
 * 
 * @author qq277803242
 *
 */
public class Test4Semaphore implements Runnable {
	Semaphore semaphore=new Semaphore(5);
	@Override
	public void run() {
		try {
			semaphore.acquire();
		} catch (InterruptedException e) {
			System.out.println(e.getMessage());
		}
		System.out.println(Thread.currentThread().getName()
				+ " start runing 。。。");
		try {
			Thread.sleep(1000);
		} catch (InterruptedException e) {
			System.out.println(e.getMessage());
		}
		semaphore.release();
		System.out.println(Thread.currentThread().getName() + " finished");
	}
	public static void main(String[] args) {
		Runnable runable=new Test4Semaphore();
		for(int i=0;i<100;i++){
			new Thread(runable).start();
		}
	}
}

　　

 

最近把工作给辞了， 有时间了，想想还是分开篇幅写，总结下， 呵呵，到时也整理份目录出来，当作纪念

 

下篇打算讲讲基于Future 构建缓存

 

二 , java.util.concurrent.atomic

三 , java.util.concurrent.locks