多线程设计主要API总结

java.lang.Runnable 接口
void run() 必须重写这个方法，并在这个方法中提供所要执行的任务。

java.lang.Thread 类，该类实现了Runnable接口
构造
Thread(Runnable target) 构造一个新线程，用于调用给定target的run()方法
方法
1.启动和中断线程
void start() : 启动这个线程，将引发调用run()方法，这个方法将立即返回，并且新线程将并行运行。
void run() : 调用关联Runnable的run方法。
static void sleep(long millis,int nanos) : 休眠给定的毫秒数 需要捕获sleep方法可能抛出的异常InterruptedException
    millis - 以毫秒为单位的休眠时间
    nanos - 要休眠的另外 0-999999 纳秒
void interrupt() : 中断线程，如果当前线程无法修改该线程(如果不是中断状态会调用checkAccess)
    抛出： SecurityException
void checkAccess() : 判定当前运行的线程是否有权修改该线程 如果有安全管理器，则调用其 checkAccess 方法，并将该线程作为其参数
    抛出： SecurityException 如果不允许当前线程访问该线程。
boolean isInterrupted() : 测试线程是否已经中断。线程的中断状态 不受该方法的影响。返回：如果该线程已经中断，则返回 true；否则返回 false。
static boolean interrupted() : 检测当前的线程是否被中断，并清除该线程的中断状态。
2.线程状态
void join() : 等待该线程终止。
void join(long millis) : 等待该线程终止的时间最长为 millis 毫秒。
Thread.State getState() : 返回该线程的状态。 该方法用于监视系统状态，不用于同步控制。
3.线程优先级
setPriority(int) : 设置线程优先级
    int MIN_PRIORITY 线程的最小优先级。最小优先级值为1.
    int NORM_PRIORITY 线程的默认优先级。缺省优先级值为5.
    int MAX_PRIORITY 线程的最大优先级。最大优先级值为10。
static void yield() : 导致当前执行线程处于让步状态。如果有其他的可运行线程具有至少与此线程同样高的优先级，那么这些线程接下来会被调度。
4.守护线程
setDaemon(boolean) : 设置该线程标记为守护线程或用户线程。必须在线程启动之前调用。当正在运行的线程都是守护线程时，Java 虚拟机退出。
isDaemon : 测试该线程是否为守护线程。如果该线程是守护线程，则返回 true；否则返回 false。
5.未捕获异常
static void setDefaultUncaughtExceptionHandler(Thread.UncaughtExceptionHandler eh) : 设置当线程由于未捕获到异常而突然终止，并且没有为该线程定义其他处理程序时所调用的默认处理程序。
static Thread.UncaughtExceptionHandler getDefaultUncaughtExceptionHandler() : 返回线程由于未捕获到异常而突然终止时调用的默认处理程序。(获取未捕获异常的处理器)，如果不设置返回null。
void setUncaughtExceptionHandler(Thread.UncaughtExceptionHandler eh) : 设置该线程由于未捕获到异常而突然终止时调用的处理程序。 
Thread.UncaughtExceptionHandler getUncaughtExceptionHandler() : 获取未捕获异常的处理器，如果未设置返回java.lang.ThreadGroup
 
已过时方法
【已过时】void stop() : 停止该线程
【已过时】void suspend() : 暂停这一线程的运行。
【已过时】void resume() : 恢复线程。

接口 Thread.UncaughtExceptionHandler
方法 void uncaughtException(Thread t, Throwable e) : 当一个线程因未捕获异常而终止，按规定要讲客户报告记录到日志中。
参数 t:由于未捕获异常而终止的线程    e:未捕获异常的对象

类 ThreadGroup
void uncaughtException(Thread t, Throwable e) :
如果此线程组有一个父线程组，那么调用此父线程组的 uncaughtException 方法时带有两个相同的参数。
否则，此方法将查看是否安装了默认的未捕获异常处理程序，如果是，则在调用其 uncaughtException 方法时带有两个相同的参数。
否则，此方法将确认 Throwable 参数是否为一个 ThreadDeath 实例。如果是，则不会做任何特殊的操作。否则，在从线程的 getName 方法返回时，会使用 Throwable 的 printStackTrace 方法，将包含线程名称的消息和堆栈跟踪信息输出到标准错误流。
 
接口 java.util.concurrent.locks.Lock
void lock() : 获取这个锁，如果锁同时被另一个线程拥有则发生阻塞
boolean tryLock() : 尝试获得锁而没有发生阻塞。如果成功返回true，这个方法会抢夺可用的锁，即使该锁有公平加锁策略，即使其他线程已经等待很久。
boolean tryLock(long time, TimeUnit unit) : 尝试获得锁，阻塞时间不会超过给定的值；如果成功返回true。
void lockInterruptibly() : 获得锁，但是会不确定的发生阻塞。如果线程被中断，抛出一个InterruptedException异常。
void unlock() : 释放这个锁

类 java.util.concurrent.locks.ReentrantLock
ReentrantLock() : 构建一个可以用来保护临界区的可重入锁。
ReentrantLock(boolean fair) : 构建一个带有公平策略的锁。一个公平锁偏爱等待时间最长的线程。但是这一公平保证将大大降低性能，所以默认情况下，锁没有强制为公平的。

类 java.util.concurrent.locks.ReentrantReadWriteLock
Lock readLock() : 得到一个可以被多个线程读操作公用的读锁，但会排斥所有写操作。
Lock writeLock() : 得到一个写锁，排斥所有其他的读操作和写操作。

接口 java.util.concurrent.locks.Condition
void await() : 将该线程放到条件的等待集中
void await(long time, TimeUnit unit) : 进入该条件的等待集，直到线程从等待集中移出，或等待了指定时间之后才解除阻塞。如果因为等待时间到了而返回就返回false，否则返回true。
void awaitUninterruptibly() : 进入该条件的等待集，直到线程从等待集移出才解除线程。如果线程被中断，该方法不会抛出InterruptException。
void signalAll() : 唤醒所有等待线程
void signal() : 唤醒一个等待线程

类 java.lang.Object
void notifyAll() : 唤醒在此对象监视器上等待的所有线程。该方法只能在同步方法或同步块内部使用。如果当前线程不是锁的持有者，抛出IllegalMonitorStateException异常。
void notify() : 唤醒在此对象监视器上等待的单个线程。该方法只能在同步方法或同步块内部使用。如果当前线程不是锁的持有者，抛出IllegalMonitorStateException异常。
void wait() : 导致当前线程等待,直到它被通知。该方法只能在同步方法或同步块内部使用。如果当前线程不是锁的持有者，抛出IllegalMonitorStateException异常。
void wait(long millis) : 在其他线程调用此对象的 notify() 方法或 notifyAll() 方法，或者超过指定的时间量前，导致当前线程等待。
void wait(long millis, int nanos) : 在其他线程调用此对象的 notify() 方法或 notifyAll() 方法，或者超过指定的时间量前，导致当前线程等待。millis毫秒数，nanos<1 000 000 纳秒数。

类 java.util.concurrent.ArrayBlockingQueue<E>

类 java.util.concurrent.ConcurrentLinkedQueue<E>
构造 ConcurrentLinkedQueue<E>() : 构造一个可以被多线程安全访问的无边界非阻塞的队列。

类 java.util.concurrent.ConcurrentHashMap<K,V>
构造 ConcurrentHashMap() : 创建一个带有默认初始容量 (16)、加载因子 (0.75) 和 concurrencyLevel (16) 的新的空映射。
ConcurrentHashMap(int initialCapacity, float loadFactor, int concurrencyLevel) : 创建一个带有指定初始容量、加载因子和并发级别的新的空映射。
initialCapacity : 集合的初始容量，默认为16
loadFactor : 控制调整：如果每一个桶的平均负载超过这个因子，表的大小会被从新调整。默认值为0.75
concurrencyLevel : 并发写者线程的估计数目
 
类 java.util.concurrent.ConcurrentSkipListSet
构造 ConcurrentSkipListSet() : 构造一个新的空 set，该set按照元素的自然顺序对其进行排序。或元素实现comparable接口。
构造 ConcurrentSkipListSet(Comparator<? super E> comparator) : 构造一个新的空set，该set按照指定的比较器对其元素进行排序。

类 java.util.concurrent.ConcurrentSkipListMap<K,V>
构造 ConcurrentSkipListMap() : 构造一个新的空映射，该映射按照键的自然顺序进行排序。
构造 ConcurrentSkipListMap(Comparator<? super K> comparator) : 构造一个新的空映射，该映射按照指定的比较器进行排序。

类 java.util.Conllections
static<E> Conllection<E> synchronizedConllection(Collection<E> c)
static<E> List synchronizedList(List<E> c)
static<E> Set synchronizedSet(Set<E> c)
static<E> SortedSet synchronizedSortedSet(SortedSet<E> c)
static<K, V> Map<K, V> synchronizedMap(Map<K, V> c)
static<K, V> SortedMap<K, V> synchronizedSortedMap(SortedMap<K, V> c)

类 java.util.concurrent.ConcurrentLinkedQueue<E>
构造 ConcurrentLinkedQueue<E>() : 构造一个可以被多线程安全访问的无边界非阻塞的队列。

类 java.util.concurrent.ConcurrentHashMap<K,V>
构造 ConcurrentHashMap() : 创建一个带有默认初始容量 (16)、加载因子 (0.75) 和 concurrencyLevel (16) 的新的空映射。
ConcurrentHashMap(int initialCapacity, float loadFactor, int concurrencyLevel) : 创建一个带有指定初始容量、加载因子和并发级别的新的空映射。
initialCapacity : 集合的初始容量，默认为16
loadFactor : 控制调整：如果每一个桶的平均负载超过这个因子，表的大小会被从新调整。默认值为0.75
concurrencyLevel : 并发写者线程的估计数目
 
类 java.util.concurrent.ConcurrentSkipListSet
构造 ConcurrentSkipListSet() : 构造一个新的空 set，该set按照元素的自然顺序对其进行排序。或元素实现comparable接口。
构造 ConcurrentSkipListSet(Comparator<? super E> comparator) : 构造一个新的空set，该set按照指定的比较器对其元素进行排序。

类 java.util.concurrent.ConcurrentSkipListMap<K,V>
构造 ConcurrentSkipListMap() : 构造一个新的空映射，该映射按照键的自然顺序进行排序。
构造 ConcurrentSkipListMap(Comparator<? super K> comparator) : 构造一个新的空映射，该映射按照指定的比较器进行排序。


类 java.util.concurrent.Executors
static ExecutorService newCachedThreadPool() : 返回一个带缓存的线程池，该池在必要的时候创建线程，在线程空闲60秒后终止线程。
static ExecutorService newFixedThreadPool(int nThreads) : 返回一个线程池，该池中的线程数由参数指定。
static ExecutorService newSingleThreadPool() : 返回一个执行器，它在一个单个线程中依次执行各个任务。
static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) : 返回一个线程池，它使用给定的线程数来调度任务。
static ScheduledExecutorService newSingleThreadScheduledExecutor(ThreadFactory threadFactory) : 创建一个单线程执行程序，它可安排在给定延迟后运行命令或者定期地执行。

接口 java.util.concurrent.ExecutorService
Future<T> submit(Callable<T> task) : 提交一个返回值的任务用于执行，返回一个表示任务的未决结果的 Future。
Future<?> submit(Runnable task) : 提交一个 Runnable 任务用于执行，并返回一个表示该任务的 Future。
<T> Future<T> submit(Runnable task, T result) : 提交一个 Runnable 任务用于执行，并返回一个表示该任务的 Future。result为返回的结果。
<T> T invokeAny(Collection<Callable<T>> tasks) : 执行给定的任务，如果某个任务已成功完成（也就是未抛出异常），则返回其结果。
<T> T invokeAny(Collection<? extends Callable<T>> tasks, long timeout, TimeUnit unit) : 执行给定的任务，如果在给定的超时期满前某个任务已成功完成（也就是未抛出异常），则返回其结果。
<T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks) : 执行给定的任务，当所有任务完成时，返回保持任务状态和结果的 Future 列表。
<T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks, long timeout, TimeUnit unit) : 执行给定的任务，当所有任务完成或超时期满时（无论哪个首先发生），返回保持任务状态和结果的 Future 列表。

类 java.util.concurrent.ThreadPoolExecutor
int getLargestPoolSize() : 返回曾经同时位于池中的最大线程数。

类 java.util.concurrent.ScheduledThreadPoolExecutor
<V> ScheduledFuture<V> schedule(Callable<V> callable, long delay, TimeUnit unit) : 创建并执行在给定延迟后启用的 ScheduledFuture。
ScheduledFuture<?> schedule(Runnable command, long delay, TimeUnit unit) : 创建并执行在给定延迟后启用的一次性操作。
ScheduledFuture<?> scheduleAtFixedRate(Runnable command, long initialDelay, long period, TimeUnit unit) : 创建并执行一个在给定初始延迟后首次启用的定期操作，后续操作具有给定的周期；也就是将在 initialDelay 后开始执行，然后在 initialDelay+period 后执行，接着在 initialDelay + 2 * period 后执行，依此类推。
 ScheduledFuture<?> scheduleWithFixedDelay(Runnable command, long initialDelay, long delay, TimeUnit unit) : 创建并执行一个在给定初始延迟后首次启用的定期操作，随后，在每一次执行终止和下一次执行开始之间都存在给定的延迟。
 
类 java.util.concurrent.ExecutorCompletionService   
ExecutorCompletionService(Executor e) : 构建一个执行器完成服务来收集给定执行器的结果
Future<T> submit(Callable<T> task) : 提交一个任务给底层的执行器。
Future<T> submit(Runnable<T> task) : 提交一个任务给底层的执行器。
Future<T> task() : 获取并移除表示下一个已完成任务的 Future，如果目前不存在这样的任务，则等待。
Future<V> poll() : 获取并移除表示下一个已完成任务的 Future，如果不存在这样的任务，则返回 null。
Future<V> poll(long timeout, TimeUnit unit) : 获取并移除表示下一个已完成任务的 Future，如果目前不存在这样的任务，则将等待指定的时间（如果有必要）。