package ThreadPool;
    
    import com.sun.istack.internal.logging.Logger;
    
    import java.util.concurrent.*;
    import java.util.concurrent.atomic.AtomicInteger;
    
    public class ThreadPoolManage {
    
        private static final Logger logger = Logger.getLogger(ThreadPoolManage.class);
    
        private AtomicInteger threadId = new AtomicInteger(0);
        private String prefix;
        private int poolSiza;
        private ThreadPoolExecutor threadPoolExecutor;
    
        public ThreadPoolManage(int poolSiza, String prefix) {
            this.poolSiza = poolSiza;
            this.prefix = prefix;
        }
    
        /**
         * 创建固定线程池
         */
        public void buildThreadPool() {
            logger.info("build threadPoll");
    
    
            this.threadPoolExecutor = new ThreadPoolExecutor(poolSiza, poolSiza,
                    0L, TimeUnit.MILLISECONDS,
                    new LinkedBlockingQueue<Runnable>(),
                    new ThreadFactory() {
                        @Override
                        public Thread newThread(Runnable r) {
                            return new Thread(r, prefix + threadId.getAndIncrement());
                        }
                    }
            ) {
                @Override
                protected void afterExecute(Runnable r, Throwable t) {
                    super.afterExecute(r, t);
                    printException(r, t);
                }
    
                private void printException(Runnable r, Throwable t) {
                    if (t == null && r instanceof Future<?>) {
                        try {
                            Future<?> future = (Future<?>) r;
                            if (future.isDone()) {
                                future.get();
                            }
                        } catch (CancellationException ce) {
                            t = ce;
                        } catch (ExecutionException ee) {
                            t = ee.getCause();
                        } catch (InterruptedException ie) {
                            Thread.currentThread().interrupt();
                        }
                    }
                    if (t != null) {
                        logger.warning(t.getMessage(), t);
                    }
                }
            };
        }
        public void closeThreadPool() {
            logger.info("close thread pool");
            threadPoolExecutor.shutdown();
            try {
                threadPoolExecutor.awaitTermination(1, TimeUnit.DAYS);
            } catch (InterruptedException e) {
                logger.warning(e.getMessage());
            }
        }
    }
    
    
    
    

    // toArray(T[] contents)调用方式一
    public static Integer[] vectorToArray1(ArrayList<Integer> v) {
        Integer[] newText = new Integer[v.size()];
        v.toArray(newText);
        return newText;
    }
    // toArray(T[] contents)调用方式二。最常用！
    public static Integer[] vectorToArray2(ArrayList<Integer> v) {
        Integer[] newText = (Integer[])v.toArray(new Integer[0]);
        return newText;
    }
    // toArray(T[] contents)调用方式三
    public static Integer[] vectorToArray3(ArrayList<Integer> v) {
        Integer[] newText = new Integer[v.size()];
        Integer[] newStrings = (Integer[])v.toArray(newText);
        return newStrings;
    }
   
源码：
   
    package java.util;
    
    public class ArrayList<E> extends AbstractList<E>
            implements List<E>, RandomAccess, Cloneable, java.io.Serializable
    {
        // 序列版本号
        private static final long serialVersionUID = 8683452581122892189L;
    
        // 保存ArrayList中数据的数组
        private transient Object[] elementData;
    
        // ArrayList中实际数据的数量
        private int size;
    
        // ArrayList带容量大小的构造函数。
        public ArrayList(int initialCapacity) {
            super();
            if (initialCapacity < 0)
                throw new IllegalArgumentException("Illegal Capacity: "+
                                                   initialCapacity);
            // 新建一个数组
            this.elementData = new Object[initialCapacity];
        }
    
        // ArrayList构造函数。默认容量是10。
        public ArrayList() {
            this(10);
        }
    
        // 创建一个包含collection的ArrayList
        public ArrayList(Collection<? extends E> c) {
            elementData = c.toArray();
            size = elementData.length;
            // c.toArray might (incorrectly) not return Object[] (see 6260652)
            if (elementData.getClass() != Object[].class)
                elementData = Arrays.copyOf(elementData, size, Object[].class);
        }
    
    
        // 将当前容量值设为 =实际元素个数
        public void trimToSize() {
            modCount++;
            int oldCapacity = elementData.length;
            if (size < oldCapacity) {
                elementData = Arrays.copyOf(elementData, size);
            }
        }
    
    
        // 确定ArrarList的容量。
        // 若ArrayList的容量不足以容纳当前的全部元素，设置 新的容量=“(原始容量x3)/2 + 1”
        public void ensureCapacity(int minCapacity) {
            // 将“修改统计数”+1
            modCount++;
            int oldCapacity = elementData.length;
            // 若当前容量不足以容纳当前的元素个数，设置 新的容量=“(原始容量x3)/2 + 1”
            if (minCapacity > oldCapacity) {
                Object oldData[] = elementData;
                int newCapacity = (oldCapacity * 3)/2 + 1;
                if (newCapacity < minCapacity)
                    newCapacity = minCapacity;
                elementData = Arrays.copyOf(elementData, newCapacity);
            }
        }
    
        // 添加元素e
        public boolean add(E e) {
            // 确定ArrayList的容量大小
            ensureCapacity(size + 1);  // Increments modCount!!
            // 添加e到ArrayList中
            elementData[size++] = e;
            return true;
        }
    
        // 返回ArrayList的实际大小
        public int size() {
            return size;
        }
    
        // 返回ArrayList是否包含Object(o)
        public boolean contains(Object o) {
            return indexOf(o) >= 0;
        }
    
        // 返回ArrayList是否为空
        public boolean isEmpty() {
            return size == 0;
        }
    
        // 正向查找，返回元素的索引值
        public int indexOf(Object o) {
            if (o == null) {
                for (int i = 0; i < size; i++)
                if (elementData[i]==null)
                    return i;
                } else {
                    for (int i = 0; i < size; i++)
                    if (o.equals(elementData[i]))
                        return i;
                }
                return -1;
            }
    
            // 反向查找，返回元素的索引值
            public int lastIndexOf(Object o) {
            if (o == null) {
                for (int i = size-1; i >= 0; i--)
                if (elementData[i]==null)
                    return i;
            } else {
                for (int i = size-1; i >= 0; i--)
                if (o.equals(elementData[i]))
                    return i;
            }
            return -1;
        }
    
        // 反向查找(从数组末尾向开始查找)，返回元素(o)的索引值
        public int lastIndexOf(Object o) {
            if (o == null) {
                for (int i = size-1; i >= 0; i--)
                if (elementData[i]==null)
                    return i;
            } else {
                for (int i = size-1; i >= 0; i--)
                if (o.equals(elementData[i]))
                    return i;
            }
            return -1;
        }
     
    
        // 返回ArrayList的Object数组
        public Object[] toArray() {
            return Arrays.copyOf(elementData, size);
        }
    
        // 返回ArrayList的模板数组。所谓模板数组，即可以将T设为任意的数据类型
        public <T> T[] toArray(T[] a) {
            // 若数组a的大小 < ArrayList的元素个数；
            // 则新建一个T[]数组，数组大小是“ArrayList的元素个数”，并将“ArrayList”全部拷贝到新数组中
            if (a.length < size)
                return (T[]) Arrays.copyOf(elementData, size, a.getClass());
    
            // 若数组a的大小 >= ArrayList的元素个数；
            // 则将ArrayList的全部元素都拷贝到数组a中。
            System.arraycopy(elementData, 0, a, 0, size);
            if (a.length > size)
                a[size] = null;
            return a;
        }
    
        // 获取index位置的元素值
        public E get(int index) {
            RangeCheck(index);
    
            return (E) elementData[index];
        }
    
        // 设置index位置的值为element
        public E set(int index, E element) {
            RangeCheck(index);
    
            E oldValue = (E) elementData[index];
            elementData[index] = element;
            return oldValue;
        }
    
        // 将e添加到ArrayList中
        public boolean add(E e) {
            ensureCapacity(size + 1);  // Increments modCount!!
            elementData[size++] = e;
            return true;
        }
    
        // 将e添加到ArrayList的指定位置
        public void add(int index, E element) {
            if (index > size || index < 0)
                throw new IndexOutOfBoundsException(
                "Index: "+index+", Size: "+size);
    
            ensureCapacity(size+1);  // Increments modCount!!
            System.arraycopy(elementData, index, elementData, index + 1,
                 size - index);
            elementData[index] = element;
            size++;
        }
    
        // 删除ArrayList指定位置的元素
        public E remove(int index) {
            RangeCheck(index);
    
            modCount++;
            E oldValue = (E) elementData[index];
    
            int numMoved = size - index - 1;
            if (numMoved > 0)
                System.arraycopy(elementData, index+1, elementData, index,
                     numMoved);
            elementData[--size] = null; // Let gc do its work
    
            return oldValue;
        }
    
        // 删除ArrayList的指定元素
        public boolean remove(Object o) {
            if (o == null) {
                    for (int index = 0; index < size; index++)
                if (elementData[index] == null) {
                    fastRemove(index);
                    return true;
                }
            } else {
                for (int index = 0; index < size; index++)
                if (o.equals(elementData[index])) {
                    fastRemove(index);
                    return true;
                }
            }
            return false;
        }
    
    
        // 快速删除第index个元素
        private void fastRemove(int index) {
            modCount++;
            int numMoved = size - index - 1;
            // 从"index+1"开始，用后面的元素替换前面的元素。
            if (numMoved > 0)
                System.arraycopy(elementData, index+1, elementData, index,
                                 numMoved);
            // 将最后一个元素设为null
            elementData[--size] = null; // Let gc do its work
        }
    
        // 删除元素
        public boolean remove(Object o) {
            if (o == null) {
                for (int index = 0; index < size; index++)
                if (elementData[index] == null) {
                    fastRemove(index);
                return true;
                }
            } else {
                // 便利ArrayList，找到“元素o”，则删除，并返回true。
                for (int index = 0; index < size; index++)
                if (o.equals(elementData[index])) {
                    fastRemove(index);
                return true;
                }
            }
            return false;
        }
    
        // 清空ArrayList，将全部的元素设为null
        public void clear() {
            modCount++;
    
            for (int i = 0; i < size; i++)
                elementData[i] = null;
    
            size = 0;
        }
    
        // 将集合c追加到ArrayList中
        public boolean addAll(Collection<? extends E> c) {
            Object[] a = c.toArray();
            int numNew = a.length;
            ensureCapacity(size + numNew);  // Increments modCount
            System.arraycopy(a, 0, elementData, size, numNew);
            size += numNew;
            return numNew != 0;
        }
    
        // 从index位置开始，将集合c添加到ArrayList
        public boolean addAll(int index, Collection<? extends E> c) {
            if (index > size || index < 0)
                throw new IndexOutOfBoundsException(
                "Index: " + index + ", Size: " + size);
    
            Object[] a = c.toArray();
            int numNew = a.length;
            ensureCapacity(size + numNew);  // Increments modCount
    
            int numMoved = size - index;
            if (numMoved > 0)
                System.arraycopy(elementData, index, elementData, index + numNew,
                     numMoved);
    
            System.arraycopy(a, 0, elementData, index, numNew);
            size += numNew;
            return numNew != 0;
        }
    
        // 删除fromIndex到toIndex之间的全部元素。
        protected void removeRange(int fromIndex, int toIndex) {
        modCount++;
        int numMoved = size - toIndex;
            System.arraycopy(elementData, toIndex, elementData, fromIndex,
                             numMoved);
    
        // Let gc do its work
        int newSize = size - (toIndex-fromIndex);
        while (size != newSize)
            elementData[--size] = null;
        }
    
        private void RangeCheck(int index) {
        if (index >= size)
            throw new IndexOutOfBoundsException(
            "Index: "+index+", Size: "+size);
        }
    
    
        // 克隆函数
        public Object clone() {
            try {
                ArrayList<E> v = (ArrayList<E>) super.clone();
                // 将当前ArrayList的全部元素拷贝到v中
                v.elementData = Arrays.copyOf(elementData, size);
                v.modCount = 0;
                return v;
            } catch (CloneNotSupportedException e) {
                // this shouldn't happen, since we are Cloneable
                throw new InternalError();
            }
        }
    
    
        // java.io.Serializable的写入函数
        // 将ArrayList的“容量，所有的元素值”都写入到输出流中
        private void writeObject(java.io.ObjectOutputStream s)
            throws java.io.IOException{
        // Write out element count, and any hidden stuff
        int expectedModCount = modCount;
        s.defaultWriteObject();
    
            // 写入“数组的容量”
            s.writeInt(elementData.length);
    
        // 写入“数组的每一个元素”
        for (int i=0; i<size; i++)
                s.writeObject(elementData[i]);
    
        if (modCount != expectedModCount) {
                throw new ConcurrentModificationException();
            }
    
        }
    
    
        // java.io.Serializable的读取函数：根据写入方式读出
        // 先将ArrayList的“容量”读出，然后将“所有的元素值”读出
        private void readObject(java.io.ObjectInputStream s)
            throws java.io.IOException, ClassNotFoundException {
            // Read in size, and any hidden stuff
            s.defaultReadObject();
    
            // 从输入流中读取ArrayList的“容量”
            int arrayLength = s.readInt();
            Object[] a = elementData = new Object[arrayLength];
    
            // 从输入流中将“所有的元素值”读出
            for (int i=0; i<size; i++)
                a[i] = s.readObject();
        }
    }

    public ThreadPoolExecutor(int corePoolSize,
                                  int maximumPoolSize,
                                  long keepAliveTime,
                                  TimeUnit unit,
                                  BlockingQueue<Runnable> workQueue) {
            this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
                 Executors.defaultThreadFactory(), defaultHandler);
        }

    public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue,
                              ThreadFactory threadFactory) {
        this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
             threadFactory, defaultHandler);
    }

    public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue,
                              RejectedExecutionHandler handler) {
        this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
             Executors.defaultThreadFactory(), handler);
    }

    public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue,
                              ThreadFactory threadFactory,
                              RejectedExecutionHandler handler) {
        if (corePoolSize < 0 ||
            maximumPoolSize <= 0 ||
            maximumPoolSize < corePoolSize ||
            keepAliveTime < 0)
            throw new IllegalArgumentException();
        if (workQueue == null || threadFactory == null || handler == null)
            throw new NullPointerException();
        this.corePoolSize = corePoolSize;
        this.maximumPoolSize = maximumPoolSize;
        this.workQueue = workQueue;
        this.keepAliveTime = unit.toNanos(keepAliveTime);
        this.threadFactory = threadFactory;
        this.handler = handler;
    }

    public abstract class AbstractExecutorService implements ExecutorService {
        protected <T> RunnableFuture<T> newTaskFor(Runnable runnable, T value) {
            return new FutureTask<T>(runnable, value);
        }
        protected <T> RunnableFuture<T> newTaskFor(Callable<T> callable) {
            return new FutureTask<T>(callable);
        }
        //submit函数1
        public Future<?> submit(Runnable task) {
            if (task == null) throw new NullPointerException();
            RunnableFuture<Void> ftask = newTaskFor(task, null);
            execute(ftask);
            return ftask;
        }
        //submit函数2
        public <T> Future<T> submit(Runnable task, T result) {
            if (task == null) throw new NullPointerException();
            RunnableFuture<T> ftask = newTaskFor(task, result);
            execute(ftask);
            return ftask;
        }
        //submit函数3
        public <T> Future<T> submit(Callable<T> task) {
            if (task == null) throw new NullPointerException();
            RunnableFuture<T> ftask = newTaskFor(task);
            execute(ftask);
            return ftask;
        }
        private <T> T doInvokeAny(Collection<? extends Callable<T>> tasks,boolean timed, long nanos) throws InterruptedException, ExecutionException, TimeoutException {······}
        public <T> T invokeAny(Collection<? extends Callable<T>> tasks,long timeout, TimeUnit unit)throws InterruptedException, ExecutionException, TimeoutException {······}
        public <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks,long timeout, TimeUnit unit)throws InterruptedException {
    }    

    public interface ExecutorService extends Executor {
        void shutdown();
        List<Runnable> shutdownNow();
        boolean isShutdown();
        boolean isTerminated();
        boolean awaitTermination(long timeout, TimeUnit unit) throws InterruptedException;
        <T> Future<T> submit(Callable<T> task);
        <T> Future<T> submit(Runnable task, T result);
        Future<?> submit(Runnable task);
        <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks) throws InterruptedException;
        <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks,long timeout, TimeUnit unit) throws InterruptedException;
        <T> T invokeAny(Collection<? extends Callable<T>> tasks) throws InterruptedException, ExecutionException;
        <T> T invokeAny(Collection<? extends Callable<T>> tasks,long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException;
    }

   public interface Executor {
       void execute(Runnable command);
   }
   

    volatile int runState;
    static final int RUNNING    = 0;
    static final int SHUTDOWN   = 1;
    static final int STOP       = 2;
    static final int TERMINATED = 3;

    private final BlockingQueue<Runnable> workQueue;              //任务缓存队列，用来存放等待执行的任务
    private final ReentrantLock mainLock = new ReentrantLock();   //线程池的主要状态锁，对线程池状态（runState等）的改变都要使用这个锁
    private final HashSet<Worker> workers = new HashSet<Worker>();  //用来存放工作集
    private volatile long  keepAliveTime;    //线程存货时间   
    private volatile boolean allowCoreThreadTimeOut;   //是否允许为核心线程设置存活时间
    private volatile int   corePoolSize;     //核心池的大小（即线程池中的线程数目大于这个参数时，提交的任务会被放进任务缓存队列）
    private volatile int   maximumPoolSize;   //线程池最大能容忍的线程数
    private volatile int   poolSize;       //线程池中当前的线程数
    private volatile RejectedExecutionHandler handler; //任务拒绝策略
    private volatile ThreadFactory threadFactory;   //线程工厂，用来创建线程
    private int largestPoolSize;   //用来记录线程池中曾经出现过的最大线程数
    private long completedTaskCount;   //用来记录已经执行完毕的任务个数

    //初始化核心线程池一个线程
    public boolean prestartCoreThread() {
        return addIfUnderCorePoolSize(null); //注意传进去的参数是null
    }
    //初始化核心线程池所有线程
    public int prestartAllCoreThreads() {
        int n = 0;
        while (addIfUnderCorePoolSize(null))//注意传进去的参数是null
            ++n;
        return n;
    }

    public void execute(Runnable command) {
        if (command == null)
            throw new NullPointerException();
        //获取ctl，主线程控制状态ctl是包装两个概念的原子整数，其中workerCount指代有效线程数，runState指代线程是运行还是停止等。
        int c = ctl.get();
        //保证增加工作线程时，ctl可以实时更新。
        if (workerCountOf(c) < corePoolSize) {
            if (addWorker(command, true))
                return;
            c = ctl.get();
        }
        //保证任务可以在新线程或合并线程中运行
        if (isRunning(c) && workQueue.offer(command)) {
            int recheck = ctl.get();
            if (! isRunning(recheck) && remove(command))
                reject(command);
            else if (workerCountOf(recheck) == 0)
                addWorker(null, false);
        }
        else if (!addWorker(command, false))
            reject(command);
    }    

    public void shutdown() {
        //声明一个重入锁
        final ReentrantLock mainLock = this.mainLock;
        mainLock.lock();
        //关闭线程
        try {
            //确保有权限关闭线程
            checkShutdownAccess();
            //将运行状态转化为跟定目标
            advanceRunState(SHUTDOWN);
            //中断线程，等待未执行的任务
            interruptIdleWorkers();
            onShutdown();
        } finally {
            mainLock.unlock();
        }
        tryTerminate();
    }

    public boolean isShutdown() {
        return ! isRunning(ctl.get());
    }
 ```java   
#### isTerminated()方法分析
当所有的任务都已关闭后,才表示线程池关闭成功，这时调用isTerminaed方法会返回true。
```java
    public boolean isTerminated() {
        return runStateAtLeast(ctl.get(), TERMINATED);
    }

    public boolean remove(Runnable task) {
        boolean removed = workQueue.remove(task);
        tryTerminate(); 
        return removed;
    }

    public void purge() {
        final BlockingQueue<Runnable> q = workQueue;
        try {
            Iterator<Runnable> it = q.iterator();
            while (it.hasNext()) {
                Runnable r = it.next();
                if (r instanceof Future<?> && ((Future<?>)r).isCancelled())
                    it.remove();
            }
        } catch (ConcurrentModificationException fallThrough) {
            for (Object r : q.toArray())
                if (r instanceof Future<?> && ((Future<?>)r).isCancelled())
                    q.remove(r);
        }
        tryTerminate(); 
    }

    public int getPoolSize() {
        final ReentrantLock mainLock = this.mainLock;
        mainLock.lock();
        try {
            return runStateAtLeast(ctl.get(), TIDYING) ? 0
                : workers.size();
        } finally {
            mainLock.unlock();
        }
    }

      public int getActiveCount() {
        final ReentrantLock mainLock = this.mainLock;
        mainLock.lock();
        try {
            int n = 0;
            for (Worker w : workers)
                if (w.isLocked())
                    ++n;
            return n;
        } finally {
            mainLock.unlock();
        }
    }

    public int getLargestPoolSize() {
        final ReentrantLock mainLock = this.mainLock;
        mainLock.lock();
        try {
            return largestPoolSize;
        } finally {
            mainLock.unlock();
        }
    }

    public long getTaskCount() {
            final ReentrantLock mainLock = this.mainLock;
            mainLock.lock();
            try {
                //已经完成的任务数
                long n = completedTaskCount;
                //加上正在线程池执行的任务数
                for (Worker w : workers) {
                    n += w.completedTasks;
                    if (w.isLocked())
                        ++n;
                }
                //再加上工作队列中等待的任务数
                return n + workQueue.size();
            } finally {
                mainLock.unlock();
            }
        }

    public String toString() {
        long ncompleted;
        int nworkers, nactive;
        final ReentrantLock mainLock = this.mainLock;
        mainLock.lock();
        try {
            ncompleted = completedTaskCount;
            nactive = 0;
            nworkers = workers.size();
            for (Worker w : workers) {
                ncompleted += w.completedTasks;
                if (w.isLocked())
                    ++nactive;
            }
        } finally {
            mainLock.unlock();
        }
        int c = ctl.get();
        String rs = (runStateLessThan(c, SHUTDOWN) ? "Running" :
                     (runStateAtLeast(c, TERMINATED) ? "Terminated" :
                      "Shutting down"));
        return super.toString() +
            "[" + rs +
            ", pool size = " + nworkers +
            ", active threads = " + nactive +
            ", queued tasks = " + workQueue.size() +
            ", completed tasks = " + ncompleted +
            "]";
    }

    public class Test {
         public static void main(String[] args) {   
             ThreadPoolExecutor executor = new ThreadPoolExecutor(5, 10, 200, TimeUnit.MILLISECONDS,
                     new ArrayBlockingQueue<Runnable>(5));
              
             for(int i=0;i<15;i++){
                 MyTask myTask = new MyTask(i);
                 executor.execute(myTask);
                 System.out.println("线程池中线程数目："+executor.getPoolSize()+"，队列中等待执行的任务数目："+
                 executor.getQueue().size()+"，已执行玩别的任务数目："+executor.getCompletedTaskCount());
             }
             executor.shutdown();
         }
    }
    class MyTask implements Runnable {
        private int taskNum;
         
        public MyTask(int num) {
            this.taskNum = num;
        }
         
        @Override
        public void run() {
            System.out.println("正在执行task "+taskNum);
            try {
                Thread.currentThread().sleep(4000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("task "+taskNum+"执行完毕");
        }
    }

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

	class CurrentThreadDemo {
	    public static void main(String args[]) {
	        Thread t = Thread.currentThread();
	        System.out.println("Current thread: " + t);
	        // change the name of the thread
	        t.setName("My Thread");
	        System.out.println("After name change: " + t);
	        try {
	            for(int n = 5; n > 0; n--) {
	                System.out.println(n);
	                Thread.sleep(1000);
	            }
	        } catch (InterruptedException e) {
	            System.out.println("Main thread interrupted");
	        }
	    }
	}

	final void setName(String threadName)
	final String getName()

## Thread类

	class testThread extend Thread{
		private String name;
		public testThread(){
			this.name = name;
		}
		public void run(){
			for(int i=0;i<5;i++){
				System.out.println(name+"running: "+i);
			}try{
				sleep((int) Math.random()*10);
			}catch(InterruptedException e){
				e.printStackTrace();
			}
		}
	}
	public class Main{
		public static void main(String[] args){
			testThread thread_1 = new testThread("A");
			testThread thread_2 = new testThread("B");
			thread_1.start();
			thread_2.start();
		}
	}

	import static java.lang.Thread.sleep;
	class testThread implements Runnable{
	    private String name;
	    public testThread(String name){
	        this.name = name;
	    }
	    public void run(){
	        for (int i=0;i<5;i++){
	            System.out.println(name+" running: "+i);
	        }try{
	            Thread.sleep((int)Math.random()*10);
	        }catch (InterruptedException e){
	            e.printStackTrace();
	        }
	    }
	}
	public class Main{
	    public static void main(String[] args) {
	        testThread thread_1 = new testThread("C");
	        testThread thread_2 = new testThread("D");
	        new Thread(thread_1).start();
	        new Thread(thread_2).start();
	    }
	}

	import static java.lang.Thread.sleep;
	class testThread implements Runnable{
	    private String name;
	    public testThread(String name){
	        this.name = name;
	    }
	    public void run(){
	        System.out.println(Thread.currentThread().getName()+" 线程开始运行");
	        for(int i=0;i<5;i++) {
	            System.out.println(name + " running " + i);
	            try {
	                sleep((int) Math.random() * 10);
	            } catch (InterruptedException e) {
	                e.printStackTrace();
	            }
	        }
	        System.out.println(Thread.currentThread().getName()+" 线程运行结束");
	    }
	}
	public class Main{
	    public static void main(String[] args) {
	        System.out.println(Thread.currentThread().getName()+ " 主线程开始运行");
	        new Thread(new testThread("E")).start();
	        new Thread(new testThread("F")).start();
	        System.out.println(Thread.currentThread().getName()+ " 主线程运行结束");
	    }
	}

	import static java.lang.Thread.sleep;
	class testThread implements Runnable{
	    private String name;
	    public testThread(String name){
	        this.name = name;
	    }
	    public void run(){
	        System.out.println(Thread.currentThread().getName()+" 线程开始运行");
	        for(int i=0;i<5;i++) {
	            System.out.println(name + " running " + i);
	            try {
	                sleep((int) Math.random() * 10);
	            } catch (InterruptedException e) {
	                e.printStackTrace();
	            }
	        }
	        System.out.println(Thread.currentThread().getName()+" 线程运行结束");
	    }
	}
	public class Main{
	    public static void main(String[] args) {
	        System.out.println(Thread.currentThread().getName()+ " 主线程开始运行");
	        Thread thread_1 = new Thread(new testThread("E"));
	        Thread thread_2 = new Thread(new testThread("F"));
	        thread_1.start();
	        thread_2.start();
	        try{
	            thread_1.join();
	        }catch (InterruptedException e){
	            e.printStackTrace();
	        }
	        try{
	            thread_2.join();
	        }catch (InterruptedException e){
	            e.printStackTrace();
	        }
	        System.out.println(Thread.currentThread().getName()+ " 主线程运行结束");
	    }
	}

	import java.util.concurrent.TimeUnit;
	public class Main{
	    public static Object object = new Object();
	    static class testThread_1 implements Runnable{
	        @Override
	        public void run()
	        {
	            synchronized(object)
	            {
	                System.out.println(Thread.currentThread().getName()+" running.");
	                try
	                {
	                    object.wait();
	                }
	                catch (InterruptedException e)
	                {
	                    e.printStackTrace();
	                }
	                System.out.println(Thread.currentThread().getName()+" get the lock.");
	            }
	        }
	    }
	    static class testThread_2 implements Runnable{
	        @Override
	        public void run() {
	            synchronized (object){
	                System.out.println(Thread.currentThread().getName()+ " running");
	                object.notify();
	                System.out.println(Thread.currentThread().getName()+ " is invoked");
	                System.out.println(Thread.currentThread().getName()+ "release the lock");
	            }
	        }
	    }
	    public static void main(String[] args)throws InterruptedException {
	        new Thread(new testThread_1()).start();
	        TimeUnit.SECONDS.sleep(1);
	        new Thread(new testThread_2()).start();
	    }
	}

    //默认的初始容量
    static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16
    //最大容量
    static final int MAXIMUM_CAPACITY = 1 << 30;
    //负载因子
    static final float DEFAULT_LOAD_FACTOR = 0.75f;
    static final int TREEIFY_THRESHOLD = 8;
    static final int UNTREEIFY_THRESHOLD = 6;
    static final int MIN_TREEIFY_CAPACITY = 64;
    //存储数据的Node数组，长度是2的幂。  
    transient Node<K,V>[] table;  
    //keyset 方法要返回的结果  
    transient Set<Map.Entry<K,V>> entrySet;  
    //map中保存的键值对的数量  
    transient int size;  
    //hashmap 对象被修改的次数  
    transient int modCount;  
    // 容量乘以装载因子所得结果，如果key-value的 数量等于该值，则调用resize方法，扩大容量，同时修改threshold的值。  
    int threshold;  
    //装载因子  
    final float loadFactor;  

    public HashMap(int initialCapacity, float loadFactor) {
        if (initialCapacity < 0)
            throw new IllegalArgumentException("Illegal initial capacity: " +
                                               initialCapacity);
        if (initialCapacity > MAXIMUM_CAPACITY)
            initialCapacity = MAXIMUM_CAPACITY;
        if (loadFactor <= 0 || Float.isNaN(loadFactor))
            throw new IllegalArgumentException("Illegal load factor: " +
                                               loadFactor);
        this.loadFactor = loadFactor;
        this.threshold = tableSizeFor(initialCapacity);
    }

    static class Node<K,V> implements Map.Entry<K,V> {
        final int hash;
        final K key;
        V value;
        Node<K,V> next;
    }

    //计算出hash值
    static final int hash(Object key) {
        int h;
        return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
    }

    public V put(K key, V value) {
        return putVal(hash(key), key, value, false, true);
    }
    
    /**
     * key的hash值
     * key
     * value
     * onlyIfAbsent如果是true，则不修改已存在的value值
     * true
     * return value值，if none ->null
    **/
    final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
                   boolean evict) {
        Node<K,V>[] tab; Node<K,V> p; int n, i;
        //判断table是否初始化，若未初始化，使用resize()初始化table容量，并设置threshold值
        if ((tab = table) == null || (n = tab.length) == 0)
            n = (tab = resize()).length;
        //根据hash值定位数组索引，如果对应的数组索引无值，调用newNode()方法，创建Node结点    
        if ((p = tab[i = (n - 1) & hash]) == null)
            tab[i] = newNode(hash, key, value, null);
        else {
            Node<K,V> e; K k;
            //若是hash值和key值都相等，则更新相应结点
            if (p.hash == hash &&
                ((k = p.key) == key || (key != null && key.equals(k))))
                e = p;
            //添加treeNode结点类型的键值对    
            else if (p instanceof TreeNode)
                e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
            else {
                for (int binCount = 0; ; ++binCount) {
                    if ((e = p.next) == null) {
                        创建新Node，并添加到链表尾部
                        p.next = newNode(hash, key, value, null);
                        if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                            treeifyBin(tab, hash);
                        break;
                    }
                    if (e.hash == hash &&
                        ((k = e.key) == key || (key != null && key.equals(k))))
                        break;
                    p = e;
                }
            }
            if (e != null) { // existing mapping for key
                V oldValue = e.value;
                if (!onlyIfAbsent || oldValue == null)
                    e.value = value;
                afterNodeAccess(e);
                return oldValue;
            }
        }
        ++modCount;
        //更新容量和threshold
        if (++size > threshold)
            resize();
        afterNodeInsertion(evict);
        return null;
    }

    public V get(Object key) {
        Node<K,V> e;
        return (e = getNode(hash(key), key)) == null ? null : e.value;
    }
    final Node<K,V> getNode(int hash, Object key) {
        Node<K,V>[] tab; Node<K,V> first, e; int n; K k;
        if ((tab = table) != null && (n = tab.length) > 0 &&
            (first = tab[(n - 1) & hash]) != null) {
            if (first.hash == hash && // always check first node
                ((k = first.key) == key || (key != null && key.equals(k))))
                return first;
            if ((e = first.next) != null) {
                if (first instanceof TreeNode)
                    return ((TreeNode<K,V>)first).getTreeNode(hash, key);
                do {
                    if (e.hash == hash &&
                        ((k = e.key) == key || (key != null && key.equals(k))))
                        return e;
                } while ((e = e.next) != null);
            }
        }
        return null;
    }

    private static class SynchronizedMap<K,V>
       implements Map<K,V>, Serializable {
       private static final long serialVersionUID = 1978198479659022715L;
       private final Map<K,V> m;     // Backing Map
       final Object      mutex;        // Object on which to synchronize
       SynchronizedMap(Map<K,V> m) {
           this.m = Objects.requireNonNull(m);
           mutex = this;
       }
       SynchronizedMap(Map<K,V> m, Object mutex) {
           this.m = m;
           this.mutex = mutex;
       }
       public int size() {
           synchronized (mutex) {return m.size();}
       }
       public boolean isEmpty() {
           synchronized (mutex) {return m.isEmpty();}
       }
       public boolean containsKey(Object key) {
           synchronized (mutex) {return m.containsKey(key);}
       }
       public boolean containsValue(Object value) {
           synchronized (mutex) {return m.containsValue(value);}
       }
       public V get(Object key) {
           synchronized (mutex) {return m.get(key);}
       }
       public V put(K key, V value) {
           synchronized (mutex) {return m.put(key, value);}
       }
       public V remove(Object key) {
           synchronized (mutex) {return m.remove(key);}
       }
       // 省略其他方法
   }

    public class ArrayBlockingQueue<E> extends AbstractQueue<E>
    implements BlockingQueue<E>, java.io.Serializable {
     
    private static final long serialVersionUID = -817911632652898426L;
     
    /** The queued items  */
    private final E[] items;
    /** items index for next take, poll or remove */
    private int takeIndex;
    /** items index for next put, offer, or add. */
    private int putIndex;
    /** Number of items in the queue */
    private int count;
     
    /*
    * Concurrency control uses the classic two-condition algorithm
    * found in any textbook.
    */
     
    /** Main lock guarding all access */
    private final ReentrantLock lock;
    /** Condition for waiting takes */
    private final Condition notEmpty;
    /** Condition for waiting puts */
    private final Condition notFull;
    }
 　
``` 　
 　　可以看出，ArrayBlockingQueue中用来存储元素的实际上是一个数组，takeIndex和putIndex分别表示队首元素和队尾元素的下标，count表示队列中元素的个数。

　　lock是一个可重入锁，notEmpty和notFull是等待条件。

　　下面看一下ArrayBlockingQueue的构造器，构造器有三个重载版本：
    
    public ArrayBlockingQueue(int capacity) {
        }
    public ArrayBlockingQueue(int capacity, boolean fair) {
     
        }
    public ArrayBlockingQueue(int capacity, boolean fair,
                              Collection<? extends E> c) {
    }
 　　第一个构造器只有一个参数用来指定容量，第二个构造器可以指定容量和公平性，第三个构造器可以指定容量、公平性以及用另外一个集合进行初始化。
然后看它的两个关键方法的实现：put()和take()：
```java　　
　  public void put(E e) throws InterruptedException {
        if (e == null) throw new NullPointerException();
        final E[] items = this.items;
        final ReentrantLock lock = this.lock;
        lock.lockInterruptibly();
        try {
            try {
                while (count == items.length)
                    notFull.await();
            } catch (InterruptedException ie) {
                notFull.signal(); // propagate to non-interrupted thread
                throw ie;
            }
            insert(e);
        } finally {
            lock.unlock();
        }
    }

    private E extract() {
        final E[] items = this.items;
        E x = items[takeIndex];
        items[takeIndex] = null;
        takeIndex = inc(takeIndex);
        --count;
        notFull.signal();
        return x;
    }

    class Pair<T> {  
        private T value;  
        public T getValue() {  
            return value;  
        }  
        public void setValue(T  value) {  
            this.value = value;  
        }  
    }   

    class Pair {  
        private Object value;  
        public Object getValue() {  
            return value;  
        }  
        public void setValue(Object  value) {  
            this.value = value;  
        }  
    }  

    public class Test10 {  
        public static void main(String[] args) {  
              
            //  
            ArrayList<String> arrayList1=new ArrayList();  
            arrayList1.add("1");//编译通过  
            arrayList1.add(1);//编译错误  
            String str1=arrayList1.get(0);//返回类型就是String  
              
            ArrayList arrayList2=new ArrayList<String>();  
            arrayList2.add("1");//编译通过  
            arrayList2.add(1);//编译通过  
            Object object=arrayList2.get(0);//返回类型就是Object  
              
            new ArrayList<String>().add("11");//编译通过  
            new ArrayList<String>().add(22);//编译错误  
            String string=new ArrayList<String>().get(0);//返回类型就是String  
        }  
    }  

	public interface lock { 
		void lock();
		void lockInterruptibly() throws InterruptException;
		boolean trylock();
		boolean trylock(long time, TimeUnit unit) throws InterruptException;
		void unlock();
		Condition newCondition();
	}

	//默认为非公平锁，若使用公平所，需要传入参数true
	Lock lock = new ReentrantLock();
	···
	lock.lock();
	try{
		//执行任务，更新状态
	} catch(Exception e){
		...
	} finally{
		lock.unlock();
	}

	Lock lock = new ReentrantLock();
	···
	if(lock.tryLock()){
		try{
			//执行任务，更新状态
		}catch(Exception e){
			···
		} finally{
			lock.unlock();
		}
	}else{
		···
	}

	public void method() throws InterruptedException(){
		lock.interruptibly();
		try{
			//执行任务，更新状态
		}catch(Exception e){
			···
		} finally{
			lock.unlock();
		}
	}

	import java.util.ArrayList;
	import java.util.List;
	import java.util.concurrent.locks.Lock;
	import java.util.concurrent.locks.ReentrantLock;
	import java.util.stream.Stream;

	public class Main{
	    private List<Integer> list = new ArrayList<>();
	    （1）//private Lock lock = new ReentrantLock();
	    public void method(Thread thread){
	    	（2）//Lock lock = new ReentrantLock();
	        lock.lock();
	        try{
	            System.out.println(thread.getName()+"获取线程");
	            Stream.of(1,2,3,4,5).forEach(e -> list.add(e));
	            System.out.println(list);
	        }catch (Exception e){
	            e.printStackTrace();
	        }finally {
	            System.out.println(thread.getName()+"释放线程");
	            lock.unlock();
	        }
	    }

	    public static void main(String[] args) {
	        Main test = new Main();
	        new Thread(){
	            @Override
	            public void run(){
	                super.run();
	                test.method(Thread.currentThread());
	            }
	        }.start();
	        new Thread(){
	            @Override
	            public void run() {
	                super.run();
	                test.method(Thread.currentThread());
	            }
	        }.start();
	    }
	}

	import java.util.ArrayList;
	import java.util.List;
	import java.util.concurrent.locks.Lock;
	import java.util.concurrent.locks.ReentrantLock;
	import java.util.stream.Stream;

	public class Main{
	    private List<Integer> list = new ArrayList<Integer>();
	    private Lock lock = new ReentrantLock();
	    public void method(Thread thread){
	        if(lock.tryLock()){
	            try{
	                System.out.println(thread.getName()+"获取线程");
	                Stream.of(1,2,3,4,5).forEach(e -> list.add(e));
	                System.out.println(list);
	            }catch (Exception e){
	                e.printStackTrace();
	            }finally {
	                System.out.println(thread.getName()+"释放线程");
	                lock.unlock();
	            }
	        }else{
	            System.out.println(thread.getName()+"获取线程失败");
	        }
	    }

	    public static void main(String[] args) {
	        Main test = new Main();
	        new Thread(){
	            @Override
	            public void run(){
	                super.run();
	                test.method(Thread.currentThread());
	            }
	        }.start();
	        new Thread(){
	            @Override
	            public void run() {
	                super.run();
	                test.method(Thread.currentThread());
	            }
	        }.start();
	    }
	}

	import java.util.ArrayList;
	import java.util.List;
	import java.util.concurrent.locks.Lock;
	import java.util.concurrent.locks.ReentrantLock;
	import java.util.stream.Stream;

	class thread1 implements Runnable{
	    private Main test = null;
	    public thread1(Main test){
	        this.test = test;
	    }
	    @Override
	    public void run() {
	        try{
	            test.method(Thread.currentThread());
	        }catch(Exception e){
	            System.out.println(Thread.currentThread()+"线程被中断");
	        }
	    }
	}

	public class Main{
	    Lock lock = new ReentrantLock();
	    public void method(Thread thread) throws InterruptedException{
	        lock.lockInterruptibly();
	        try{
	            System.out.println(thread.getName()+"得到了锁");
	            long startTime = System.currentTimeMillis();
	            for(    ;     ;) {
	                if(System.currentTimeMillis() - startTime >= Integer.MAX_VALUE)
	                    break;
	            }
	        }catch (Exception e){
	            e.printStackTrace();
	        }finally {
	            System.out.println(thread.getName()+"释放线程");
	            lock.unlock();
	        }
	    }

	    public static void main(String[] args) {
	        Main test = new Main();
	        Thread thread_1 = new Thread(new thread1(test));
	        Thread thread_2 = new Thread(new thread1(test));
	        thread_1.start();
	        thread_2.start();
	        try{
	            Thread.sleep(2000);
	        }catch (Exception e){
	            e.printStackTrace();
	        }
	        thread_2.interrupt();
	    }
	}

	public interface ReadWriteLock{
		//return the lock of userd for reading
		Lock readLock();
		//return the lock of userd for writing
		Lock writeLock();
	}

	import java.util.concurrent.locks.ReentrantReadWriteLock;
	public class test {
	    private ReentrantReadWriteLock reentrantReadWriteLock = new ReentrantReadWriteLock();
	    public static void main(String[] args) {
	        test _test = new test();
	        new Thread(){
	            @Override
	            public void run() {
	                super.run();
	                _test.method(Thread.currentThread());
	            }
	        }.start();
	        new Thread(){
	            @Override
	            public void run() {
	                super.run();
	                _test.method(Thread.currentThread());
	            }
	        }.start();
	    }
	    public void method(Thread thread){
	        reentrantReadWriteLock.readLock().lock();
	        long start = System.currentTimeMillis();
	        try{
	            while(System.currentTimeMillis()-start<1){
	                System.out.println(thread.getName()+"正在读操作");
	            }
	            System.out.println(thread.getName()+"都操作完成");
	        }catch(Exception e){
	            e.printStackTrace();
	        }finally {
	            reentrantReadWriteLock.readLock().unlock();
	        }
	    }
	}

	//创建用于执行sql语句的Statement对象
	stmt = (Stattement)conn.createStatement();
	//执行查询语句，返回查询结果
	
	ResultSet rs = stmt.executeQuery("SELECT id,name FROM test");
	while(rs.next()){
		int id = rs.getInt("id");
		String name = rs.getString("name");
		out.println("..."+id+"..."+name);
		out.println("<br />")
	}
	//执行插入语句，返回插入行数
	String sql = “INSERT INTO test ...VALUES(...)”
	stmt = (Statement)conn.createStatement();
	int count = stmt.executeUpdate(sql);
	//数据库更新(删除)和插入相似

	public static void example(){
		Connection conn = null;
	}try{
		Class.forName("com.mysql.jdbc.Driver");
		conn = DreiverManager.getConnection("jdbc:ysql://localhost:3306/mysqltest", USSR, PASS);
		conn.setAutoCommit(false);//取消自动提交，改为手动提交
		String sql_1 = "update test_table set name='...' where name='...'";
		String sql_2 = "insert test_table (name,url) values('...',''),('','')";
		stmt = (Statement)conn.create.Statement();
		int count = stmt.executeUpdate(sql_1);
		//若所有结果执行完成，则执行提交事务
		stmt.execteUpdate(sql_2);
		conn.commit();
		ps.close();
		conn.close()
		catch(ClassNotFoundException e){
			e.printStackTrace();
		}catch(SQLException e){
			e.printStackTrace();
			try{
				//只要有一个sql语句错误，则事务回滚
				conn.rollback();
			}catch(SQLException e){
				e.printStackTrace();	
			}	
		}
	}	

	public void JtaTransfer() { 
	        javax.transaction.UserTransaction tx = null;
	        java.sql.Connection conn = null;
	         try{ 
	             tx = (javax.transaction.UserTransaction) context.lookup("java:comp/UserTransaction");  //取得JTA事务，本例中是由Jboss容器管理
	             javax.sql.DataSource ds = (javax.sql.DataSource) context.lookup("java:/XAOracleDS");  //取得数据库连接池，必须有支持XA的数据库、驱动程序  
	             tx.begin();
	            conn = ds.getConnection();

	             // 将自动提交设置为 false，
	             //若设置为 true 则数据库将会把每一次数据更新认定为一个事务并自动提交
	             conn.setAutoCommit(false);

	             stmt = conn.createStatement(); 
	             // 将 A 账户中的金额减少 500 
	             stmt.execute("\
	             update t_account set amount = amount - 500 where account_id = 'A'");
	             // 将 B 账户中的金额增加 500 
	             stmt.execute("\
	             update t_account set amount = amount + 500 where account_id = 'B'");

	             // 提交事务
	             tx.commit();
	             // 事务提交：转账的两步操作同时成功
	         } catch(SQLException sqle){            
	             try{ 
	                 // 发生异常，回滚在本事务中的操做
	              tx.rollback();
	                 // 事务回滚：转账的两步操作完全撤销
	                 stmt.close(); 
	                 conn.close(); 
	             }catch(Exception ignore){ 

	             } 
	             sqle.printStackTrace(); 
	         } 
	     }

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

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

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

    public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) {
        return new ScheduledThreadPoolExecutor(corePoolSize);
    }
    public static ScheduledExecutorService newScheduledThreadPool(
            int corePoolSize, ThreadFactory threadFactory) {
        return new ScheduledThreadPoolExecutor(corePoolSize, threadFactory);
    }

    void shutdown();
    List<Runnable> shutdownNow();
    boolean isShutdown();
    boolean isTerminated();
    boolean awaitTermination(long timeout, TimeUnit unit)
        throws InterruptedException;
    submit();
    invokeAny();
    invokeAll();
    execute();

    ExecutorService executorService = Executors.newSingleThreadExecutor();
    executorService.execute(new Runnable() {
        public void run() {
            System.out.println("Asynchronous task");
        }
    });
    executorService.shutdown();

    Future future = executorService.submit(new Runnable() {
    public void run() {
        System.out.println("Asynchronous task");
    }
    });
    //如果任务结束执行则返回 null
    System.out.println("future.get()=" + future.get());

    Future future = executorService.submit(new Callable(){
        public Object call() throws Exception {
            System.out.println("Asynchronous Callable");
            return "Callable Result";
        }
    });
    
    System.out.println("future.get() = " + future.get());

    package com.study.test;  
      
    public class A { //父类  
        public static String staticStr = "A静态属性";  
        public String nonStaticStr = "A非静态属性";  
        public static void staticMethod(){  
            System.out.println("A静态方法");  
        }  
        public void nonStaticMethod(){  
            System.out.println("A非静态方法");  
        }  
    }  
    
    
    package com.study.test;  
      
    public class B extends A{//子类B  
        public static String staticStr = "B改写后的静态属性";  
        public String nonStaticStr = "B改写后的非静态属性";  
        public static void staticMethod(){  
            System.out.println("B改写后的静态方法");  
        }  
    }  
 
    package com.study.test;  
      
    public class C extends A{//子类C继承A中的所有属性和方法  
      
    }  

    package com.study.test;  
      
    public class StaticExtendsTest {  
      
        public static void main(String[] args) {  
            C c = new C();  
            System.out.println(c.nonStaticStr);  
            System.out.println(c.staticStr);  
            c.staticMethod();//输出的结果都是父类中的非静态属性、静态属性和静态方法,推出静态属性和静态方法可以被继承  
              
            System.out.println("-------------------------------");  
              
            A c1 = new C();  
            System.out.println(c1.nonStaticStr);  
            System.out.println(c1.staticStr);  
            c1.staticMethod();//结果同上，输出的结果都是父类中的非静态属性、静态属性和静态方法,推出静态属性和静态方法可以被继承  
          
            System.out.println("-------------------------------");  
            B b = new B();  
            System.out.println(b.nonStaticStr);  
            System.out.println(b.staticStr);  
            b.staticMethod();  
              
            System.out.println("-------------------------------");  
            A b1 = new B();  
            System.out.println(b1.nonStaticStr);  
            System.out.println(b1.staticStr);  
            b1.staticMethod();//结果都是父类的静态方法，说明静态方法不可以被重写，不能实现多态  
        }  
      
    }  

	public class addGroups(){
		public static void main(String[] args){
			Conllection<Integer> conllection = new ArrayList<Integer>(Arrays.asList(1,2,3));
			Integer[] moreInts = {4,5,6};
			collection.addAll(Arrays.asList(moreInts));
			Collections.addAlls(conllection, 7,8,9);
			Collections.addAlls(conllection, moreInts);
		}
	}

	import java.util.*;

	import static java.lang.System.out;

	public class Main {
		 public static void main(String[] args) {
	        List<String> list = new ArrayList<String>(Arrays.asList("red","blue","white","grey"));
	        //add(int index,String value)向List中添加插入元素
	        list.add("yellow");
	        out.println(list);
	        //contains(String value)判断List中是否包含该元素
	        out.println(list.contains("yellow"));
	        //indexOf(String value)查询元素的位置
	        out.println(list.indexOf("blue"));
	        //remove(String value)删除元素
	        out.println(list.remove("blue"));
	        out.println(list);
	        //subList(int index,int _index)截取片断，返回一个新的List对象
	        List<String> _list = list.subList(1,4);
	        out.println(_list);
	        //containAll(List object)判断一个List中是否包含另一个List中的所有值
	        out.println(list.containsAll(_list));
	        //Collections.sort(List object)对List进行排序
	        Collections.sort(_list);
	        out.println(_list);
	        List<String> copy_list = new ArrayList<>(list);
	        _list = Arrays.asList(list.get(1),list.get(3));
	        out.println(_list);
	        out.println(copy_list);
	        //retainAll()取交集
	        copy_list.retainAll(_list);
	        out.println(copy_list);
	        //removeALl()从List中移除参数List中所有元素
	        copy_list.removeAll(_list);
	        out.println(copy_list);
	        //set()设值，在指定索引处，替换位置上的元素
	        list.set(1,"green");
	        out.println(list);
	        //addAll()在List中插入新的列表
	        list.addAll(1,_list);
	        out.println(list);
	        //isEmpty()判断List是否为空
	        out.println(list.isEmpty());
	        //clear()清除所有元素
	        list.clear();
	        out.println(list);
	        //toArray()将Collection转换为一个数组，为重载方法，无参版本返回的是Object数组
	        Object[] array = _list.toArray();
	        out.println(array[0]);
	    }
	}

 	import java.util.*;
	import static java.lang.System.out;
	public class Main {
    	public static void main(String[] args) {
	        List<String> list = new ArrayList<String>(Arrays.asList("red","blue","white","grey"));
	        Iterator<String> iter = list.iterator();
	        while(iter.hasNext()){
	            String s = iter.next();
	            out.println(s);
	        }
	        for(String _s : list)
	            out.println(_s);
	        iter = list.iterator();
	        for(int i = 0;i < 2;i++){
	            iter.next();
	            iter.remove();
	        }
	        out.println(list);
	    }
	}

	import java.util.*;
	import static java.lang.System.out;
	public class Main {
	    public static void display(Iterator<String> iter){
	        while(iter.hasNext()){
	            String s = iter.next();
	            out.println(s);
	        }
	    }
	    public static void main(String[] args) {

	        List<String> list = new ArrayList<String>(Arrays.asList("red", "blue", "white", "grey"));
	        LinkedList<String> L_list = new LinkedList<String>(list);
	        HashSet<String> H_list = new HashSet<String>(list);
	        TreeSet<String> T_list = new TreeSet<String>(list);
	        display(list.iterator());
	        display(L_list.iterator());
	        display(H_list.iterator());
	        display(T_list.iterator());
	    }
	}

	import java.util.*;
	import static java.lang.System.out;
	public class Main {
	    public static void main(String[] args) {
	        List<String> list = new ArrayList<String>(Arrays.asList("red", "blue", "white", "grey"));
	        ListIterator<String> iter = list.listIterator();
	        while(iter.hasNext()){
	            System.out.print(iter.next()+","+iter.nextIndex()+","+iter.previousIndex()+" ");
	        }
	        System.out.println();
	        while(iter.hasPrevious())
	            out.print(iter.previous()+" ");
	        out.println();
	        iter = list.listIterator(2);
	        while(iter.hasNext()){
	            iter.next();
	            iter.set("girl");
	        }
	        out.println(list);
	    }
	}

	import java.util.*;
   import static java.lang.System.out;
   public class Main {
       public static void main(String[] args) {
           LinkedList<String> list = new LinkedList<String>(Arrays.asList("red","blue","green","yellow"));
           out.println(list);
           out.println("getFirst():"+list.getFirst());
           out.println("element():"+list.element());
           out.println("peek():"+list.peek());
           out.println("remove():"+list.remove());
           out.println("removeFirst():"+list.removeFirst());
           out.println("poll():"+list.poll());
           list.addFirst("red");
           list.addLast("blue");
           out.println(list);
           out.println("removeLast():"+list.removeLast());
       }
   }

   [red, blue, green, yellow]
   getFirst():red
   element():red
   peek():red
   remove():red
   removeFirst():blue
   poll():green
   [red, yellow, blue]
   removeLast():blue

	import java.util.LinkedList;
	public class Stack<T>{
		private LinkedList<T> Storage = new LinkedList<T>();
		public void push(T v) {
			storage.addFirst(v);
		}
		public T peek(){
			return storage.getFirst();
		}
		public T pop(){
			return storage.removeFirst();
		}
		public boolean empty(){
			return storage.isEmpty();
		}
		public String toString(){
			return storage.toString();
		}
	}

	import java.util.*;
	import static java.lang.System.out;
	public class Main {
	    public static void main(String[] args) {
	        Random rand = new Random(47);
	        //Set<Integer> set = new HashSet<Integer>();
	        //Set<Integer> set = new TreeSet<Integer>();
	        Set<Integer> set = new LinkedHashSet<Integer>();
	        for(int i = 0;i<1000;i++){
	            set.add(rand.nextInt(30));
	        }
	        out.println(set);
	    }
	}

	import java.util.*;
	import static java.lang.System.out;
	public class Main {
	    public static void main(String[] args) {
	        Random rand = new Random(47);
	        Map<Integer, Integer> map = new HashMap<Integer, Integer>();
	        for(int i =0; i<1000;i++){
	            int r= rand.nextInt(30);
	            Integer num = map.get(r);
	            map.put(r, num==null?1:num+1);
	        }
	        out.println(map);
	    }
	}

	import java.util.*;
	import static java.lang.System.out;
	public class Main {
	    public static void main(String[] args) {
	        Map<Integer, String> map = new HashMap<Integer, String>();
	        map.put(0, "red");
	        map.put(1, "blue");
	        map.put(2, "yellow");
	        out.println(map);
	        out.println(map.containsKey(1));
	        out.println(map.containsValue("blue"));
	    }
	}

    Map<Integer, Integer> map = new HashMap<Integer, Integer>();  
  
    for (Map.Entry<Integer, Integer> entry : map.entrySet()) {  
  
        System.out.println("Key = " + entry.getKey() + ", Value = " + entry.getValue());  
 
}  

    Map<Integer, Integer> map = new HashMap<Integer, Integer>();  
  
    //遍历map中的键  
      
    for (Integer key : map.keySet()) {  
      
        System.out.println("Key = " + key);  
      
    }  
      
    //遍历map中的值  
      
    for (Integer value : map.values()) {  
      
        System.out.println("Value = " + value);  
      
    }

    Map<Integer, Integer> map = new HashMap<Integer, Integer>();  
  
    Iterator<Map.Entry<Integer, Integer>> entries = map.entrySet().iterator();  
      
    while (entries.hasNext()) {  
      
        Map.Entry<Integer, Integer> entry = entries.next();  
      
        System.out.println("Key = " + entry.getKey() + ", Value = " + entry.getValue());  
      
    }  

    public abstract class AbstractExecutorService implements ExecutorService {
        protected <T> RunnableFuture<T> newTaskFor(Runnable runnable, T value) {
            return new FutureTask<T>(runnable, value);
        }
        protected <T> RunnableFuture<T> newTaskFor(Callable<T> callable) {
            return new FutureTask<T>(callable);
        }
        //submit函数1
        public Future<?> submit(Runnable task) {
            if (task == null) throw new NullPointerException();
            RunnableFuture<Void> ftask = newTaskFor(task, null);
            execute(ftask);
            return ftask;
        }
        //submit函数2
        public <T> Future<T> submit(Runnable task, T result) {
            if (task == null) throw new NullPointerException();
            RunnableFuture<T> ftask = newTaskFor(task, result);
            execute(ftask);
            return ftask;
        }
        //submit函数3
        public <T> Future<T> submit(Callable<T> task) {
            if (task == null) throw new NullPointerException();
            RunnableFuture<T> ftask = newTaskFor(task);
            execute(ftask);
            return ftask;
        }
        private <T> T doInvokeAny(Collection<? extends Callable<T>> tasks,boolean timed, long nanos) throws InterruptedException, ExecutionException, TimeoutException {······}
        public <T> T invokeAny(Collection<? extends Callable<T>> tasks,long timeout, TimeUnit unit)throws InterruptedException, ExecutionException, TimeoutException {······}
        public <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks,long timeout, TimeUnit unit)throws InterruptedException {
    }

  public Future<?> submit(Runnable task) {···}
      
  public <T> Future<T> submit(Runnable task, T result) {···}

  public <T> Future<T> submit(Callable<T> task) {···}

    @FunctionalInterface
    public interface Callable<V> {
        //计算结果
        V call() throws Exception;
    }

#### newTaskFor()方法源码    

    protected <T> RunnableFuture<T> newTaskFor(Runnable runnable, T value) {
            return new FutureTask<T>(runnable, value);
        }
    protected <T> RunnableFuture<T> newTaskFor(Callable<T> callable) {
            return new FutureTask<T>(callable);
        }
        
#### FutureTask类部分源码

    public class FutureTask<V> implements RunnableFuture<V> {
        ···
        public FutureTask(Callable<V> callable) {···}
        public FutureTask(Runnable runnable, V result) {···}
        ···
    }

   public interface RunnableFuture<V> extends Runnable, Future<V> {
       void run();
   }

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

    public interface Future<V> {
        //试图取消对任务的执行,参数为true表示可以取消正在执行的任务
        boolean cancel(boolean mayInterruptIfRunning);
        //任务是否取消成功
        boolean isCancelled();
        //任务是否已经完成
        boolean isDone();
        //获取执行结果，会产生阻塞，等到任务执行完再返回结果
        V get() throws InterruptedException, ExecutionException;
        //在指定时间内未返回结果，则返回null
        V get(long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException;
    }

    public <T> Future<T> submit(Callable<T> task) {
        //Callable任务为空，抛出无参异常
        if (task == null) throw new NullPointerException();
        //返回FutureTask类对象,
        RunnableFuture<T> ftask = newTaskFor(task);
        //向线程池提交一个任务
        execute(ftask);
        //返回处理后的任务
        return ftask;
    }

    public FutureTask(Callable<V> callable) {
        if (callable == null)
            throw new NullPointerException();
        this.callable = callable;
        this.state = NEW;      
    }

    public class Test {
        public static void main(String[] args) {
            //建议使用Executors类中的方法构建线程池，具体使用方法和源码分析看我关于线程池本主题的其他博文
            ExecutorService executor = Executors.newCachedThreadPool();
            Task task = new Task();
            Future<Integer> result = executor.submit(task);
            executor.shutdown();
             
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e1) {
                e1.printStackTrace();
            }
             
            System.out.println("主线程在执行任务");
             
            try {
                System.out.println("task运行结果"+result.get());
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (ExecutionException e) {
                e.printStackTrace();
            }
             
            System.out.println("所有任务执行完毕");
        }
    }
    class Task implements Callable<Integer>{
        @Override
        public Integer call() throws Exception {
            System.out.println("子线程在进行计算");
            Thread.sleep(3000);
            int sum = 0;
            for(int i=0;i<100;i++)
                sum += i;
            return sum;
        }
    }

   public class Test {
       public static void main(String[] args) {
           //第一种方式，线程池方式
           ExecutorService executor = Executors.newCachedThreadPool();
           Task task = new Task();
           FutureTask<Integer> futureTask = new FutureTask<Integer>(task);
           executor.submit(futureTask);
           executor.shutdown();
            
           //第二种方式，注意这种方式和第一种方式效果是类似的，只不过一个使用的是ExecutorService，一个使用的是Thread
           /*Task task = new Task();
           FutureTask<Integer> futureTask = new FutureTask<Integer>(task);
           Thread thread = new Thread(futureTask);
           thread.start();*/
            
           try {
               Thread.sleep(1000);
           } catch (InterruptedException e1) {
               e1.printStackTrace();
           }
            
           System.out.println("主线程在执行任务");
            
           try {
               System.out.println("task运行结果"+futureTask.get());
           } catch (InterruptedException e) {
               e.printStackTrace();
           } catch (ExecutionException e) {
               e.printStackTrace();
           }
            
           System.out.println("所有任务执行完毕");
       }
   }
   class Task implements Callable<Integer>{
       @Override
       public Integer call() throws Exception {
           System.out.println("子线程在进行计算");
           Thread.sleep(3000);
           int sum = 0;
           for(int i=0;i<100;i++)
               sum += i;
           return sum;
       }
   }