java.util.concurrent 中的学习

在学习java.util.concurrent 相关中，首先发现了这样的一个神贴：

http://www.iteye.com/topic/366591

 

 

不过 首先要弄明白concurrent中的许多概念，以及之间的关系。

 

线程池: 实现了ExecutorService接口 以及子接口ScheduledExecutorService

 

Executors类，提供了一系列工厂方法用于创先线程池

 

 

 

static ExecutorService	newCachedThreadPool ()             创建一个可根据需要创建新线程的线程池，但是在以前构造的线程可用时将重用它们。
static ExecutorService	newCachedThreadPool (ThreadFactory  threadFactory)             创建一个可根据需要创建新线程的线程池，但是在以前构造的线程可用时将重用它们，并在需要时使用提供的 ThreadFactory 创建新线程。
static ExecutorService	newFixedThreadPool (int nThreads)             创建一个可重用固定线程数的线程池，以共享的无界队列方式来运行这些线程。
static ExecutorService	newFixedThreadPool (int nThreads,  ThreadFactory  threadFactory)             创建一个可重用固定线程数的线程池，以共享的无界队列方式来运行这些线程，在需要时使用提供的 ThreadFactory 创建新线程。
static ScheduledExecutorService	newScheduledThreadPool (int corePoolSize)             创建一个线程池，它可安排在给定延迟后运行命令或者定期地执行。
static ScheduledExecutorService	newScheduledThreadPool (int corePoolSize,  ThreadFactory  threadFactory)             创建一个线程池，它可安排在给定延迟后运行命令或者定期地执行。
static ExecutorService	newSingleThreadExecutor ()             创建一个使用单个 worker 线程的 Executor，以无界队列方式来运行该线程。
static ExecutorService	newSingleThreadExecutor (ThreadFactory  threadFactory)             创建一个使用单个 worker 线程的 Executor，以无界队列方式来运行该线程，并在需要时使用提供的 ThreadFactory 创建新线程。
static ScheduledExecutorService	newSingleThreadScheduledExecutor ()             创建一个单线程执行程序，它可安排在给定延迟后运行命令或者定期地执行。
static ScheduledExecutorService	newSingleThreadScheduledExecutor (ThreadFactory  threadFactory)             创建一个单线程执行程序，它可安排在给定延迟后运行命令或者定期地执行。

 

 

 

    CachedThreadPool:

public static ExecutorService newCachedThreadPool() {
        return new ThreadPoolExecutor
(0, Integer.MAX_VALUE,
                                      60L, TimeUnit.SECONDS,
                                      new SynchronousQueue<Runnable>());
    }

 

    SingleThreadExecutor:

public static ExecutorService newSingleThreadExecutor() {
        return new FinalizableDelegatedExecutorService
            (new ThreadPoolExecutor(1, 1,
                                    0L, TimeUnit.MILLISECONDS,
                                    new LinkedBlockingQueue<Runnable>
()));
    }

 

    FixedThreadPool:

public static ExecutorService newFixedThreadPool(int nThreads) {
        return new ThreadPoolExecutor(nThreads, nThreads,
                                      0L, TimeUnit.MILLISECONDS,
                                      new LinkedBlockingQueue<Runnable>());
    }

 

    注意这几个里面BlockingQueue的区别

 

ThreadPoolExecutor (int corePoolSize, int maximumPoolSize, long keepAliveTime,  TimeUnit  unit,  BlockingQueue <Runnable > workQueue)  
用给定的初始参数和默认的线程工厂及被拒绝的执行处理程序创建新的ThreadPoolExecutor 。

 

 

看源码的时候 发现了一些概念 记录下

volatile  http://zhidao.baidu.com/question/12947255.html?fr=ala0

AtomicInteger  http://blog.sina.com.cn/s/blog_473f547b0100ktap.html