Object类相关api（相关的方法一定是当前线程在获取了对应的锁对象才能调用，否则会抛出异常）
o.wait() ：锁对象调用该方法使当前线程进入等待状态，并立刻释放锁对象，直到被其他线程唤醒进入等锁池。
o.wait(long) ：锁对象调用该方法使当前线程进入等待状态，同时释放锁对象。但是超过等待的时间后线程会自动唤醒，或者被其他线程唤醒，并进入等锁池中。
o.wait(long,int) ：和o.wait(long)方法一样，如果int参数大于0则前面的long数字加1
o.notify()：随机唤醒一个处于等待中的线程（同一个等待阻塞池中）
o.notifyAll()：唤醒所有等待中的线程（同一个等待阻塞池中）
Thread类的相关api
Thread.currentThread()：返回对当前线程对象的引用
Thread.interrupted()：检测当前线程是否已经中断（调用该方法后后就将该线程的中断标志位设置位false，所以连续两次调用该方法第二次肯定时false）
Thread.sleep(long millis)：使当前线程睡眠（不会释放锁对象，可以让其他线程有执行的机会）
Thread.yield()：使当前线程放弃cpu的执行权（有可能立刻又被重新选中继续执行，只可能给优先级更高的线程机会）
t.getId():返回该线程的id
t.getName():返回该线程的名字
t.getPriority():返回该线程的优先级
t.getState():返回该线程的状态
t.getThreadGroup()：返回该线程所属的线程组
t.interrupt():将该线程中断（实际并不会中断，只是将中断标志设置为true），如果线程正处在sleep(),join(),wait()方法中时（也就是正在阻塞中）调用该方法，该方法会抛出异常。
t.interrupted():检测该线程是否已经中断（对中断标志位不作处理）
t.isAlive()：检测该线程是否还活着
t.isDaemon()：检测该线程是否为守护线程
t.isInterrupted()：检测该线程是否已经中断
t.join():在a线程中调用b.join()，则a线程阻塞，直到b线程执行完
t.join(long millis):和上面的方法一样，不过a线程阻塞的时间根据long的大小有关，如果达到设定的阻塞时间，就算b线程没有执行完，a线程也会被唤醒。
JDK5之后java.uti.concurrent包下面的一些工具类方便开发
1、线程池
①为什么需要线程池？ ------- 主要是为了重复利用线程资源，减少系统在创建和销毁线程上所花的时间和开销；同时也可以限制资源过多，防止出现OOM或执行效率下降
②如何获取线程池？
在jdk5及以上版本中，使用java.util.concurrent.Executors类来创建线程池，该类提供了很多静态方法来创建线程池ExecutorService。
1、Executors.newFixedThreadPool(int) 创建一个最大规模固定的线程池，如果当前线程不够用且没有超过线程池限制数量，则创建新的线程。如果线程池已满，则会将任务放入等待队列。
2、Executors.newCachedThreadPool 创建一个最大规模可为Integer.MAX_VALUE 的可缓存的线程池。如果当前线程不够用就增加线程池中的线程数，如果当前线程池中线程过多，则会回收空的线程。
3、Executors.newSingleThreadExecutor创建一个单线程的线程池，确保任务串行
4、Executors.newScheduledThreadPool 创建一个固定大小的线程池，以延迟或者固定周期的方式执行，类似于定时器。
③执行任务和关闭线程池
e.execute(Runnable r) :执行任务无返回值
e.submit(Runnable r) :执行任务返回Future<?> ,实际上是null
e.submit(Runnable r,T result) : 执行任务返回Future<T>
e.submit(Callable c) :执行返回Future<？>
e.invokeAny(Collection<? extends Callable<T> > c):随机执行集合中的一个任务，返回T。如果其中一个任务执行结束(或者抛了一个异常)，其他 Callable 将被取消。
e.invokeAll(Collection<? extends Callable<T> > c)：执行集合中所有的任务，返回List<Future<T>>
e.shutdown():调用该方法后线程池立刻变成shutdown状态，不能再往线程池中增加新的任务否则将会抛出RejectedExecutionException异常，等所有进入队列的任务都执行完毕后关闭线程池
e.shutdownNow()：调用该方法后，线程池立刻变成stop状态，停止接受新的任务，并且试图停止所有正在执行的任务（使用的是Thread.interrupt()方法，不一定能中断正在执行的线程），不会执行等待队列中的任务，然后关闭线程池。
public class Test7 { public static void main(String[] args) throws InterruptedException, ExecutionException { //获取当前系统cpu的数目 int availableProcessors = Runtime.getRuntime().availableProcessors(); ExecutorService fixedThreadPool = Executors.newFixedThreadPool(availableProcessors); fixedThreadPool.execute(new MyThread7()); fixedThreadPool.shutdown(); ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor(); Future<?> future = singleThreadExecutor.submit(new MyThread7()); Future<?> future2 = singleThreadExecutor.submit(new MyThread8()); System.out.println("future: "+future.get()); System.out.println("future2: "+future2.get()); singleThreadExecutor.shutdown(); ExecutorService cachedThreadPool = Executors.newCachedThreadPool(); String result = "这是result"; Future<String> submit = cachedThreadPool.submit(new MyThread7(),result); System.out.println("..."+submit.get()); cachedThreadPool.shutdown(); ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(availableProcessors); //初始延迟3秒钟，只执行一次 scheduledThreadPool.schedule(new MyThread8(), 3, TimeUnit.SECONDS ); //初始延迟2秒中，每5秒执行一次 scheduledThreadPool.scheduleWithFixedDelay(new FixedDelay(), 2, 5, TimeUnit.SECONDS); //初始延迟1秒钟，每4秒中执行一次 scheduledThreadPool.scheduleAtFixedRate(new FixedRate(), 1, 4, TimeUnit.SECONDS); Thread.sleep(20000); scheduledThreadPool.shutdown(); } } class MyThread7 implements Runnable{ @Override public void run() { System.out.println("执行代码:"+System.currentTimeMillis()/1000); } } class MyThread8 implements Callable<String>{ @Override public String call() { System.out.println("执行代码:"+System.currentTimeMillis()/1000); return "执行完成"; } } class FixedDelay implements Runnable{ @Override public void run() { System.out.println("FixedDelay执行代码:"+System.currentTimeMillis()/1000); } } class FixedRate implements Runnable{ @Override public void run() { System.out.println("FixedRate执行代码:"+System.currentTimeMillis()/1000); } }
执行结果：
执行代码:1523348201
执行代码:1523348201
future: null
执行代码:1523348201
future2: 执行完成
执行代码:1523348201
...这是result
FixedRate执行代码:1523348202
FixedDelay执行代码:1523348203
执行代码:1523348204
FixedRate执行代码:1523348206
FixedDelay执行代码:1523348208
FixedRate执行代码:1523348210
FixedDelay执行代码:1523348213
FixedRate执行代码:1523348214
FixedRate执行代码:1523348218
FixedDelay执行代码:1523348218
④ThreadPoolExecutor学习
其实通过源码可知newFixedThreadPool、newCachedThreadPool、newSingleThreadExecutor 三种线程池的创建都是通过调用如下的方法来创建的。
public ThreadPoolExecutor(int corePoolSize,//核心线程池大小 int maximumPoolSize,//最大线程池大小 long keepAliveTime,//线程执行完成后在线程池中的缓存时间，也就是线程空闲多长时间后会被回收 TimeUnit unit,//时间单位TimeUnit.SECONDS 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.acc = System.getSecurityManager() == null ?
null :
AccessController.getContext();
this.corePoolSize = corePoolSize;
this.maximumPoolSize = maximumPoolSize;
this.workQueue = workQueue;
this.keepAliveTime = unit.toNanos(keepAliveTime);
this.threadFactory = threadFactory;
this.handler = handler;
}
线程池总结：
ThreadPoolExecutor对象初始化时，不创建任何执行线程，当有新任务进来时，才会创建线程来执行任务。当目前执行线程的总数小于核心线程大小时，所有新加入的任务，都会创建新线程来处理。当目前执行线程的总数大于或等于核心线程时，所有新加入的任务，都放入任务缓存队列中。当目前执行线程的总数大于或等于核心线程，并且缓存队列已满，同时此时线程总数小于线程池的最大规模，那么创建新线程，协助处理新的任务。当所有线程都在执行，线程池大小已经达到上限，并且缓存队列已满时，就rejectHandler拒绝新的任务。
2、BlockingQueue:阻塞队列。
下面是接口中一些常见的方法：BlockingQueue中不能插入null值，否则会抛出NullPointerException。
①ArrayBlockingQueue:有界的阻塞队列，其内部是通过数组实现，
②DelayQueue：无界的阻塞延时队列，加入该队列的元素需要实现Delayed接口，实现该接口的元素会有一个过期时间，只有过期的元素才能被取出。队列中元素会根据过期的先后顺序排序
③LinkedBlockingQueue：通过链式结构对元素进行储存，该链式结构可以设置存储上限，如果没有则用Integer.MAX_VALUE作为上限。
④PriorityBlockingQueue：优先级队列，加入该队列的元素必须实现Comparable接口，因为队列会根据compare（）方法来对元素进行排序。
⑤SynchronousQueue：同步队列，该队列只能容纳一个元素，如果队列中已经有元素，则新加入的元素会阻塞。
⑥BlockingDeque：阻塞双端队列，可以将元素放入队列两端或从两端取出元素，该接口继承了BlockingQueue，实现类为LinkedBlockingDeque。
3、java.util.concurrent.ConcurrentHashMap:和java.util.HashTable类似，但是ConcurrentHashMap拥有更好的并发性能。它在写入数据的时候不会将整个ConcurrentHashMap锁住，而是将写入的部分锁住。
4、CountDownLatch：闭锁是一个并发构造，它允许一个或多个线程等待一系列的操作完成。CountDownLatch初始化时需要给定一个数量，闭锁调用await（）方法可以使线程进入等待状态，该闭锁每调用一次countDown()就会将数量减1，当数量减为0后，所有的等待线程就会被唤醒。
4、java.util.concurrent.CyclicBarrier:栅栏是一种类的同步机制，可以实现所有线程运行到某处后等待（通过调用await（）方法），直到满足了所需的数量，才会一起释放去继续执行。当然也可以设定等待时间，那样即使没有达到数量也会继续执行。类似于约人一起去玩，先在某个地方一起集合，然后一起去。这是可以重复使用的。
5.每次CyclicBarrier都支持栅栏行动，当最后一个线程都运行到栅栏时，就会执行该行动。CyclicBarrier行动就是一个线程。
6、交换机java.util.concurrent.Exchanger：表示两个线程可以交换一类对象的汇合点，通过exchange（o）方法来交换对象。
7、信号量java.util.concurrent.Semaphore：它是一个计数信号量，主要用于防止超过N个线程同时执行一块代码，或者进行两个线程之间发送信号。它主要有两个方法，require（）和release（）分别用来获取许可和释放许可。
8、java.util.concurrent.locks.Lock：一个类似于 synchronized 块的线程同步机制。但是 Lock 比 synchronized 块更加灵活、精细。实现类java.util.concurrent.locks.ReentrantLock
9、java.util.concurrent.locks.ReadWriteLock ：读写锁，它能够允许多个线程在同一时间对某特定资源进行读取，但同一时间内只能有一个线程对其进行写入。实现类 java.util.concurrent.locks.ReentrantReadWriteLock
10、ForkJoinPool：其作用和ExecutorService差不多，但是其可以对任务进行分叉和合并
11、AtomicBoolean、AtomicInteger、AtomicLong ：数据具有原子性，并且增加了一些操作的方法。
12、AtomicReference提供了一个可以被原子性读和写的对象引用变量