Java容器
collection一个独立的元素序列，这些元素都服从一条或多条规则。list必须按照插入的顺序保存元素，set不能有重复元素，queue按照排队的顺序确定对象产生的顺序。map一组成对的“键值对”对象，允许你使用键来查找。arraylist允许你使用数字来查找。
容器按照每个槽存放元素个数来分类：Collection类的每个槽保存一个数据,包括List存放有序的，set存放不重复的，queue一端插入一端输出。MAP类的每个槽存放两个元素，键和值，
LIST中arraylist和linkedlist主要是在执行某些操作性能不同
arraylist：Add方法用于添加一个元素到当前列表的末尾
linkedlist:
STACK:先进先出lifo,一般都使用linkedlist实现
SET,保存不重复元素，中有hashset、treeset、linkedhashset，hashset可以最快的获取元素，使用散列函数，treeset按照对象比较升序排列，使用红黑树，linkedhashset按照插入顺序排列
MAP:不必制定map的大小，他会自动调整尺寸，HASHMAP、TREEMAP、LINKHASHMAP和set的规则基本一样
QUEUE:lilo,使用linkedlist实现
异常
Java抛出异常发生的动作：1、会在堆上创建异常对象，2、当前执行路径被终止，并应用异常对象，3、异常机制接管，寻找一个恰当的地方继续执行（恰当的地方是异常处理程序，它使程序从错误状态恢复，要么继续执行，要么换一种方式执行）
Throwable包括ERROR和EXCEPTION
RuntimeException：如果没有被捕获而直达main方法，程序将直接退出，在退出前将调用peintStackTrace()方法，在代码中忽略runtimeexception是应为他代表的是编程错误，编程错误包括 1、无法预料的错误，比如说传递了null,2、其他地方引起的异常
finally子句总会被执行，
finally return，finally语句是在try的return语句执行之后，return返回之前执行
public class FinallyTest1 { public static void main(String[] args) { System.out.println(test11()); } public static String test11() { try { System.out.println("try block"); return test12(); } finally { System.out.println("finally block"); } } public static String test12() { System.out.println("return statement"); return "after return"; } }
运行结果为：
try block return statement finally block after return
并发
从性能角度考虑，如果没有任务会阻塞，那么单处理器的机器使用并发并没有意义。
如果在你机器上有多个处理器，线程调度器将会在这些处理器之间默默地分发线程。
在任何线程池中，现有的线程在可能的情况下，都会被自动复用。
如果希望任务完成后能够返回一个值，那么可以实现callable接口而不是runnable接口，它的入口方法是call()，使用submit()方法调用。
异常不能够跨线程传播，必须要线程内部解决。
注意：每个访问共享临界资源的方法都要被同步。可以通过synchronized进行同步。
java.util.concurrent.locks中的Lock对象必须被显示的创建、锁定和释放。
原子性操作是不能被线程调度机制终端的操作，一旦开始，那么它一定可以再可能发生的“上下文切换”之前*（切换到其他线程执行）执行完毕。原子性可以用于除long和double的所有基本类型上的简单操作。JVM可以讲64位（long和double变量）读取和写入当做两个分离的32位操作来执行，这就产生了在一个读取和写入操作中间发生上下文切换，从而导致不同任务看到不同结果，使用valatile关键字可以避免。
volatile关键字还可以确保了应用中的可视性，volatile域会立即被写入到主存中，而读取操作就发生在主存中。在非volatile域上的原子操作不必刷新到主存中去，因此其他读取改域的任务不必看到这个新值。如果多个任务同时访问某个域，那么这个域就应该是volatile的，否则这个域就应该这能经由同步来访问，同步也会导致主存中刷新，因此一个域完全由syncchronnized方法或语句防护，不必设置为volatile的。一个任务所做的任何写入操作对这个任务都是可视的，因此不用设置为volatile的。当一个域值依赖于其他值时，volatile就无法工作了。
使用volatile而不是synchrnized的唯一安全情况是类中只有一个可变的域。使用时第一选择是synchronized关键字，这是最安全的方式。
线程池：
CachedThreadPool
创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程，线程池为无限大，当执行第二个任务时第一个任务已经完成，会复用执行第一个任务的线程，而不用每次新建线程。。这种线程池应该优先考虑。
FixedThreadPool
创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。定长线程池的大小最好根据系统资源进行设置。如Runtime.getRuntime().availableProcessors()。
ScheduledThreadPool
创建一个定长线程池，支持定时及周期性任务执行。延迟执行
SingleThreadExecutor
创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行
ThreadPoolExecutor
1. ThreadPoolExecutor的一个常用的构造方法
ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime,
TimeUnit unit, BlockingQueue<Runnable> workQueue, RejectedExecutionHandler handler)
参数说明：
-corePoolSize 线程池中所保存的核心线程数。线程池启动后默认是空的，只有任务来临时才会创建线程以处理请求。prestartAllCoreThreads方法可以在线程池启动后即启动所有核心线程以等待任务。
-maximumPoolSize 线程池允许创建的最大线程数。当workQueue使用无界队列时（如：LinkedBlockingQueue），则此参数无效。
-keepAliveTime 当前线程池线程总数大于核心线程数时，终止多余的空闲线程的时间。
-unit keepAliveTime参数的时间单位。
-workQueue 工作队列，如果当前线程池达到核心线程数时（corePoolSize），且当前所有线程都处于活动状态，则将新加入的任务放到此队列中。下面仅列几个常用的：
ArrayBlockingQueue： 基于数组结构的有界队列，此队列按FIFO原则对任务进行排序。如果队列满了还有任务进来，则调用拒绝策略。
LinkedBlockingQueue： 基于链表结构的无界队列，此队列按FIFO原则对任务进行排序。因为它是无界的，根本不会满，所以采用此队列后线程池将忽略拒绝策略（handler）参数；同时还将忽略最大线程数（maximumPoolSize）等参数。
SynchronousQueue： 直接将任务提交给线程而不是将它加入到队列，实际上此队列是空的。每个插入的操作必须等到另一个调用移除的操作；如果新任务来了线程池没有任何可用线程处理的话，则调用拒绝策略。其实要是把maximumPoolSize设置成无界（Integer.MAX_VALUE）的，加上SynchronousQueue队列，就等同于Executors.newCachedThreadPool()。
PriorityBlockingQueue： 具有优先级的队列的有界队列，可以自定义优先级；默认是按自然排序，可能很多场合并不合适。
-handler 拒绝策略，当线程池与workQueue队列都满了的情况下，对新加任务采取的策略。
AbortPolicy： 拒绝任务，抛出RejectedExecutionException异常。默认值。
CallerRunsPolicy： A handler for rejected tasks that runs the rejected task directly in the calling thread of the execute method, unless the executor has been shut down, in which case the task is discarded（没太弄懂意思，看不太懂，程序模拟半天也没得出啥结论。）
DiscardOldestPolicy： 如果执行程序尚未关闭，则位于工作队列头部的任务将被删除，然后重试执行程序（如果再次失败，则重复此过程）。这样的结果是最后加入的任务反而有可能被执行到，先前加入的都被抛弃了。
DiscardPolicy： 加不进的任务都被抛弃了，同时没有异常抛出。
2. 详解及示范
一个任务进来（Runnable）时，如果核心线程数（corePoolSize）未达到，则直接创建线程处理该任务；如果核心线程数已经达到则该任务进入工作队列（workQueue）。如果工作队列满了（只能是有界队列），则检查最大线程数（maximumPoolSize）是否达到，如果没达到则创建线程处理任务（FIFO）；如果最大线程数据也达到了，则调用拒绝策略（handler）。
如果workQueue使用LinkedBlockingQueue队列，因为它是无界的，队列永远不会满，所以maximumPoolSize参数是没有意义的，同样keepAliveTime、unit、handler三个参数都无意义。
如果workQueue使用ArrayBlockingQueue队列，那么小心，因为此队列是有界的，必须小心处理拒绝策略。你看人家Executors类，压根就不使用ArrayBlockingQueue队列。
正常情况下，如果使用Executors静态工厂生成的几种常用线程池能够满足要求，建议就用它们吧。自己控制所有细节挺不容易的。
package com.clzhang.sample.thread;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.PriorityBlockingQueue;
import java.util.concurrent.SynchronousQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
public class ThreadPoolTest3 {
static class MyThread implements Runnable {
private String name;
public MyThread(String name) {
this.name = name;
}
@Override
public void run() {
// 做点事情
try {
Thread.sleep(1000);
System.out.println(name + " finished job!") ;
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
public static void main(String[] args) {
// 创建线程池，为了更好的明白运行流程，增加了一些额外的代码
// BlockingQueue<Runnable> queue = new ArrayBlockingQueue<Runnable>(2);
BlockingQueue<Runnable> queue = new LinkedBlockingQueue<Runnable>();
// BlockingQueue<Runnable> queue = new PriorityBlockingQueue<Runnable>();
// BlockingQueue<Runnable> queue = new SynchronousQueue<Runnable>();
// AbortPolicy/CallerRunsPolicy/DiscardOldestPolicy/DiscardPolicy
ThreadPoolExecutor threadPool = new ThreadPoolExecutor(2, 4, 5, TimeUnit.SECONDS,
queue, new ThreadPoolExecutor.AbortPolicy());
// 向线程池里面扔任务
for (int i = 0; i < 10; i++) {
System.out.println("当前线程池大小[" + threadPool.getPoolSize() + "],当前队列大小[" + queue.size() + "]");
threadPool.execute(new MyThread("Thread" + i));
}
// 关闭线程池
threadPool.shutdown();
}
}
IO
file类：list()方法，列出目录所有文件，Arrays.sort(a1,String.CASE_INSENSITIVE_ORDER)；按照字母进行排序
