theQueue) {
public void run() {
void take(Object obj) {测试该解决方案是否运行正常
/ 描述: 测试 @author yanpenglei @create 2018-03-14 15:58
public static void main(String[] args) throws InterruptedException {
int numProducers = 4 ;< br /> int numConsumers = 3 ; BlockingQueue < Object > myQueue = new LinkedBlockingQueue < Object >( 5 ); for ( int i = 0 ; i < numProducers ; i ++) {< br /> new Thread ( new Producer ( myQueue )). start ();< br /> } for ( int i = 0 ; i < numConsumers ; i ++) {< br /> new Thread ( new Consumer ( myQueue )). start ();< br /> } Thread . sleep ( 1000 ); System . exit ( 0 );< br /> }< br />}< br />**运行结果**< br />生产者资源队列大小= 1 < br />生产者资源队列大小= 1 < br />消费者 资源 队列大小 1 < br />生产者资源队列大小= 1 < br />消费者 资源 队列大小 1 < br />消费者 资源 队列大小 1 < br />生产者资源队列大小= 1 < br />生产者资源队列大小= 3 < br />消费对象 java . lang . Object@1e1aa52b < br />生产者资源队列大小= 2 < br />生产者资源队列大小= 5 < br />消费对象 java . lang . Object@6e740a76 < br />消费对象 java . lang . Object@697853f6 ……
消费对象 java.lang.Object@41a10cbc从输出结果中,我们可以发现队列大小永远不会超过5，消费者线程消费了生产者生产的资源 。
Callable 和 Future 是比较有趣的一对组合。当我们需要获取线程的执行结果时，就需要用到它们。Callable用于产生结果，Future用于获取结果 。Callable接口使用泛型去定义它的返回类型 。Executors类提供了一些有用的方法去在线程池中执行Callable内的任务。由于Callable任务是并行的，必须等待它返回的结果。java.util.concurrent.Future对象解决了这个问题。在线程池提交Callable任务后返回了一个Future对象 ，使用它可以知道Callable任务的状态和得到Callable返回的执行结果。Future提供了get()方法，等待Callable结束并获取它的执行结果。代码示例 Callable 是一个接口，它只包含一个call()方法。Callable是一个返回结果并且可能抛出异常的任务 。为了便于理解，我们可以将Callable比作一个Runnable接口，而Callable的call()方法则类似于Runnable的run()方法 。
public static void main(String[] args) throws InterruptedException, ExecutionException {
System . out . println ( "start main thread " ); ExecutorService exec = Executors . newFixedThreadPool ( 2 ); //新建一个Callable 任务，并将其提交到一个ExecutorService. 将返回一个描述任务情况的Future.<br /> Callable<String> call = new Callable<String>() { @Override < br /> public String call () throws Exception {< br /> System . out . println ( "start new thread " );< br /> Thread . sleep ( 5000 );< br /> System . out . println ( "end new thread " );< br /> return "我是返回的内容" ;< br /> }< br /> }; Future < String > task = exec . submit ( call );< br /> Thread . sleep ( 1000 );< br /> String retn = task . get ();< br /> //关闭线程池<br /> exec.shutdown();<br /> System.out.println(retn + "--end main thread");<br /> }<br />}<br />控制台打印<br />start main thread <br />start new thread<br />end new thread<br />我是返回的内容--end main thread
FutureTask可用于异步获取执行结果或取消执行任务的场景。通过传入Runnable或者Callable的任务给FutureTask，直接调用其run方法或者放入线程池执行，之后可以在外部通过FutureTask的get方法异步获取执行结果，因此，FutureTask非常适合用于耗时的计算，主线程可以在完成自己的任务后，再去获取结果。另外，FutureTask还可以确保即使调用了多次run方法，它都只会执行一次Runnable或者Callable任务，或者通过cancel取消FutureTask的执行等。
FutureTask执行多任务计算的使用场景
public class FutureTaskForMultiCompute {
public static void main(String[] args) {
FutureTaskForMultiCompute inst = new FutureTaskForMultiCompute ();< br /> // 创建任务集合<br /> List<FutureTask<Integer>> taskList = new ArrayList<FutureTask<Integer>>();<br /> // 创建线程池<br /> ExecutorService exec = Executors.newFixedThreadPool(5);<br /> for (int i = 0; i < 10; i++) {<br /> // 传入Callable对象创建FutureTask对象<br /> FutureTask<Integer> ft = new FutureTask<Integer>(inst.new ComputeTask(i, "" + i));<br /> taskList.add(ft);<br /> // 提交给线程池执行任务，也可以通过exec.invokeAll(taskList)一次性提交所有任务;<br /> exec.submit(ft);<br /> } System . out . println ( "所有计算任务提交完毕, 主线程接着干其他事情！" ); // 开始统计各计算线程计算结果<br /> Integer totalResult = 0;<br /> for (FutureTask<Integer> ft : taskList) {<br /> try {<br /> //FutureTask的get方法会自动阻塞,直到获取计算结果为止<br /> totalResult = totalResult + ft.get();<br /> } catch (InterruptedException e) {<br /> e.printStackTrace();<br /> } catch (ExecutionException e) {<br /> e.printStackTrace();<br /> }<br /> } // 关闭线程池<br /> exec.shutdown();<br /> System.out.println("多任务计算后的总结果是:" + totalResult); }
private class ComputeTask implements Callable {
private Integer result = 0 ;< br /> private String taskName = "" ; public ComputeTask ( Integer iniResult , String taskName ) {< br /> result = iniResult ;< br /> this . taskName = taskName ;< br /> System . out . println ( "生成子线程计算任务: " + taskName );< br /> } public String getTaskName () {< br /> return this . taskName ;< br /> } @Override < br /> public Integer call () throws Exception {< br /> // TODO Auto-generated method stub for ( int i = 0 ; i < 100 ; i ++) {< br /> result = + i ;< br /> }< br /> // 休眠5秒钟，观察主线程行为，预期的结果是主线程会继续执行，到要取得FutureTask的结果是等待直至完成。<br /> Thread.sleep(5000);<br /> System.out.println("子线程计算任务: " + taskName + " 执行完成!");<br /> return result;<br /> }<br /> }<br />}<br />生成子线程计算任务: 0<br />生成子线程计算任务: 1<br />生成子线程计算任务: 2<br />生成子线程计算任务: 3<br />生成子线程计算任务: 4<br />生成子线程计算任务: 5<br />生成子线程计算任务: 6<br />生成子线程计算任务: 7<br />生成子线程计算任务: 8<br />生成子线程计算任务: 9<br />所有计算任务提交完毕, 主线程接着干其他事情！<br />子线程计算任务: 0 执行完成!<br />子线程计算任务: 2 执行完成!<br />子线程计算任务: 3 执行完成!<br />子线程计算任务: 4 执行完成!<br />子线程计算任务: 1 执行完成!<br />子线程计算任务: 8 执行完成!<br />子线程计算任务: 7 执行完成!<br />子线程计算任务: 6 执行完成!<br />子线程计算任务: 9 执行完成!<br />子线程计算任务: 5 执行完成!<br />多任务计算后的总结果是:990
FutureTask在高并发环境下确保任务只执行一次 connectionPool = new HashMap();
public Connection getConnection(String key) {
//创建Connection > connectionPool = new ConcurrentHashMap>();
public Connection getConnection(String key) throws Exception { connectionTask = connectionPool.get(key); callable = new Callable() { newTask = new FutureTask(callable);
//创建Connection 经过这样的改造，可以避免由于并发带来的多次创建连接及锁的出现。
主要代表有Vector和Hashtable，以及Collections.synchronizedXxx等。
主要代表有ConcurrentHashMap、CopyOnWriteArrayList、ConcurrentSkipListMap、ConcurrentSkipListSet。JDK 7 ConcurrentHashMap JDK 8 ConcurrentHashMap
主要代表有LinkedBlockingQueue、ArrayBlockingQueue、PriorityBlockingQueue(Comparable,Comparator)、SynchronousQueue。
主要代表有ArrayDeque和LinkedBlockingDeque。
如果不需要阻塞队列，优先选择ConcurrentLinkedQueue；
什么是多线程？ 多线程的好处：
使用多线程可以把程序中占据时间长的任务放到后台去处理，如图片、视屏的下载 发挥多核处理器的优势，并发执行让系统运行的更快、更流畅，用户体验更好
多线程的缺点：
大量的线程降低代码的可读性； 更多的线程需要更多的内存空间 当多个线程对同一个资源出现争夺时候要注意线程安全的问题。
上下文切换过程中，CPU会停止处理当前运行的程序，并保存当前程序运行的具体位置以便之后继续运行 CPU通过时间片分配算法来循环执行任务，当前任务执行一个时间片后会切换到下一个任务。但是，在切换前会保存上一个任务的状态，以便下次切换回这个任务时，可以再次加载这个任务的状态
从任务保存到再加载的过程就是一次上下文切换
如何创建ThreadLocal变量 所有的线程都能访问到这个ThreadLocal实例，但是每个线程却只能访问到自己通过调用ThreadLocal的set()方法设置的值。即使是两个不同的线程在同一个ThreadLocal对象上设置了不同的值，他们仍然无法访问到对方的值 。如何访问ThreadLocal变量 为ThreadLocal指定泛型类型 myThreadLocal = new ThreadLocal();ThreadLocal的设计理念与作用 http://blog.csdn.net/u011860731/article/details/48733073http://blog.csdn.net/u011860731/article/details/48733073 )
threadLocal = new InheritableThreadLocal();InheritableThreadLocal允许一个线程以及该线程创建的所有子线程都可以访问它保存的值 。InheritableThreadLocal 原理 Java 多线程：InheritableThreadLocal 实现原理 http://blog.csdn.net/ni357103403/article/details/51970748
减少了创建和销毁线程的次数，每个工作线程都可以被重复利用，可执行多个任务。 可以根据系统的承受能力，调整线程池中工作线线程的数目，防止因为消耗过多的内存，而把服务器累趴下(每个线程需要大约1MB内存，线程开的越多，消耗的内存也就越大，最后死机)。 Java里面线程池的顶级接口是Executor，但是严格意义上讲Executor并不是一个线程池，而只是一个执行线程的工具。真正的线程池接口是ExecutorService。
每次new Thread新建对象性能差。
线程缺乏统一管理，可能无限制新建线程，相互之间竞争，及可能占用过多系统资源导致死机或oom。 缺乏更多功能，如定时执行、定期执行、线程中断。
减少在创建和销毁线程上所花的时间以及系统资源的开销 如不使用线程池，有可能造成系统创建大量线程而导致消耗完系统内存
Java提供的四种线程池的好处在于 ：
重用存在的线程，减少对象创建、销毁的开销，提高性能。 可有效控制最大并发线程数，提高系统资源的使用率，同时避免过多资源竞争，避免堵塞。 提供定时执行、定期执行、单线程、并发数控制等功能。
要配置一个线程池是比较复杂的，尤其是对于线程池的原理不是很清楚的情况下，很有可能配置的线程池不是较优的，因此在Executors类里面提供了一些静态工厂，生成一些常用的线程池。
newCachedThreadPool 创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。newFixedThreadPool 创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。newScheduledThreadPool 创建一个定长线程池，支持定时及周期性任务执行。newSingleThreadExecutor 创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。
使用ThreadPoolExecutor创建线程池 ThreadPoolExecutor的构造函数 workQueue,
corePoolSize 核心线程数大小，当线程数<corePoolSize ，会创建线程执行runnablemaximumPoolSize 最大线程数， 当线程数 >= corePoolSize的时候，会把runnable放入workQueue中keepAliveTime 保持存活时间，当线程数大于corePoolSize的空闲线程能保持的最大时间。unit 时间单位workQueue 保存任务的阻塞队列threadFactory 创建线程的工厂handler 拒绝策略
当线程数小于corePoolSize时，创建线程执行任务。
当线程数大于等于corePoolSize并且workQueue没有满时，放入workQueue中 线程数大于等于corePoolSize并且当workQueue满时，新任务新建线程运行，线程总数要小于maximumPoolSize 当线程总数等于maximumPoolSize并且workQueue满了的时候执行handler的rejectedExecution。也就是拒绝策略。
ThreadPoolExecutor.AbortPolicy() 直接抛出异常RejectedExecutionException
ThreadPoolExecutor.CallerRunsPolicy() 直接调用run方法并且阻塞执行ThreadPoolExecutor.DiscardPolicy() 直接丢弃后来的任务ThreadPoolExecutor.DiscardOldestPolicy() 丢弃在队列中队首的任务
当然可以自己继承 RejectedExecutionHandler 来写拒绝策略.
https://juejin.im/post/59df0c1af265da432f301c8d
阻塞队列 ArrayBlockingQueue 数组结构组成的有界阻塞队列。
CountDownLatch 允许一个或多个线程等待其他线程完成操作。应用场景
public static void main(String[] args) throws InterruptedException {
Thread parser2 = new Thread ( new Runnable () {< br /> @Override < br /> public void run () {< br /> System . out . println ( "parser2 finish" );< br /> }< br /> }); parser1 . start ();< br /> parser2 . start ();< br /> parser1 . join ();< br /> parser2 . join ();< br /> System . out . println ( "all parser finish" );< br />} }
方法isAlive()功能是判断当前线程是否处于活动状态。 活动状态就是线程启动且尚未终止，比如正在运行或准备开始运行。
public class Test {Java并发编程：CountDownLatch、CyclicBarrier和 Semaphore http://www.importnew.com/21889.html
java在编写多线程程序时，为了保证线程安全，需要对数据同步，经常用到两种同步方式就是Synchronized和重入锁ReentrantLock。
可重入锁 。可重入锁是指同一个线程可以多次获取同一把锁。ReentrantLock和synchronized都是可重入锁 。
可中断锁 。可中断锁是指线程尝试获取锁的过程中，是否可以响应中断。synchronized是不可中断锁，而ReentrantLock则提供了中断功能。公平锁与非公平锁 。公平锁是指多个线程同时尝试获取同一把锁时，获取锁的顺序按照线程达到的顺序，而非公平锁则允许线程“插队”。synchronized是非公平锁，而ReentrantLock的默认实现是非公平锁，但是也可以设置为公平锁。CAS操作(CompareAndSwap) 。CAS操作简单的说就是比较并交换。CAS 操作包含三个操作数 —— 内存位置（V）、预期原值（A）和新值(B)。如果内存位置的值与预期原值相匹配，那么处理器会自动将该位置值更新为新值。否则，处理器不做任何操作。无论哪种情况，它都会在 CAS 指令之前返回该位置的值。CAS 有效地说明了“我认为位置 V 应该包含值 A；如果包含该值，则将 B 放到这个位置；否则，不要更改该位置，只告诉我这个位置现在的值即可。”
当线程尝试获取锁的时候，如果获取不到锁会一直阻塞。 如果获取锁的线程进入休眠或者阻塞，除非当前线程异常，否则其他线程尝试获取锁必须一直等待。
**lock ()**, 如果获取了锁立即返回，如果别的线程持有锁，当前线程则一直处于休眠状态，直到获取锁tryLock() , 如果获取了锁立即返回true，如果别的线程正持有锁，立即返回false；tryLock(long timeout,TimeUnit unit)** ，如果获取了锁定立即返回true，如果别的线程正持有锁，会等待参数给定的时间，在等待的过程中，如果获取了锁定，就返回true，如果等待超时，返回false；lockInterruptibly :如果获取了锁定立即返回，如果没有获取锁定，当前线程处于休眠状态，直到或者锁定，或者当前线程被别的线程中断
ReentrantLock 一些特性
等待可中断避免，出现死锁的情况 （如果别的线程正持有锁，会等待参数给定的时间，在等待的过程中，如果获取了锁定，就返回true，如果等待超时，返回false）公平锁与非公平锁 多个线程等待同一个锁时，必须按照申请锁的时间顺序获得锁，Synchronized锁非公平锁，ReentrantLock默认的构造函数是创建的非公平锁，可以通过参数true设为公平锁 ，但公平锁表现的性能不是很好。
公平锁：线程获取锁的顺序和调用lock的顺序一样，FIFO；Java并发包(java.util.concurrent)中大量使用了CAS操作,涉及到并发的地方都调用了sun.misc.Unsafe类方法进行CAS操作 。
简单来说，ReenTrantLock的实现是一种自旋锁，通过循环调用CAS操作来实现加锁 。它的性能比较好也是因为避免了使线程进入内核态的阻塞状态。想尽办法避免线程进入内核的阻塞状态是我们去分析和理解锁设计的关键钥匙。
在Synchronized优化以前，synchronized的性能是比ReenTrantLock差很多的，但是自从Synchronized引入了偏向锁，轻量级锁（自旋锁）后，两者的性能就差不多了，在两种方法都可用的情况下，官方甚至建议使用synchronized，其实synchronized的优化我感觉就借鉴了ReenTrantLock中的CAS技术。都是试图在用户态就把加锁问题解决，避免进入内核态的线程阻塞。synchronized ：ReentrantLock :使用非公平锁是基于性能考虑 ，公平锁为了保证线程规规矩矩地排队，需要增加阻塞和唤醒的时间开销。如果直接插队获取非公平锁，跳过了对队列的处理，速度会更快。ReentrantLock实现原理 https://www.cnblogs.com/maypattis/p/6403682.html 分析ReentrantLock的实现原理 (ReentrantLock和同步工具类的实现基础都是AQS)https://www.jianshu.com/p/fe027772e156
Semaphore就是一个信号量，它的作用是限制某段代码块的并发数 。 Semaphore有一个构造函数，可以传入一个int型整数n，表示某段代码最多只有n个线程可以访问 ， 如果超出了n，那么请等待，等到某个线程执行完毕这段代码块，下一个线程再进入 。由此可以看出如果Semaphore构造函数中传入的int型整数n=1，相当于变成了一个synchronized了。
Semaphore类位于java.util.concurrent包下，它提供了2个构造器：
Semaphore类中比较重要的几个方法，首先是acquire()、release()方法： acquire()用来获取一个许可，若无许可能够获得，则会一直等待，直到获得许可。 release()用来释放许可。注意，在释放许可之前，必须先获获得许可。
Semaphore类中比较重要的几个方法，首先是acquire()、release()方法：
假若一个工厂有5台机器，但是有8个工人，一台机器同时只能被一个工人使用，只有使用完了，其他工人才能继续使用。那么我们就可以通过Semaphore来实现： new Worker(i,semaphore).start();
Lock接口比同步方法和同步块提供了更具扩展性的锁操作。他们允许更灵活的结构，可以具有完全不同的性质，并且可以支持多个相关类的条件对象。
可以使锁更公平 可以使线程在等待锁的时候响应中断 可以让线程尝试获取锁，并在无法获取锁的时候立即返回或者等待一段时间 可以在不同的范围，以不同的顺序获取和释放锁
同一时间只能有一条线程执行固定类的同步方法，但是对于类的非同步方法，可以多条线程同时访问。所以，这样就有问题了，可能线程A在执行Hashtable的put方法添加数据，线程B则可以正常调用size()方法读取Hashtable中当前元素的个数，那读取到的值可能不是最新的，可能线程A添加了完了数据，但是没有对size++，线程B就已经读取size了，那么对于线程B来说读取到的size一定是不准确的。而给size()方法加了同步之后，意味着线程B调用size()方法只有在线程A调用put方法完毕之后才可以调用，这样就保证了线程安全性
ConcurrentHashMap的并发度就是segment的大小，默认为16，这意味着最多同时可以有16条线程操作ConcurrentHashMap，这也是ConcurrentHashMap对Hashtable的最大优势
Lock比传统线程模型中的synchronized方式更加面向对象，与生活中的锁类似，锁本身也应该是一个对象。两个线程执行的代码片段要实现同步互斥的效果，它们必须用同一个Lock对象。读写锁 ：分为读锁和写锁，多个读锁不互斥，读锁与写锁互斥，这是由jvm自己控制的，你只要上好相应的锁即可 。如果你的代码只读数据，可以很多人同时读，但不能同时写，那就上读锁 ；ReentrantReadWriteLock会使用两把锁来解决问题，一个读锁，一个写锁 线程进入读锁的前提条件 ：
没有其他线程的写锁
没有写请求或者有写请求，但调用线程和持有锁的线程是同一个
线程进入写锁的前提条件 ：
没有其他线程的读锁 没有其他线程的写锁 读锁的重入是允许多个申请读操作的线程的，而写锁同时只允许单个线程占有，该线程的写操作可以重入。 如果一个线程占有了写锁，在不释放写锁的情况下，它还能占有读锁，即写锁降级为读锁。 对于同时占有读锁和写锁的线程，如果完全释放了写锁，那么它就完全转换成了读锁，以后的写操作无法重入，在写锁未完全释放时写操作是可以重入的。 公平模式下无论读锁还是写锁的申请都必须按照AQS锁等待队列先进先出的顺序。非公平模式下读操作插队的条件是锁等待队列head节点后的下一个节点是SHARED型节点，写锁则无条件插队。 读锁不允许newConditon获取Condition接口，而写锁的newCondition接口实现方法同ReentrantLock。
什么是线程？ 什么是线程安全和线程不安全？ 什么是自旋锁？ 什么是Java内存模型？ 什么是CAS？ 什么是乐观锁和悲观锁？ 什么是AQS？ 什么是原子操作？在Java Concurrency API中有哪些原子类(atomic classes)？ 什么是Executors框架？ 什么是阻塞队列？如何使用阻塞队列来实现生产者-消费者模型？ 什么是Callable和Future? 什么是FutureTask? 什么是同步容器和并发容器的实现？ 什么是多线程？优缺点？ 什么是多线程的上下文切换？ ThreadLocal的设计理念与作用？ ThreadPool（线程池）用法与优势？ Concurrent包里的其他东西：ArrayBlockingQueue、CountDownLatch等等。 synchronized和ReentrantLock的区别？ Semaphore有什么作用？ Java Concurrency API中的Lock接口(Lock interface)是什么？对比同步它有什么优势？ Hashtable的size()方法中明明只有一条语句”return count”，为什么还要做同步？ ConcurrentHashMap的并发度是什么？ ReentrantReadWriteLock读写锁的使用？ CyclicBarrier和CountDownLatch的用法及区别？ LockSupport工具？ Condition接口及其实现原理？ Fork/Join框架的理解? wait()和sleep()的区别? 线程的五个状态（五种状态，创建、就绪、运行、阻塞和死亡）? start()方法和run()方法的区别？ Runnable接口和Callable接口的区别？ volatile关键字的作用？ Java中如何获取到线程dump文件？ 线程和进程有什么区别？ 线程实现的方式有几种（四种）？ 高并发、任务执行时间短的业务怎样使用线程池？并发不高、任务执行时间长的业务怎样使用线程池？并发高、业务执行时间长的业务怎样使用线程池？ 如果你提交任务时，线程池队列已满，这时会发生什么？ 锁的等级：方法锁、对象锁、类锁? 如果同步块内的线程抛出异常会发生什么？ 并发编程（concurrency）并行编程（parallellism）有什么区别？ 如何保证多线程下 i++ 结果正确？ 一个线程如果出现了运行时异常会怎么样? 如何在两个线程之间共享数据? 生产者消费者模型的作用是什么? 怎么唤醒一个阻塞的线程? Java中用到的线程调度算法是什么 单例模式的线程安全性? 线程类的构造方法、静态块是被哪个线程调用的? 同步方法和同步块，哪个是更好的选择? 如何检测死锁？怎么预防死锁？
通俗的说：加锁的就是是线程安全的，不加锁的就是是线程不安全的
线程安全: 就是多线程访问时，采用了加锁机制，当一个线程访问该类的某个数据时，进行保护，其他线程不能进行访问，直到该线程读取完，其他线程才可使用。不会出现数据不一致或者数据污染 。集合类分成两组，线程安全和非线程安全的 。线程不安全：就是不提供数据访问保护，有可能出现多个线程先后更改数据造成所得到的数据是脏数据 自旋锁是SMP架构中的一种low-level的同步机制 。自选锁需要注意 ：
由于自旋时不释放CPU，因而持有自旋锁的线程应该尽快释放自旋锁，否则等待该自旋锁的线程会一直在那里自旋，这就会浪费CPU时间。 持有自旋锁的线程在sleep之前应该释放自旋锁以便其它线程可以获得自旋锁 。
参考https://segmentfault.com/q/1010000000530936
MonitorObject myMonitorObject = new MonitorObject();
public void doWait(){
public void doNotify(){
Java内存模型描述了在多线程代码中哪些行为是合法的，以及线程如何通过内存进行交互。它描述了“程序中的变量“ 和 ”从内存或者寄存器获取或存储它们的底层细节”之间的关系。Java内存模型通过使用各种各样的硬件和编译器的优化来正确实现以上事情 。Java包含了几个语言级别的关键字，包括：volatile, final以及synchronized，目的是为了帮助程序员向编译器描述一个程序的并发需求。Java内存模型定义了volatile和synchronized的行为，更重要的是保证了同步的java程序在所有的处理器架构下面都能正确的运行。
public void reader() {
JVM内存结构主要有三大块：堆内存、方法区和栈 。Eden空间、From Survivor空间、To Survivor空间 ,默认情况下年轻代按照8:1:1的比例来分配；方法区存储类信息、常量、静态变量等数据，是线程共享的区域 ，为与Java堆区分，方法区还有一个别名Non-Heap(非堆)；栈又分为java虚拟机栈和本地方法栈主要用于方法的执行。JAVA的JVM的内存可分为3个区：堆(heap)、栈(stack)和方法区(method)
可通过参数 -Xms 和-Xmx设置
Java堆是被所有线程共享,是Java虚拟机所管理的内存中最大的一块 Java堆在虚拟机启动时创建 。Java堆唯一的目的是存放对象实例，几乎所有的对象实例和数组都在这里 。Java堆为了便于更好的回收和分配内存，可以细分为：新生代和老年代 ；再细致一点的有Eden空间、From Survivor空间、To Survivor区 。
新生代 ：包括Eden区、From Survivor区、To Survivor区，系统默认大小Eden:Survivor=8:1。老年代 ：在年轻代中经历了N次垃圾回收后仍然存活的对象，就会被放到年老代中。因此，可以认为年老代中存放的都是一些生命周期较长的对象。
Survivor空间等Java堆可以处在物理上不连续的内存空间中，只要逻辑上是连续的即可（就像我们的磁盘空间一样。在实现时，既可以实现成固定大小的，也可以是可扩展的）。
据Java虚拟机规范的规定，当方法区无法满足内存分配需求时，将抛出OutOfMemoryError异常 。
可通过参数 栈帧是方法运行期的基础数据结构栈容量可由-Xss设置 Java虚拟机栈是线程私有的，它的生命周期与线程相同 。
每一个方法被调用直至执行完成的过程，就对应着一个栈帧在虚拟机栈中从入栈到出栈的过程。 虚拟机栈是执行Java方法的内存模型(也就是字节码)服务：每个方法在执行的同时都会创建一个栈帧 ，用于存储 局部变量表 、操作数栈 、动态链接 、方法出口 等信息。
局部变量表 ：32位变量槽，存放了编译期可知的各种基本数据类型、对象引用、returnAddress类型 。操作数栈 ：基于栈的执行引擎，虚拟机把操作数栈作为它的工作区，大多数指令都要从这里弹出数据、执行运算，然后把结果压回操作数栈。动态连接 ：每个栈帧都包含一个指向运行时常量池（方法区的一部分）中该栈帧所属方法的引用 。持有这个引用是为了支持方法调用过程中的动态连接。Class文件的常量池中有大量的符号引用，字节码中的方法调用指令就以常量池中指向方法的符号引用为参数。这些符号引用一部分会在类加载阶段或第一次使用的时候转化为直接引用，这种转化称为静态解析。另一部分将在每一次的运行期间转化为直接应用，这部分称为动态连接方法出口 ：返回方法被调用的位置，恢复上层方法的局部变量和操作数栈，如果无返回值，则把它压入调用者的操作数栈。
局部变量表所需的内存空间在编译期间完成分配 ，当进入一个方法时，这个方法需要在帧中分配多大的局部变量空间是完全确定的。在方法运行期间不会改变局部变量表的大小。主要存放了编译期可知的各种基本数据类型、对象引用 （reference类型）、returnAddress类型）。
undefinedjava虚拟机栈,规定了两种异常状况：
如果线程请求的深度大于虚拟机所允许的深度，将抛出StackOverflowError异常 。如果虚拟机栈动态扩展，而扩展时无法申请到足够的内存，就会抛出OutOfMemoryError异常 。
可通过参数 栈容量可由-Xss设置
虚拟机栈为虚拟机执行Java方法（也就是字节码）服务。
本地方法栈则是为虚拟机使用到的Native方法服务。有的虚拟机（譬如Sun HotSpot虚拟机）直接就把本地方法栈和虚拟机栈合二为一
可通过参数-XX:MaxPermSize设置
线程共享内存区域，用于储存已被虚拟机加载的类信息、常量、静态变量，即编译器编译后的代码，方法区也称持久代（Permanent Generation） 。
虽然Java虚拟机规范把方法区描述为堆的一个逻辑部分，但是它却有一个别名叫做Non-Heap（非堆） ，目的应该是与Java堆区分开来。 如何实现方法区，属于虚拟机的实现细节，不受虚拟机规范约束。 方法区主要存放java类定义信息，与垃圾回收关系不大，方法区可以选择不实现垃圾回收,但不是没有垃圾回收。 方法区域的内存回收目标主要是针对常量池的回收和对类型的卸载 。运行时常量池，也是方法区的一部分，虚拟机加载Class后把常量池中的数据放入运行时常量池 。
JDK1.6之前字符串常量池位于方法区之中 。JDK1.7字符串常量池已经被挪到堆之中 。可通过参数-XX:PermSize和-XX:MaxPermSize设置
常量池 （Constant Pool）：常量池数据编译期被确定，是Class文件中的一部分。存储了类、方法、接口等中的常量，当然也包括字符串常量 。字符串池/字符串常量池 （String Pool/String Constant Pool）：是常量池中的一部分，存储编译期类中产生的字符串类型数据。运行时常量池 （Runtime Constant Pool）：方法区的一部分，所有线程共享。虚拟机加载Class后把常量池中的数据放入到运行时常量池 。常量池：可以理解为Class文件之中的资源仓库，它是Class文件结构中与其他项目资源关联最多的数据类型。
常量池中主要存放两大类常量：字面量（Literal）和符号引用（Symbolic Reference）。 字面量：文本字符串、声明为final的常量值等。 符号引用：类和接口的完全限定名（Fully Qualified Name）、字段的名称和描述符（Descriptor）、方法的名称和描述符。
可通过-XX:MaxDirectMemorySize指定，如果不指定，则默认与Java堆的最大值（-Xmx指定）一样 。
直接内存（Direct Memory）并不是虚拟机运行时数据区的一部分，也不是Java虚拟机规范中定义的内存区域，但是这部分内存也被频繁地使用，而且也可能导致OutOfMemoryError异常出现 。
java堆（Java Heap）
Java堆是被所有线程共享 ,是Java虚拟机所管理的内存中最大的一块 Java堆在虚拟机启动时创建Java堆唯一的目的是存放对象实例，几乎所有的对象实例和数组都在这里 Java堆为了便于更好的回收和分配内存，可以细分为：新生代和老年代；再细致一点的有Eden空间、From Survivor空间、To Survivor区
新生代 ：包括Eden区、From Survivor区、To Survivor区，系统默认大小Eden:Survivor=8:1。老年代 ：在年轻代中经历了N次垃圾回收后仍然存活的对象，就会被放到年老代中。因此，可以认为年老代中存放的都是一些生命周期较长的对象。
java虚拟机栈(stack)
Java虚拟机栈是线程私有的，它的生命周期与线程相同 。每一个方法被调用直至执行完成的过程，就对应着一个栈帧在虚拟机栈中从入栈到出栈的过程。 虚拟机栈是执行Java方法的内存模型(也就是字节码)服务：每个方法在执行的同时都会创建一个栈帧，用于存储 局部变量表 、操作数栈 、动态链接 、方法出口 等信息
方法区（Method Area）
线程共享内存区域） ，用于储存已被虚拟机加载的类信息、常量、静态变量，即编译器编译后的代码 ，方法区也称持久代（Permanent Generation） 。方法区主要存放java类定义信息，与垃圾回收关系不大，方法区可以选择不实现垃圾回收,但不是没有垃圾回收。 方法区域的内存回收目标主要是针对常量池的回收和对类型的卸载。 运行时常量池，也是方法区的一部分，虚拟机加载Class后把常量池中的数据放入运行时常量池 。
CAS（compare and swap）的缩写，中文翻译成比较并交换 。利用CPU的CAS指令，同时借助JNI来完成Java的非阻塞算法,实现原子操作。其它原子操作都是利用类似的特性完成的 。CAS是项乐观锁技术 ，当多个线程尝试使用CAS同时更新同一个变量时，只有其中一个线程能更新变量的值，而其它线程都失败，失败的线程并不会被挂起，而是被告知这次竞争中失败，并可以再次尝试。
CAS有3个操作数，内存值V，旧的预期值A，要修改的新值B。当且仅当预期值A和内存值V相同时，将内存值V修改为B，否则什么都不做。
确保对内存的读-改-写操作都是原子操作执行
CAS虽然很高效的解决原子操作，但是CAS仍然存在三大问题。ABA问题，循环时间长开销大和只能保证一个共享变量的原子操作
使用CAS在线程冲突严重时，会大幅降低程序性能；CAS只适合于线程冲突较少的情况使用 。
synchronized在jdk1.6之后，已经改进优化。synchronized的底层实现主要依靠Lock-Free的队列，基本思路是自旋后阻塞，竞争切换后继续竞争锁，稍微牺牲了公平性，但获得了高吞吐量。在线程冲突较少的情况下，可以获得和CAS类似的性能；而线程冲突严重的情况下，性能远高于CAS 。
参考https://blog.52itstyle.com/archives/948/
Java在JDK1.5之前都是靠synchronized关键字保证同步的，这种通过使用一致的锁定协议来协调对共享状态的访问，可以确保无论哪个线程持有共享变量的锁，都采用独占的方式来访问这些变量。独占锁其实就是一种悲观锁，所以可以说synchronized是悲观锁。
乐观锁（ Optimistic Locking）其实是一种思想。相对悲观锁而言，乐观锁假设认为数据一般情况下不会造成冲突，所以在数据进行提交更新的时候，才会正式对数据的冲突与否进行检测，如果发现冲突了，则让返回用户错误的信息，让用户决定如何去做。
AbstractQueuedSynchronizer简称AQS，是一个用于构建锁和同步容器的框架 。事实上concurrent包内许多类都是基于AQS构建，例如ReentrantLock ，Semaphore，CountDownLatch，ReentrantReadWriteLock，FutureTask 等。AQS解决了在实现同步容器时设计的大量细节问题。AQS使用一个FIFO的队列表示排队等待锁的线程，队列头节点称作“哨兵节点”或者“哑节点”，它不与任何线程关联。其他的节点与等待线程关联，每个节点维护一个等待状态waitStatus。
参考https://blog.52itstyle.com/archives/948/
A线程写volatile变量，随后B线程读这个volatile变量。 A线程写volatile变量，随后B线程用CAS更新这个volatile变量。 A线程用CAS更新一个volatile变量，随后B线程用CAS更新这个volatile变量。 A线程用CAS更新一个volatile变量，随后B线程读这个volatile变量。
Java的CAS会使用现代处理器上提供的高效机器级别原子指令，这些原子指令以原子方式对内存执行读-改-写操作，这是在多处理器中实现同步的关键（从本质上来说，能够支持原子性读-改-写指令的计算机器，是顺序计算图灵机的异步等价机器，因此任何现代的多处理器都会去支持某种能对内存执行原子性读-改-写操作的原子指令）。同时，volatile变量的读/写和CAS可以实现线程之间的通信。把这些特性整合在一起，就形成了整个concurrent包得以实现的基石。如果我们仔细分析concurrent包的源代码实现，会发现一个通用化的实现模式：
state是独占的，还是共享的； state被获取后，其他线程需要等待； state被释放后，唤醒等待线程； 线程等不及时，如何退出等待。
至于线程是否可以获得state，如何释放state，就不是AQS关心的了，要由子类具体实现。AQS中还有一个表示状态的字段state，例如ReentrantLocky用它表示线程重入锁的次数，Semaphore用它表示剩余的许可数量，FutureTask用它表示任务的状态。对state变量值的更新都采用CAS操作保证更新操作的原子性 。https://www.cnblogs.com/maypattis/p/6403682.html
原子操作是指一个不受其他操作影响的操作任务单元。原子操作是在多线程环境下避免数据不一致必须的手段。
Executor框架同java.util.concurrent.Executor 接口在Java 5中被引入。newCachedThreadPool 创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。newFixedThreadPool 创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。newScheduledThreadPool 创建一个定长线程池，支持定时及周期性任务执行。newSingleThreadExecutor 创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。
JDK7提供了7个阻塞队列。（也属于并发容器）
ArrayBlockingQueue ：一个由数组结构组成的有界阻塞队列。 LinkedBlockingQueue ：一个由链表结构组成的有界阻塞队列。 PriorityBlockingQueue ：一个支持优先级排序的无界阻塞队列。 DelayQueue：一个使用优先级队列实现的无界阻塞队列。 SynchronousQueue：一个不存储元素的阻塞队列。 LinkedTransferQueue：一个由链表结构组成的无界阻塞队列。 LinkedBlockingDeque：一个由链表结构组成的双向阻塞队列。
插入 方法：队列满时，队列会阻塞插入元素的线程，直到队列不满。移除 方法：队列空时，获取元素的线程会等待队列变为非空。
方法\处理方式
抛出异常
返回特殊值
一直阻塞
超时退出
插入方法
add(e)
offer(e)
put(e)
offer(e,time,unit)
移除方法
remove()
poll()
take()
poll(time,unit)
检查方法
element()
peek()
不可用
不可用
JDK 7 提供了7个阻塞队列，如下ArrayBlockingQueue 数组结构组成的有界阻塞队列。LinkedBlockingQueue 一个由链表结构组成的有界阻塞队列PriorityBlockingQueue 支持优先级的无界阻塞队列DelayQueue 支持延时获取元素的无界阻塞队列，即可以指定多久才能从队列中获取当前元素SynchronousQueue 不存储元素的阻塞队列，每一个put必须等待一个take操作，否则不能继续添加元素。并且他支持公平访问队列。LinkedTransferQueue 由链表结构组成的无界阻塞TransferQueue队列。相对于其他阻塞队列，多了tryTransfer和transfer方法transfer方法 tryTransfer方法 LinkedBlockingDeque 链表结构的双向阻塞队列，优势在于多线程入队时，减少一半的竞争。
通知模式实现：所谓通知模式，就是当生产者往满的队列里添加元素时会阻塞住生产者，当消费者消费了一个队列中的元素后，会通知生产者当前队列可用。
为什么BlockingQueue适合解决生产者消费者问题 BlockingQueue是一种数据结构，支持一个线程往里存资源，另一个线程从里取资源。这正是解决生产者消费者问题所需要的，那么让我们开始解决该问题吧。 生产者
import java.util.concurrent.BlockingQueue;
/ 描述:生产者 @author yanpenglei @create 2018-03-14 15:52
protected BlockingQueue queue;
Producer(BlockingQueue theQueue) {
public void run() {
Object getResource () {< br /> try {< br /> Thread . sleep ( 100 );< br /> } catch ( InterruptedException ex ) {< br /> System . out . println ( "生产者 读 中断" );< br /> }< br /> return new Object ();< br /> }< br />}< br />**消费者**< br />以下代码用于消费者线程< br /> package io . ymq . example . thread ; import java.util.concurrent.BlockingQueue;
/ 描述: 消费者 @author yanpenglei @create 2018-03-14 15:54 queue;
Consumer(BlockingQueue theQueue) {
public void run() {
void take(Object obj) {测试该解决方案是否运行正常
/ 描述: 测试 @author yanpenglei @create 2018-03-14 15:58
public static void main(String[] args) throws InterruptedException {
int numProducers = 4 ;< br /> int numConsumers = 3 ; BlockingQueue < Object > myQueue = new LinkedBlockingQueue < Object >( 5 ); for ( int i = 0 ; i < numProducers ; i ++) {< br /> new Thread ( new Producer ( myQueue )). start ();< br /> } for ( int i = 0 ; i < numConsumers ; i ++) {< br /> new Thread ( new Consumer ( myQueue )). start ();< br /> } Thread . sleep ( 1000 ); System . exit ( 0 );< br /> }< br />}< br />**运行结果**< br />生产者资源队列大小= 1 < br />生产者资源队列大小= 1 < br />消费者 资源 队列大小 1 < br />生产者资源队列大小= 1 < br />消费者 资源 队列大小 1 < br />消费者 资源 队列大小 1 < br />生产者资源队列大小= 1 < br />生产者资源队列大小= 3 < br />消费对象 java . lang . Object@1e1aa52b < br />生产者资源队列大小= 2 < br />生产者资源队列大小= 5 < br />消费对象 java . lang . Object@6e740a76 < br />消费对象 java . lang . Object@697853f6 ……
消费对象 java.lang.Object@41a10cbc从输出结果中,我们可以发现队列大小永远不会超过5，消费者线程消费了生产者生产的资源 。
Callable 和 Future 是比较有趣的一对组合。当我们需要获取线程的执行结果时，就需要用到它们。Callable用于产生结果，Future用于获取结果 。Callable接口使用泛型去定义它的返回类型 。Executors类提供了一些有用的方法去在线程池中执行Callable内的任务。由于Callable任务是并行的，必须等待它返回的结果。java.util.concurrent.Future对象解决了这个问题。在线程池提交Callable任务后返回了一个Future对象 ，使用它可以知道Callable任务的状态和得到Callable返回的执行结果。Future提供了get()方法，等待Callable结束并获取它的执行结果。代码示例 Callable 是一个接口，它只包含一个call()方法。Callable是一个返回结果并且可能抛出异常的任务 。为了便于理解，我们可以将Callable比作一个Runnable接口，而Callable的call()方法则类似于Runnable的run()方法 。
public static void main(String[] args) throws InterruptedException, ExecutionException {
System . out . println ( "start main thread " ); ExecutorService exec = Executors . newFixedThreadPool ( 2 ); //新建一个Callable 任务，并将其提交到一个ExecutorService. 将返回一个描述任务情况的Future.<br /> Callable<String> call = new Callable<String>() { @Override < br /> public String call () throws Exception {< br /> System . out . println ( "start new thread " );< br /> Thread . sleep ( 5000 );< br /> System . out . println ( "end new thread " );< br /> return "我是返回的内容" ;< br /> }< br /> }; Future < String > task = exec . submit ( call );< br /> Thread . sleep ( 1000 );< br /> String retn = task . get ();< br /> //关闭线程池<br /> exec.shutdown();<br /> System.out.println(retn + "--end main thread");<br /> }<br />}<br />控制台打印<br />start main thread <br />start new thread<br />end new thread<br />我是返回的内容--end main thread
FutureTask可用于异步获取执行结果或取消执行任务的场景。通过传入Runnable或者Callable的任务给FutureTask，直接调用其run方法或者放入线程池执行，之后可以在外部通过FutureTask的get方法异步获取执行结果，因此，FutureTask非常适合用于耗时的计算，主线程可以在完成自己的任务后，再去获取结果。另外，FutureTask还可以确保即使调用了多次run方法，它都只会执行一次Runnable或者Callable任务，或者通过cancel取消FutureTask的执行等。
FutureTask执行多任务计算的使用场景
public class FutureTaskForMultiCompute {
public static void main(String[] args) {
FutureTaskForMultiCompute inst = new FutureTaskForMultiCompute ();< br /> // 创建任务集合<br /> List<FutureTask<Integer>> taskList = new ArrayList<FutureTask<Integer>>();<br /> // 创建线程池<br /> ExecutorService exec = Executors.newFixedThreadPool(5);<br /> for (int i = 0; i < 10; i++) {<br /> // 传入Callable对象创建FutureTask对象<br /> FutureTask<Integer> ft = new FutureTask<Integer>(inst.new ComputeTask(i, "" + i));<br /> taskList.add(ft);<br /> // 提交给线程池执行任务，也可以通过exec.invokeAll(taskList)一次性提交所有任务;<br /> exec.submit(ft);<br /> } System . out . println ( "所有计算任务提交完毕, 主线程接着干其他事情！" ); // 开始统计各计算线程计算结果<br /> Integer totalResult = 0;<br /> for (FutureTask<Integer> ft : taskList) {<br /> try {<br /> //FutureTask的get方法会自动阻塞,直到获取计算结果为止<br /> totalResult = totalResult + ft.get();<br /> } catch (InterruptedException e) {<br /> e.printStackTrace();<br /> } catch (ExecutionException e) {<br /> e.printStackTrace();<br /> }<br /> } // 关闭线程池<br /> exec.shutdown();<br /> System.out.println("多任务计算后的总结果是:" + totalResult); }
private class ComputeTask implements Callable {
private Integer result = 0 ;< br /> private String taskName = "" ; public ComputeTask ( Integer iniResult , String taskName ) {< br /> result = iniResult ;< br /> this . taskName = taskName ;< br /> System . out . println ( "生成子线程计算任务: " + taskName );< br /> } public String getTaskName () {< br /> return this . taskName ;< br /> } @Override < br /> public Integer call () throws Exception {< br /> // TODO Auto-generated method stub for ( int i = 0 ; i < 100 ; i ++) {< br /> result = + i ;< br /> }< br /> // 休眠5秒钟，观察主线程行为，预期的结果是主线程会继续执行，到要取得FutureTask的结果是等待直至完成。<br /> Thread.sleep(5000);<br /> System.out.println("子线程计算任务: " + taskName + " 执行完成!");<br /> return result;<br /> }<br /> }<br />}<br />生成子线程计算任务: 0<br />生成子线程计算任务: 1<br />生成子线程计算任务: 2<br />生成子线程计算任务: 3<br />生成子线程计算任务: 4<br />生成子线程计算任务: 5<br />生成子线程计算任务: 6<br />生成子线程计算任务: 7<br />生成子线程计算任务: 8<br />生成子线程计算任务: 9<br />所有计算任务提交完毕, 主线程接着干其他事情！<br />子线程计算任务: 0 执行完成!<br />子线程计算任务: 2 执行完成!<br />子线程计算任务: 3 执行完成!<br />子线程计算任务: 4 执行完成!<br />子线程计算任务: 1 执行完成!<br />子线程计算任务: 8 执行完成!<br />子线程计算任务: 7 执行完成!<br />子线程计算任务: 6 执行完成!<br />子线程计算任务: 9 执行完成!<br />子线程计算任务: 5 执行完成!<br />多任务计算后的总结果是:990
FutureTask在高并发环境下确保任务只执行一次 connectionPool = new HashMap();
public Connection getConnection(String key) {
//创建Connection > connectionPool = new ConcurrentHashMap>();
public Connection getConnection(String key) throws Exception { connectionTask = connectionPool.get(key); callable = new Callable() { newTask = new FutureTask(callable);
//创建Connection 经过这样的改造，可以避免由于并发带来的多次创建连接及锁的出现。
主要代表有Vector和Hashtable，以及Collections.synchronizedXxx等。
主要代表有ConcurrentHashMap、CopyOnWriteArrayList、ConcurrentSkipListMap、ConcurrentSkipListSet。JDK 7 ConcurrentHashMap JDK 8 ConcurrentHashMap
主要代表有LinkedBlockingQueue、ArrayBlockingQueue、PriorityBlockingQueue(Comparable,Comparator)、SynchronousQueue。
主要代表有ArrayDeque和LinkedBlockingDeque。
如果不需要阻塞队列，优先选择ConcurrentLinkedQueue；
什么是多线程？ 多线程的好处：
使用多线程可以把程序中占据时间长的任务放到后台去处理，如图片、视屏的下载 发挥多核处理器的优势，并发执行让系统运行的更快、更流畅，用户体验更好
多线程的缺点：
大量的线程降低代码的可读性； 更多的线程需要更多的内存空间 当多个线程对同一个资源出现争夺时候要注意线程安全的问题。
上下文切换过程中，CPU会停止处理当前运行的程序，并保存当前程序运行的具体位置以便之后继续运行 CPU通过时间片分配算法来循环执行任务，当前任务执行一个时间片后会切换到下一个任务。但是，在切换前会保存上一个任务的状态，以便下次切换回这个任务时，可以再次加载这个任务的状态
从任务保存到再加载的过程就是一次上下文切换
如何创建ThreadLocal变量 所有的线程都能访问到这个ThreadLocal实例，但是每个线程却只能访问到自己通过调用ThreadLocal的set()方法设置的值。即使是两个不同的线程在同一个ThreadLocal对象上设置了不同的值，他们仍然无法访问到对方的值 。如何访问ThreadLocal变量 为ThreadLocal指定泛型类型 myThreadLocal = new ThreadLocal();ThreadLocal的设计理念与作用 http://blog.csdn.net/u011860731/article/details/48733073http://blog.csdn.net/u011860731/article/details/48733073 )
threadLocal = new InheritableThreadLocal();InheritableThreadLocal允许一个线程以及该线程创建的所有子线程都可以访问它保存的值 。InheritableThreadLocal 原理 Java 多线程：InheritableThreadLocal 实现原理 http://blog.csdn.net/ni357103403/article/details/51970748
减少了创建和销毁线程的次数，每个工作线程都可以被重复利用，可执行多个任务。 可以根据系统的承受能力，调整线程池中工作线线程的数目，防止因为消耗过多的内存，而把服务器累趴下(每个线程需要大约1MB内存，线程开的越多，消耗的内存也就越大，最后死机)。 Java里面线程池的顶级接口是Executor，但是严格意义上讲Executor并不是一个线程池，而只是一个执行线程的工具。真正的线程池接口是ExecutorService。
每次new Thread新建对象性能差。
线程缺乏统一管理，可能无限制新建线程，相互之间竞争，及可能占用过多系统资源导致死机或oom。 缺乏更多功能，如定时执行、定期执行、线程中断。
减少在创建和销毁线程上所花的时间以及系统资源的开销 如不使用线程池，有可能造成系统创建大量线程而导致消耗完系统内存
Java提供的四种线程池的好处在于 ：
重用存在的线程，减少对象创建、销毁的开销，提高性能。 可有效控制最大并发线程数，提高系统资源的使用率，同时避免过多资源竞争，避免堵塞。 提供定时执行、定期执行、单线程、并发数控制等功能。
要配置一个线程池是比较复杂的，尤其是对于线程池的原理不是很清楚的情况下，很有可能配置的线程池不是较优的，因此在Executors类里面提供了一些静态工厂，生成一些常用的线程池。
newCachedThreadPool 创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。newFixedThreadPool 创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。newScheduledThreadPool 创建一个定长线程池，支持定时及周期性任务执行。newSingleThreadExecutor 创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。
使用ThreadPoolExecutor创建线程池 ThreadPoolExecutor的构造函数 workQueue,
corePoolSize 核心线程数大小，当线程数<corePoolSize ，会创建线程执行runnablemaximumPoolSize 最大线程数， 当线程数 >= corePoolSize的时候，会把runnable放入workQueue中keepAliveTime 保持存活时间，当线程数大于corePoolSize的空闲线程能保持的最大时间。unit 时间单位workQueue 保存任务的阻塞队列threadFactory 创建线程的工厂handler 拒绝策略
当线程数小于corePoolSize时，创建线程执行任务。
当线程数大于等于corePoolSize并且workQueue没有满时，放入workQueue中 线程数大于等于corePoolSize并且当workQueue满时，新任务新建线程运行，线程总数要小于maximumPoolSize 当线程总数等于maximumPoolSize并且workQueue满了的时候执行handler的rejectedExecution。也就是拒绝策略。
ThreadPoolExecutor.AbortPolicy() 直接抛出异常RejectedExecutionException
ThreadPoolExecutor.CallerRunsPolicy() 直接调用run方法并且阻塞执行ThreadPoolExecutor.DiscardPolicy() 直接丢弃后来的任务ThreadPoolExecutor.DiscardOldestPolicy() 丢弃在队列中队首的任务
当然可以自己继承 RejectedExecutionHandler 来写拒绝策略.
https://juejin.im/post/59df0c1af265da432f301c8d
阻塞队列 ArrayBlockingQueue 数组结构组成的有界阻塞队列。
CountDownLatch 允许一个或多个线程等待其他线程完成操作。应用场景
public static void main(String[] args) throws InterruptedException {
Thread parser2 = new Thread ( new Runnable () {< br /> @Override < br /> public void run () {< br /> System . out . println ( "parser2 finish" );< br /> }< br /> }); parser1 . start ();< br /> parser2 . start ();< br /> parser1 . join ();< br /> parser2 . join ();< br /> System . out . println ( "all parser finish" );< br />} }
方法isAlive()功能是判断当前线程是否处于活动状态。 活动状态就是线程启动且尚未终止，比如正在运行或准备开始运行。
public class Test {Java并发编程：CountDownLatch、CyclicBarrier和 Semaphore http://www.importnew.com/21889.html
java在编写多线程程序时，为了保证线程安全，需要对数据同步，经常用到两种同步方式就是Synchronized和重入锁ReentrantLock。
可重入锁 。可重入锁是指同一个线程可以多次获取同一把锁。ReentrantLock和synchronized都是可重入锁 。
可中断锁 。可中断锁是指线程尝试获取锁的过程中，是否可以响应中断。synchronized是不可中断锁，而ReentrantLock则提供了中断功能。公平锁与非公平锁 。公平锁是指多个线程同时尝试获取同一把锁时，获取锁的顺序按照线程达到的顺序，而非公平锁则允许线程“插队”。synchronized是非公平锁，而ReentrantLock的默认实现是非公平锁，但是也可以设置为公平锁。CAS操作(CompareAndSwap) 。CAS操作简单的说就是比较并交换。CAS 操作包含三个操作数 —— 内存位置（V）、预期原值（A）和新值(B)。如果内存位置的值与预期原值相匹配，那么处理器会自动将该位置值更新为新值。否则，处理器不做任何操作。无论哪种情况，它都会在 CAS 指令之前返回该位置的值。CAS 有效地说明了“我认为位置 V 应该包含值 A；如果包含该值，则将 B 放到这个位置；否则，不要更改该位置，只告诉我这个位置现在的值即可。”
当线程尝试获取锁的时候，如果获取不到锁会一直阻塞。 如果获取锁的线程进入休眠或者阻塞，除非当前线程异常，否则其他线程尝试获取锁必须一直等待。
**lock ()**, 如果获取了锁立即返回，如果别的线程持有锁，当前线程则一直处于休眠状态，直到获取锁tryLock() , 如果获取了锁立即返回true，如果别的线程正持有锁，立即返回false；tryLock(long timeout,TimeUnit unit)** ，如果获取了锁定立即返回true，如果别的线程正持有锁，会等待参数给定的时间，在等待的过程中，如果获取了锁定，就返回true，如果等待超时，返回false；lockInterruptibly :如果获取了锁定立即返回，如果没有获取锁定，当前线程处于休眠状态，直到或者锁定，或者当前线程被别的线程中断
ReentrantLock 一些特性
等待可中断避免，出现死锁的情况 （如果别的线程正持有锁，会等待参数给定的时间，在等待的过程中，如果获取了锁定，就返回true，如果等待超时，返回false）公平锁与非公平锁 多个线程等待同一个锁时，必须按照申请锁的时间顺序获得锁，Synchronized锁非公平锁，ReentrantLock默认的构造函数是创建的非公平锁，可以通过参数true设为公平锁 ，但公平锁表现的性能不是很好。
公平锁：线程获取锁的顺序和调用lock的顺序一样，FIFO；Java并发包(java.util.concurrent)中大量使用了CAS操作,涉及到并发的地方都调用了sun.misc.Unsafe类方法进行CAS操作 。
简单来说，ReenTrantLock的实现是一种自旋锁，通过循环调用CAS操作来实现加锁 。它的性能比较好也是因为避免了使线程进入内核态的阻塞状态。想尽办法避免线程进入内核的阻塞状态是我们去分析和理解锁设计的关键钥匙。
在Synchronized优化以前，synchronized的性能是比ReenTrantLock差很多的，但是自从Synchronized引入了偏向锁，轻量级锁（自旋锁）后，两者的性能就差不多了，在两种方法都可用的情况下，官方甚至建议使用synchronized，其实synchronized的优化我感觉就借鉴了ReenTrantLock中的CAS技术。都是试图在用户态就把加锁问题解决，避免进入内核态的线程阻塞。synchronized ：ReentrantLock :使用非公平锁是基于性能考虑 ，公平锁为了保证线程规规矩矩地排队，需要增加阻塞和唤醒的时间开销。如果直接插队获取非公平锁，跳过了对队列的处理，速度会更快。ReentrantLock实现原理 https://www.cnblogs.com/maypattis/p/6403682.html 分析ReentrantLock的实现原理 (ReentrantLock和同步工具类的实现基础都是AQS)https://www.jianshu.com/p/fe027772e156
Semaphore就是一个信号量，它的作用是限制某段代码块的并发数 。 Semaphore有一个构造函数，可以传入一个int型整数n，表示某段代码最多只有n个线程可以访问 ， 如果超出了n，那么请等待，等到某个线程执行完毕这段代码块，下一个线程再进入 。由此可以看出如果Semaphore构造函数中传入的int型整数n=1，相当于变成了一个synchronized了。
Semaphore类位于java.util.concurrent包下，它提供了2个构造器：
Semaphore类中比较重要的几个方法，首先是acquire()、release()方法： acquire()用来获取一个许可，若无许可能够获得，则会一直等待，直到获得许可。 release()用来释放许可。注意，在释放许可之前，必须先获获得许可。
Semaphore类中比较重要的几个方法，首先是acquire()、release()方法：
假若一个工厂有5台机器，但是有8个工人，一台机器同时只能被一个工人使用，只有使用完了，其他工人才能继续使用。那么我们就可以通过Semaphore来实现： new Worker(i,semaphore).start();
Lock接口比同步方法和同步块提供了更具扩展性的锁操作。他们允许更灵活的结构，可以具有完全不同的性质，并且可以支持多个相关类的条件对象。
可以使锁更公平 可以使线程在等待锁的时候响应中断 可以让线程尝试获取锁，并在无法获取锁的时候立即返回或者等待一段时间 可以在不同的范围，以不同的顺序获取和释放锁
而给size()方法加了同步之后，意味着线程B调用size()方法只有在线程A调用put方法完毕之后才可以调用，这样就保证了线程安全性
读写锁 ：分为读锁和写锁，多个读锁不互斥，读锁与写锁互斥，这是由jvm自己控制的，你只要上好相应的锁即可 。如果你的代码
什么是线程？ 什么是线程安全和线程不安全？ 什么是自旋锁？ 什么是Java内存模型？ 什么是CAS？ 什么是乐观锁和悲观锁？ 什么是AQS？ 什么是原子操作？在Java Concurrency API中有哪些原子类(atomic classes)？ 什么是Executors框架？ 什么是阻塞队列？如何使用阻塞队列来实现生产者-消费者模型？ 什么是Callable和Future? 什么是FutureTask? 什么是同步容器和并发容器的实现？ 什么是多线程？优缺点？ 什么是多线程的上下文切换？ ThreadLocal的设计理念与作用？ ThreadPool（线程池）用法与优势？ Concurrent包里的其他东西：ArrayBlockingQueue、CountDownLatch等等。 synchronized和ReentrantLock的区别？ Semaphore有什么作用？ Java Concurrency API中的Lock接口(Lock interface)是什么？对比同步它有什么优势？ Hashtable的size()方法中明明只有一条语句”return count”，为什么还要做同步？ ConcurrentHashMap的并发度是什么？ ReentrantReadWriteLock读写锁的使用？ CyclicBarrier和CountDownLatch的用法及区别？ LockSupport工具？ Condition接口及其实现原理？ Fork/Join框架的理解? wait()和sleep()的区别? 线程的五个状态（五种状态，创建、就绪、运行、阻塞和死亡）? start()方法和run()方法的区别？ Runnable接口和Callable接口的区别？ volatile关键字的作用？ Java中如何获取到线程dump文件？ 线程和进程有什么区别？ 线程实现的方式有几种（四种）？ 高并发、任务执行时间短的业务怎样使用线程池？并发不高、任务执行时间长的业务怎样使用线程池？并发高、业务执行时间长的业务怎样使用线程池？ 如果你提交任务时，线程池队列已满，这时会发生什么？ 锁的等级：方法锁、对象锁、类锁? 如果同步块内的线程抛出异常会发生什么？ 并发编程（concurrency）并行编程（parallellism）有什么区别？ 如何保证多线程下 i++ 结果正确？ 一个线程如果出现了运行时异常会怎么样? 如何在两个线程之间共享数据? 生产者消费者模型的作用是什么? 怎么唤醒一个阻塞的线程? Java中用到的线程调度算法是什么 单例模式的线程安全性? 线程类的构造方法、静态块是被哪个线程调用的? 同步方法和同步块，哪个是更好的选择? 如何检测死锁？怎么预防死锁？
通俗的说：加锁的就是是线程安全的，不加锁的就是是线程不安全的
线程安全: 就是多线程访问时，采用了加锁机制，当一个线程访问该类的某个数据时，进行保护，其他线程不能进行访问，直到该线程读取完，其他线程才可使用。不会出现数据不一致或者数据污染 。集合类分成两组，线程安全和非线程安全的 。线程不安全：就是不提供数据访问保护，有可能出现多个线程先后更改数据造成所得到的数据是脏数据 自旋锁是SMP架构中的一种low-level的同步机制 。自选锁需要注意 ：
由于自旋时不释放CPU，因而持有自旋锁的线程应该尽快释放自旋锁，否则等待该自旋锁的线程会一直在那里自旋，这就会浪费CPU时间。 持有自旋锁的线程在sleep之前应该释放自旋锁以便其它线程可以获得自旋锁 。
参考https://segmentfault.com/q/1010000000530936
MonitorObject myMonitorObject = new MonitorObject();
public void doWait(){
public void doNotify(){
Java内存模型描述了在多线程代码中哪些行为是合法的，以及线程如何通过内存进行交互。它描述了“程序中的变量“ 和 ”从内存或者寄存器获取或存储它们的底层细节”之间的关系。Java内存模型通过使用各种各样的硬件和编译器的优化来正确实现以上事情 。Java包含了几个语言级别的关键字，包括：volatile, final以及synchronized，目的是为了帮助程序员向编译器描述一个程序的并发需求。Java内存模型定义了volatile和synchronized的行为，更重要的是保证了同步的java程序在所有的处理器架构下面都能正确的运行。
public void reader() {
JVM内存结构主要有三大块：堆内存、方法区和栈 。Eden空间、From Survivor空间、To Survivor空间 ,默认情况下年轻代按照8:1:1的比例来分配；方法区存储类信息、常量、静态变量等数据，是线程共享的区域 ，为与Java堆区分，方法区还有一个别名Non-Heap(非堆)；栈又分为java虚拟机栈和本地方法栈主要用于方法的执行。JAVA的JVM的内存可分为3个区：堆(heap)、栈(stack)和方法区(method)
可通过参数 -Xms 和-Xmx设置
Java堆是被所有线程共享,是Java虚拟机所管理的内存中最大的一块 Java堆在虚拟机启动时创建 。Java堆唯一的目的是存放对象实例，几乎所有的对象实例和数组都在这里 。Java堆为了便于更好的回收和分配内存，可以细分为：新生代和老年代 ；再细致一点的有Eden空间、From Survivor空间、To Survivor区 。
新生代 ：包括Eden区、From Survivor区、To Survivor区，系统默认大小Eden:Survivor=8:1。老年代 ：在年轻代中经历了N次垃圾回收后仍然存活的对象，就会被放到年老代中。因此，可以认为年老代中存放的都是一些生命周期较长的对象。
Survivor空间等Java堆可以处在物理上不连续的内存空间中，只要逻辑上是连续的即可（就像我们的磁盘空间一样。在实现时，既可以实现成固定大小的，也可以是可扩展的）。
据Java虚拟机规范的规定，当方法区无法满足内存分配需求时，将抛出OutOfMemoryError异常 。
可通过参数 栈帧是方法运行期的基础数据结构栈容量可由-Xss设置 Java虚拟机栈是线程私有的，它的生命周期与线程相同 。
每一个方法被调用直至执行完成的过程，就对应着一个栈帧在虚拟机栈中从入栈到出栈的过程。 虚拟机栈是执行Java方法的内存模型(也就是字节码)服务：每个方法在执行的同时都会创建一个栈帧 ，用于存储 局部变量表 、操作数栈 、动态链接 、方法出口 等信息。
局部变量表 ：32位变量槽，存放了编译期可知的各种基本数据类型、对象引用、returnAddress类型 。操作数栈 ：基于栈的执行引擎，虚拟机把操作数栈作为它的工作区，大多数指令都要从这里弹出数据、执行运算，然后把结果压回操作数栈。动态连接 ：每个栈帧都包含一个指向运行时常量池（方法区的一部分）中该栈帧所属方法的引用 。持有这个引用是为了支持方法调用过程中的动态连接。Class文件的常量池中有大量的符号引用，字节码中的方法调用指令就以常量池中指向方法的符号引用为参数。这些符号引用一部分会在类加载阶段或第一次使用的时候转化为直接引用，这种转化称为静态解析。另一部分将在每一次的运行期间转化为直接应用，这部分称为动态连接方法出口 ：返回方法被调用的位置，恢复上层方法的局部变量和操作数栈，如果无返回值，则把它压入调用者的操作数栈。
局部变量表所需的内存空间在编译期间完成分配 ，当进入一个方法时，这个方法需要在帧中分配多大的局部变量空间是完全确定的。在方法运行期间不会改变局部变量表的大小。主要存放了编译期可知的各种基本数据类型、对象引用 （reference类型）、returnAddress类型）。
undefinedjava虚拟机栈,规定了两种异常状况：
如果线程请求的深度大于虚拟机所允许的深度，将抛出StackOverflowError异常 。如果虚拟机栈动态扩展，而扩展时无法申请到足够的内存，就会抛出OutOfMemoryError异常 。
可通过参数 栈容量可由-Xss设置
虚拟机栈为虚拟机执行Java方法（也就是字节码）服务。
本地方法栈则是为虚拟机使用到的Native方法服务。有的虚拟机（譬如Sun HotSpot虚拟机）直接就把本地方法栈和虚拟机栈合二为一
可通过参数-XX:MaxPermSize设置
线程共享内存区域，用于储存已被虚拟机加载的类信息、常量、静态变量，即编译器编译后的代码，方法区也称持久代（Permanent Generation） 。
虽然Java虚拟机规范把方法区描述为堆的一个逻辑部分，但是它却有一个别名叫做Non-Heap（非堆） ，目的应该是与Java堆区分开来。 如何实现方法区，属于虚拟机的实现细节，不受虚拟机规范约束。 方法区主要存放java类定义信息，与垃圾回收关系不大，方法区可以选择不实现垃圾回收,但不是没有垃圾回收。 方法区域的内存回收目标主要是针对常量池的回收和对类型的卸载 。运行时常量池，也是方法区的一部分，虚拟机加载Class后把常量池中的数据放入运行时常量池 。
JDK1.6之前字符串常量池位于方法区之中 。JDK1.7字符串常量池已经被挪到堆之中 。可通过参数-XX:PermSize和-XX:MaxPermSize设置
常量池 （Constant Pool）：常量池数据编译期被确定，是Class文件中的一部分。存储了类、方法、接口等中的常量，当然也包括字符串常量 。字符串池/字符串常量池 （String Pool/String Constant Pool）：是常量池中的一部分，存储编译期类中产生的字符串类型数据。运行时常量池 （Runtime Constant Pool）：方法区的一部分，所有线程共享。虚拟机加载Class后把常量池中的数据放入到运行时常量池 。常量池：可以理解为Class文件之中的资源仓库，它是Class文件结构中与其他项目资源关联最多的数据类型。
常量池中主要存放两大类常量：字面量（Literal）和符号引用（Symbolic Reference）。 字面量：文本字符串、声明为final的常量值等。 符号引用：类和接口的完全限定名（Fully Qualified Name）、字段的名称和描述符（Descriptor）、方法的名称和描述符。
可通过-XX:MaxDirectMemorySize指定，如果不指定，则默认与Java堆的最大值（-Xmx指定）一样 。
直接内存（Direct Memory）并不是虚拟机运行时数据区的一部分，也不是Java虚拟机规范中定义的内存区域，但是这部分内存也被频繁地使用，而且也可能导致OutOfMemoryError异常出现 。
java堆（Java Heap）
Java堆是被所有线程共享 ,是Java虚拟机所管理的内存中最大的一块 Java堆在虚拟机启动时创建Java堆唯一的目的是存放对象实例，几乎所有的对象实例和数组都在这里 Java堆为了便于更好的回收和分配内存，可以细分为：新生代和老年代；再细致一点的有Eden空间、From Survivor空间、To Survivor区
新生代 ：包括Eden区、From Survivor区、To Survivor区，系统默认大小Eden:Survivor=8:1。老年代 ：在年轻代中经历了N次垃圾回收后仍然存活的对象，就会被放到年老代中。因此，可以认为年老代中存放的都是一些生命周期较长的对象。
java虚拟机栈(stack)
Java虚拟机栈是线程私有的，它的生命周期与线程相同 。每一个方法被调用直至执行完成的过程，就对应着一个栈帧在虚拟机栈中从入栈到出栈的过程。 虚拟机栈是执行Java方法的内存模型(也就是字节码)服务：每个方法在执行的同时都会创建一个栈帧，用于存储 局部变量表 、操作数栈 、动态链接 、方法出口 等信息
方法区（Method Area）
线程共享内存区域） ，用于储存已被虚拟机加载的类信息、常量、静态变量，即编译器编译后的代码 ，方法区也称持久代（Permanent Generation） 。方法区主要存放java类定义信息，与垃圾回收关系不大，方法区可以选择不实现垃圾回收,但不是没有垃圾回收。 方法区域的内存回收目标主要是针对常量池的回收和对类型的卸载。 运行时常量池，也是方法区的一部分，虚拟机加载Class后把常量池中的数据放入运行时常量池 。
CAS（compare and swap）的缩写，中文翻译成比较并交换 。利用CPU的CAS指令，同时借助JNI来完成Java的非阻塞算法,实现原子操作。其它原子操作都是利用类似的特性完成的 。CAS是项乐观锁技术 ，当多个线程尝试使用CAS同时更新同一个变量时，只有其中一个线程能更新变量的值，而其它线程都失败，失败的线程并不会被挂起，而是被告知这次竞争中失败，并可以再次尝试。
CAS有3个操作数，内存值V，旧的预期值A，要修改的新值B。当且仅当预期值A和内存值V相同时，将内存值V修改为B，否则什么都不做。
确保对内存的读-改-写操作都是原子操作执行
CAS虽然很高效的解决原子操作，但是CAS仍然存在三大问题。ABA问题，循环时间长开销大和只能保证一个共享变量的原子操作
使用CAS在线程冲突严重时，会大幅降低程序性能；CAS只适合于线程冲突较少的情况使用 。
synchronized在jdk1.6之后，已经改进优化。synchronized的底层实现主要依靠Lock-Free的队列，基本思路是自旋后阻塞，竞争切换后继续竞争锁，稍微牺牲了公平性，但获得了高吞吐量。在线程冲突较少的情况下，可以获得和CAS类似的性能；而线程冲突严重的情况下，性能远高于CAS 。
参考https://blog.52itstyle.com/archives/948/
Java在JDK1.5之前都是靠synchronized关键字保证同步的，这种通过使用一致的锁定协议来协调对共享状态的访问，可以确保无论哪个线程持有共享变量的锁，都采用独占的方式来访问这些变量。独占锁其实就是一种悲观锁，所以可以说synchronized是悲观锁。
乐观锁（ Optimistic Locking）其实是一种思想。相对悲观锁而言，乐观锁假设认为数据一般情况下不会造成冲突，所以在数据进行提交更新的时候，才会正式对数据的冲突与否进行检测，如果发现冲突了，则让返回用户错误的信息，让用户决定如何去做。
AbstractQueuedSynchronizer简称AQS，是一个用于构建锁和同步容器的框架 。事实上concurrent包内许多类都是基于AQS构建，例如ReentrantLock ，Semaphore，CountDownLatch，ReentrantReadWriteLock，FutureTask 等。AQS解决了在实现同步容器时设计的大量细节问题。AQS使用一个FIFO的队列表示排队等待锁的线程，队列头节点称作“哨兵节点”或者“哑节点”，它不与任何线程关联。其他的节点与等待线程关联，每个节点维护一个等待状态waitStatus。
参考https://blog.52itstyle.com/archives/948/
A线程写volatile变量，随后B线程读这个volatile变量。 A线程写volatile变量，随后B线程用CAS更新这个volatile变量。 A线程用CAS更新一个volatile变量，随后B线程用CAS更新这个volatile变量。 A线程用CAS更新一个volatile变量，随后B线程读这个volatile变量。
Java的CAS会使用现代处理器上提供的高效机器级别原子指令，这些原子指令以原子方式对内存执行读-改-写操作，这是在多处理器中实现同步的关键（从本质上来说，能够支持原子性读-改-写指令的计算机器，是顺序计算图灵机的异步等价机器，因此任何现代的多处理器都会去支持某种能对内存执行原子性读-改-写操作的原子指令）。同时，volatile变量的读/写和CAS可以实现线程之间的通信。把这些特性整合在一起，就形成了整个concurrent包得以实现的基石。如果我们仔细分析concurrent包的源代码实现，会发现一个通用化的实现模式：
state是独占的，还是共享的； state被获取后，其他线程需要等待； state被释放后，唤醒等待线程； 线程等不及时，如何退出等待。
至于线程是否可以获得state，如何释放state，就不是AQS关心的了，要由子类具体实现。AQS中还有一个表示状态的字段state，例如ReentrantLocky用它表示线程重入锁的次数，Semaphore用它表示剩余的许可数量，FutureTask用它表示任务的状态。对state变量值的更新都采用CAS操作保证更新操作的原子性 。https://www.cnblogs.com/maypattis/p/6403682.html
原子操作是指一个不受其他操作影响的操作任务单元。原子操作是在多线程环境下避免数据不一致必须的手段。
Executor框架同java.util.concurrent.Executor 接口在Java 5中被引入。newCachedThreadPool 创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。newFixedThreadPool 创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。newScheduledThreadPool 创建一个定长线程池，支持定时及周期性任务执行。newSingleThreadExecutor 创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。
JDK7提供了7个阻塞队列。（也属于并发容器）
ArrayBlockingQueue ：一个由数组结构组成的有界阻塞队列。 LinkedBlockingQueue ：一个由链表结构组成的有界阻塞队列。 PriorityBlockingQueue ：一个支持优先级排序的无界阻塞队列。 DelayQueue：一个使用优先级队列实现的无界阻塞队列。 SynchronousQueue：一个不存储元素的阻塞队列。 LinkedTransferQueue：一个由链表结构组成的无界阻塞队列。 LinkedBlockingDeque：一个由链表结构组成的双向阻塞队列。
插入 方法：队列满时，队列会阻塞插入元素的线程，直到队列不满。移除 方法：队列空时，获取元素的线程会等待队列变为非空。
方法\处理方式
抛出异常
返回特殊值
一直阻塞
超时退出
插入方法
add(e)
offer(e)
put(e)
offer(e,time,unit)
移除方法
remove()
poll()
take()
poll(time,unit)
检查方法
element()
peek()
不可用
不可用
JDK 7 提供了7个阻塞队列，如下ArrayBlockingQueue 数组结构组成的有界阻塞队列。LinkedBlockingQueue 一个由链表结构组成的有界阻塞队列PriorityBlockingQueue 支持优先级的无界阻塞队列DelayQueue 支持延时获取元素的无界阻塞队列，即可以指定多久才能从队列中获取当前元素SynchronousQueue 不存储元素的阻塞队列，每一个put必须等待一个take操作，否则不能继续添加元素。并且他支持公平访问队列。LinkedTransferQueue 由链表结构组成的无界阻塞TransferQueue队列。相对于其他阻塞队列，多了tryTransfer和transfer方法transfer方法 tryTransfer方法 LinkedBlockingDeque 链表结构的双向阻塞队列，优势在于多线程入队时，减少一半的竞争。
通知模式实现：所谓通知模式，就是当生产者往满的队列里添加元素时会阻塞住生产者，当消费者消费了一个队列中的元素后，会通知生产者当前队列可用。
为什么BlockingQueue适合解决生产者消费者问题 BlockingQueue是一种数据结构，支持一个线程往里存资源，另一个线程从里取资源。这正是解决生产者消费者问题所需要的，那么让我们开始解决该问题吧。 生产者
import java.util.concurrent.BlockingQueue;
/ 描述:生产者 @author yanpenglei @create 2018-03-14 15:52
protected BlockingQueue queue;
Producer(BlockingQueue theQueue) {
public void run() {
Object getResource () {< br /> try {< br /> Thread . sleep ( 100 );< br /> } catch ( InterruptedException ex ) {< br /> System . out . println ( "生产者 读 中断" );< br /> }< br /> return new Object ();< br /> }< br />}< br />**消费者**< br />以下代码用于消费者线程< br /> package io . ymq . example . thread ; import java.util.concurrent.BlockingQueue;
/ 描述: 消费者 @author yanpenglei @create 2018-03-14 15:54 queue;
Consumer(BlockingQueue theQueue) {
public void run() {
void take(Object obj) {测试该解决方案是否运行正常
/ 描述: 测试 @author yanpenglei @create 2018-03-14 15:58
public static void main(String[] args) throws InterruptedException {
int numProducers = 4 ;< br /> int numConsumers = 3 ; BlockingQueue < Object > myQueue = new LinkedBlockingQueue < Object >( 5 ); for ( int i = 0 ; i < numProducers ; i ++) {< br /> new Thread ( new Producer ( myQueue )). start ();< br /> } for ( int i = 0 ; i < numConsumers ; i ++) {< br /> new Thread ( new Consumer ( myQueue )). start ();< br /> } Thread . sleep ( 1000 ); System . exit ( 0 );< br /> }< br />}< br />**运行结果**< br />生产者资源队列大小= 1 < br />生产者资源队列大小= 1 < br />消费者 资源 队列大小 1 < br />生产者资源队列大小= 1 < br />消费者 资源 队列大小 1 < br />消费者 资源 队列大小 1 < br />生产者资源队列大小= 1 < br />生产者资源队列大小= 3 < br />消费对象 java . lang . Object@1e1aa52b < br />生产者资源队列大小= 2 < br />生产者资源队列大小= 5 < br />消费对象 java . lang . Object@6e740a76 < br />消费对象 java . lang . Object@697853f6 ……
消费对象 java.lang.Object@41a10cbc从输出结果中,我们可以发现队列大小永远不会超过5，消费者线程消费了生产者生产的资源 。
Callable 和 Future 是比较有趣的一对组合。当我们需要获取线程的执行结果时，就需要用到它们。Callable用于产生结果，Future用于获取结果 。Callable接口使用泛型去定义它的返回类型 。Executors类提供了一些有用的方法去在线程池中执行Callable内的任务。由于Callable任务是并行的，必须等待它返回的结果。java.util.concurrent.Future对象解决了这个问题。在线程池提交Callable任务后返回了一个Future对象 ，使用它可以知道Callable任务的状态和得到Callable返回的执行结果。Future提供了get()方法，等待Callable结束并获取它的执行结果。代码示例 Callable 是一个接口，它只包含一个call()方法。Callable是一个返回结果并且可能抛出异常的任务 。为了便于理解，我们可以将Callable比作一个Runnable接口，而Callable的call()方法则类似于Runnable的run()方法 。
public static void main(String[] args) throws InterruptedException, ExecutionException {
System . out . println ( "start main thread " ); ExecutorService exec = Executors . newFixedThreadPool ( 2 ); //新建一个Callable 任务，并将其提交到一个ExecutorService. 将返回一个描述任务情况的Future.<br /> Callable<String> call = new Callable<String>() { @Override < br /> public String call () throws Exception {< br /> System . out . println ( "start new thread " );< br /> Thread . sleep ( 5000 );< br /> System . out . println ( "end new thread " );< br /> return "我是返回的内容" ;< br /> }< br /> }; Future < String > task = exec . submit ( call );< br /> Thread . sleep ( 1000 );< br /> String retn = task . get ();< br /> //关闭线程池<br /> exec.shutdown();<br /> System.out.println(retn + "--end main thread");<br /> }<br />}<br />控制台打印<br />start main thread <br />start new thread<br />end new thread<br />我是返回的内容--end main thread
FutureTask可用于异步获取执行结果或取消执行任务的场景。通过传入Runnable或者Callable的任务给FutureTask，直接调用其run方法或者放入线程池执行，之后可以在外部通过FutureTask的get方法异步获取执行结果，因此，FutureTask非常适合用于耗时的计算，主线程可以在完成自己的任务后，再去获取结果。另外，FutureTask还可以确保即使调用了多次run方法，它都只会执行一次Runnable或者Callable任务，或者通过cancel取消FutureTask的执行等。
FutureTask执行多任务计算的使用场景
public class FutureTaskForMultiCompute {
public static void main(String[] args) {
FutureTaskForMultiCompute inst = new FutureTaskForMultiCompute ();< br /> // 创建任务集合<br /> List<FutureTask<Integer>> taskList = new ArrayList<FutureTask<Integer>>();<br /> // 创建线程池<br /> ExecutorService exec = Executors.newFixedThreadPool(5);<br /> for (int i = 0; i < 10; i++) {<br /> // 传入Callable对象创建FutureTask对象<br /> FutureTask<Integer> ft = new FutureTask<Integer>(inst.new ComputeTask(i, "" + i));<br /> taskList.add(ft);<br /> // 提交给线程池执行任务，也可以通过exec.invokeAll(taskList)一次性提交所有任务;<br /> exec.submit(ft);<br /> } System . out . println ( "所有计算任务提交完毕, 主线程接着干其他事情！" ); // 开始统计各计算线程计算结果<br /> Integer totalResult = 0;<br /> for (FutureTask<Integer> ft : taskList) {<br /> try {<br /> //FutureTask的get方法会自动阻塞,直到获取计算结果为止<br /> totalResult = totalResult + ft.get();<br /> } catch (InterruptedException e) {<br /> e.printStackTrace();<br /> } catch (ExecutionException e) {<br /> e.printStackTrace();<br /> }<br /> } // 关闭线程池<br /> exec.shutdown();<br /> System.out.println("多任务计算后的总结果是:" + totalResult); }
private class ComputeTask implements Callable {
private Integer result = 0 ;< br /> private String taskName = "" ; public ComputeTask ( Integer iniResult , String taskName ) {< br /> result = iniResult ;< br /> this . taskName = taskName ;< br /> System . out . println ( "生成子线程计算任务: " + taskName );< br /> } public String getTaskName () {< br /> return this . taskName ;< br /> } @Override < br /> public Integer call () throws Exception {< br /> // TODO Auto-generated method stub for ( int i = 0 ; i < 100 ; i ++) {< br /> result = + i ;< br /> }< br /> // 休眠5秒钟，观察主线程行为，预期的结果是主线程会继续执行，到要取得FutureTask的结果是等待直至完成。<br /> Thread.sleep(5000);<br /> System.out.println("子线程计算任务: " + taskName + " 执行完成!");<br /> return result;<br /> }<br /> }<br />}<br />生成子线程计算任务: 0<br />生成子线程计算任务: 1<br />生成子线程计算任务: 2<br />生成子线程计算任务: 3<br />生成子线程计算任务: 4<br />生成子线程计算任务: 5<br />生成子线程计算任务: 6<br />生成子线程计算任务: 7<br />生成子线程计算任务: 8<br />生成子线程计算任务: 9<br />所有计算任务提交完毕, 主线程接着干其他事情！<br />子线程计算任务: 0 执行完成!<br />子线程计算任务: 2 执行完成!<br />子线程计算任务: 3 执行完成!<br />子线程计算任务: 4 执行完成!<br />子线程计算任务: 1 执行完成!<br />子线程计算任务: 8 执行完成!<br />子线程计算任务: 7 执行完成!<br />子线程计算任务: 6 执行完成!<br />子线程计算任务: 9 执行完成!<br />子线程计算任务: 5 执行完成!<br />多任务计算后的总结果是:990
FutureTask在高并发环境下确保任务只执行一次 connectionPool = new HashMap();
public Connection getConnection(String key) {
//创建Connection > connectionPool = new ConcurrentHashMap>();
public Connection getConnection(String key) throws Exception { connectionTask = connectionPool.get(key); callable = new Callable() { newTask = new FutureTask(callable);
//创建Connection 经过这样的改造，可以避免由于并发带来的多次创建连接及锁的出现。
主要代表有Vector和Hashtable，以及Collections.synchronizedXxx等。
主要代表有ConcurrentHashMap、CopyOnWriteArrayList、ConcurrentSkipListMap、ConcurrentSkipListSet。JDK 7 ConcurrentHashMap JDK 8 ConcurrentHashMap
主要代表有LinkedBlockingQueue、ArrayBlockingQueue、PriorityBlockingQueue(Comparable,Comparator)、SynchronousQueue。
主要代表有ArrayDeque和LinkedBlockingDeque。
如果不需要阻塞队列，优先选择ConcurrentLinkedQueue；
什么是多线程？ 多线程的好处：
使用多线程可以把程序中占据时间长的任务放到后台去处理，如图片、视屏的下载 发挥多核处理器的优势，并发执行让系统运行的更快、更流畅，用户体验更好
多线程的缺点：
大量的线程降低代码的可读性； 更多的线程需要更多的内存空间 当多个线程对同一个资源出现争夺时候要注意线程安全的问题。
上下文切换过程中，CPU会停止处理当前运行的程序，并保存当前程序运行的具体位置以便之后继续运行 CPU通过时间片分配算法来循环执行任务，当前任务执行一个时间片后会切换到下一个任务。但是，在切换前会保存上一个任务的状态，以便下次切换回这个任务时，可以再次加载这个任务的状态
从任务保存到再加载的过程就是一次上下文切换
如何创建ThreadLocal变量 所有的线程都能访问到这个ThreadLocal实例，但是每个线程却只能访问到自己通过调用ThreadLocal的set()方法设置的值。即使是两个不同的线程在同一个ThreadLocal对象上设置了不同的值，他们仍然无法访问到对方的值 。如何访问ThreadLocal变量 为ThreadLocal指定泛型类型 myThreadLocal = new ThreadLocal();ThreadLocal的设计理念与作用 http://blog.csdn.net/u011860731/article/details/48733073http://blog.csdn.net/u011860731/article/details/48733073 )
threadLocal = new InheritableThreadLocal();InheritableThreadLocal允许一个线程以及该线程创建的所有子线程都可以访问它保存的值 。InheritableThreadLocal 原理 Java 多线程：InheritableThreadLocal 实现原理 http://blog.csdn.net/ni357103403/article/details/51970748
减少了创建和销毁线程的次数，每个工作线程都可以被重复利用，可执行多个任务。 可以根据系统的承受能力，调整线程池中工作线线程的数目，防止因为消耗过多的内存，而把服务器累趴下(每个线程需要大约1MB内存，线程开的越多，消耗的内存也就越大，最后死机)。 Java里面线程池的顶级接口是Executor，但是严格意义上讲Executor并不是一个线程池，而只是一个执行线程的工具。真正的线程池接口是ExecutorService。
每次new Thread新建对象性能差。
线程缺乏统一管理，可能无限制新建线程，相互之间竞争，及可能占用过多系统资源导致死机或oom。 缺乏更多功能，如定时执行、定期执行、线程中断。
减少在创建和销毁线程上所花的时间以及系统资源的开销 如不使用线程池，有可能造成系统创建大量线程而导致消耗完系统内存
Java提供的四种线程池的好处在于 ：
重用存在的线程，减少对象创建、销毁的开销，提高性能。 可有效控制最大并发线程数，提高系统资源的使用率，同时避免过多资源竞争，避免堵塞。 提供定时执行、定期执行、单线程、并发数控制等功能。
要配置一个线程池是比较复杂的，尤其是对于线程池的原理不是很清楚的情况下，很有可能配置的线程池不是较优的，因此在Executors类里面提供了一些静态工厂，生成一些常用的线程池。
newCachedThreadPool 创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。newFixedThreadPool 创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。newScheduledThreadPool 创建一个定长线程池，支持定时及周期性任务执行。newSingleThreadExecutor 创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。
使用ThreadPoolExecutor创建线程池 ThreadPoolExecutor的构造函数 workQueue,
corePoolSize 核心线程数大小，当线程数<corePoolSize ，会创建线程执行runnablemaximumPoolSize 最大线程数， 当线程数 >= corePoolSize的时候，会把runnable放入workQueue中keepAliveTime 保持存活时间，当线程数大于corePoolSize的空闲线程能保持的最大时间。unit 时间单位workQueue 保存任务的阻塞队列threadFactory 创建线程的工厂handler 拒绝策略
当线程数小于corePoolSize时，创建线程执行任务。
当线程数大于等于corePoolSize并且workQueue没有满时，放入workQueue中 线程数大于等于corePoolSize并且当workQueue满时，新任务新建线程运行，线程总数要小于maximumPoolSize 当线程总数等于maximumPoolSize并且workQueue满了的时候执行handler的rejectedExecution。也就是拒绝策略。
ThreadPoolExecutor.AbortPolicy() 直接抛出异常RejectedExecutionException
ThreadPoolExecutor.CallerRunsPolicy() 直接调用run方法并且阻塞执行ThreadPoolExecutor.DiscardPolicy() 直接丢弃后来的任务ThreadPoolExecutor.DiscardOldestPolicy() 丢弃在队列中队首的任务
当然可以自己继承 RejectedExecutionHandler 来写拒绝策略.
https://juejin.im/post/59df0c1af265da432f301c8d
阻塞队列 ArrayBlockingQueue 数组结构组成的有界阻塞队列。
CountDownLatch 允许一个或多个线程等待其他线程完成操作。应用场景
public static void main(String[] args) throws InterruptedException {
Thread parser2 = new Thread ( new Runnable () {< br /> @Override < br /> public void run () {< br /> System . out . println ( "parser2 finish" );< br /> }< br /> }); parser1 . start ();< br /> parser2 . start ();< br /> parser1 . join ();< br /> parser2 . join ();< br /> System . out . println ( "all parser finish" );< br />} }
方法isAlive()功能是判断当前线程是否处于活动状态。 活动状态就是线程启动且尚未终止，比如正在运行或准备开始运行。
public class Test {Java并发编程：CountDownLatch、CyclicBarrier和 Semaphore http://www.importnew.com/21889.html
java在编写多线程程序时，为了保证线程安全，需要对数据同步，经常用到两种同步方式就是Synchronized和重入锁ReentrantLock。
可重入锁 。可重入锁是指同一个线程可以多次获取同一把锁。ReentrantLock和synchronized都是可重入锁 。
可中断锁 。可中断锁是指线程尝试获取锁的过程中，是否可以响应中断。synchronized是不可中断锁，而ReentrantLock则提供了中断功能。公平锁与非公平锁 。公平锁是指多个线程同时尝试获取同一把锁时，获取锁的顺序按照线程达到的顺序，而非公平锁则允许线程“插队”。synchronized是非公平锁，而ReentrantLock的默认实现是非公平锁，但是也可以设置为公平锁。CAS操作(CompareAndSwap) 。CAS操作简单的说就是比较并交换。CAS 操作包含三个操作数 —— 内存位置（V）、预期原值（A）和新值(B)。如果内存位置的值与预期原值相匹配，那么处理器会自动将该位置值更新为新值。否则，处理器不做任何操作。无论哪种情况，它都会在 CAS 指令之前返回该位置的值。CAS 有效地说明了“我认为位置 V 应该包含值 A；如果包含该值，则将 B 放到这个位置；否则，不要更改该位置，只告诉我这个位置现在的值即可。”
当线程尝试获取锁的时候，如果获取不到锁会一直阻塞。 如果获取锁的线程进入休眠或者阻塞，除非当前线程异常，否则其他线程尝试获取锁必须一直等待。
**lock ()**, 如果获取了锁立即返回，如果别的线程持有锁，当前线程则一直处于休眠状态，直到获取锁tryLock() , 如果获取了锁立即返回true，如果别的线程正持有锁，立即返回false；tryLock(long timeout,TimeUnit unit)** ，如果获取了锁定立即返回true，如果别的线程正持有锁，会等待参数给定的时间，在等待的过程中，如果获取了锁定，就返回true，如果等待超时，返回false；lockInterruptibly :如果获取了锁定立即返回，如果没有获取锁定，当前线程处于休眠状态，直到或者锁定，或者当前线程被别的线程中断
ReentrantLock 一些特性
等待可中断避免，出现死锁的情况 （如果别的线程正持有锁，会等待参数给定的时间，在等待的过程中，如果获取了锁定，就返回true，如果等待超时，返回false）公平锁与非公平锁 多个线程等待同一个锁时，必须按照申请锁的时间顺序获得锁，Synchronized锁非公平锁，ReentrantLock默认的构造函数是创建的非公平锁，可以通过参数true设为公平锁 ，但公平锁表现的性能不是很好。
公平锁：线程获取锁的顺序和调用lock的顺序一样，FIFO；Java并发包(java.util.concurrent)中大量使用了CAS操作,涉及到并发的地方都调用了sun.misc.Unsafe类方法进行CAS操作 。
简单来说，ReenTrantLock的实现是一种自旋锁，通过循环调用CAS操作来实现加锁 。它的性能比较好也是因为避免了使线程进入内核态的阻塞状态。想尽办法避免线程进入内核的阻塞状态是我们去分析和理解锁设计的关键钥匙。
在Synchronized优化以前，synchronized的性能是比ReenTrantLock差很多的，但是自从Synchronized引入了偏向锁，轻量级锁（自旋锁）后，两者的性能就差不多了，在两种方法都可用的情况下，官方甚至建议使用synchronized，其实synchronized的优化我感觉就借鉴了ReenTrantLock中的CAS技术。都是试图在用户态就把加锁问题解决，避免进入内核态的线程阻塞。synchronized ：ReentrantLock :使用非公平锁是基于性能考虑 ，公平锁为了保证线程规规矩矩地排队，需要增加阻塞和唤醒的时间开销。如果直接插队获取非公平锁，跳过了对队列的处理，速度会更快。ReentrantLock实现原理 https://www.cnblogs.com/maypattis/p/6403682.html 分析ReentrantLock的实现原理 (ReentrantLock和同步工具类的实现基础都是AQS)https://www.jianshu.com/p/fe027772e156
Semaphore就是一个信号量，它的作用是限制某段代码块的并发数 。 Semaphore有一个构造函数，可以传入一个int型整数n，表示某段代码最多只有n个线程可以访问 ， 如果超出了n，那么请等待，等到某个线程执行完毕这段代码块，下一个线程再进入 。由此可以看出如果Semaphore构造函数中传入的int型整数n=1，相当于变成了一个synchronized了。
Semaphore类位于java.util.concurrent包下，它提供了2个构造器：
Semaphore类中比较重要的几个方法，首先是acquire()、release()方法： acquire()用来获取一个许可，若无许可能够获得，则会一直等待，直到获得许可。 release()用来释放许可。注意，在释放许可之前，必须先获获得许可。
Semaphore类中比较重要的几个方法，首先是acquire()、release()方法：
假若一个工厂有5台机器，但是有8个工人，一台机器同时只能被一个工人使用，只有使用完了，其他工人才能继续使用。那么我们就可以通过Semaphore来实现： new Worker(i,semaphore).start();
Lock接口比同步方法和同步块提供了更具扩展性的锁操作。他们允许更灵活的结构，可以具有完全不同的性质，并且可以支持多个相关类的条件对象。
可以使锁更公平 可以使线程在等待锁的时候响应中断 可以让线程尝试获取锁，并在无法获取锁的时候立即返回或者等待一段时间 可以在不同的范围，以不同的顺序获取和释放锁
同一时间只能有一条线程执行固定类的同步方法，但是对于类的非同步方法，可以多条线程同时访问。所以，这样就有问题了，可能线程A在执行Hashtable的put方法添加数据，线程B则可以正常调用size()方法读取Hashtable中当前元素的个数，那读取到的值可能不是最新的，可能线程A添加了完了数据，但是没有对size++，线程B就已经读取size了，那么对于线程B来说读取到的size一定是不准确的。而给size()方法加了同步之后，意味着线程B调用size()方法只有在线程A调用put方法完毕之后才可以调用，这样就保证了线程安全性
ConcurrentHashMap的并发度就是segment的大小，默认为16，这意味着最多同时可以有16条线程操作ConcurrentHashMap，这也是ConcurrentHashMap对Hashtable的最大优势
Lock比传统线程模型中的synchronized方式更加面向对象，与生活中的锁类似，锁本身也应该是一个对象。两个线程执行的代码片段要实现同步互斥的效果，它们必须用同一个Lock对象。读写锁 ：分为读锁和写锁，多个读锁不互斥，读锁与写锁互斥，这是由jvm自己控制的，你只要上好相应的锁即可 。如果你的代码只读数据，可以很多人同时读，但不能同时写，那就上读锁 ；ReentrantReadWriteLock会使用两把锁来解决问题，一个读锁，一个写锁 线程进入读锁的前提条件 ：
没有其他线程的写锁
没有写请求或者有写请求，但调用线程和持有锁的线程是同一个
线程进入写锁的前提条件 ：
没有其他线程的读锁 没有其他线程的写锁 读锁的重入是允许多个申请读操作的线程的，而写锁同时只允许单个线程占有，该线程的写操作可以重入。 如果一个线程占有了写锁，在不释放写锁的情况下，它还能占有读锁，即写锁降级为读锁。 对于同时占有读锁和写锁的线程，如果完全释放了写锁，那么它就完全转换成了读锁，以后的写操作无法重入，在写锁未完全释放时写操作是可以重入的。 公平模式下无论读锁还是写锁的申请都必须按照AQS锁等待队列先进先出的顺序。非公平模式下读操作插队的条件是锁等待队列head节点后的下一个节点是SHARED型节点，写锁则无条件插队。 读锁不允许newConditon获取Condition接口，而写锁的newCondition接口实现方法同ReentrantLock。
什么是线程？ 什么是线程安全和线程不安全？ 什么是自旋锁？ 什么是Java内存模型？ 什么是CAS？ 什么是乐观锁和悲观锁？ 什么是AQS？ 什么是原子操作？在Java Concurrency API中有哪些原子类(atomic classes)？ 什么是Executors框架？ 什么是阻塞队列？如何使用阻塞队列来实现生产者-消费者模型？ 什么是Callable和Future? 什么是FutureTask? 什么是同步容器和并发容器的实现？ 什么是多线程？优缺点？ 什么是多线程的上下文切换？ ThreadLocal的设计理念与作用？ ThreadPool（线程池）用法与优势？ Concurrent包里的其他东西：ArrayBlockingQueue、CountDownLatch等等。 synchronized和ReentrantLock的区别？ Semaphore有什么作用？ Java Concurrency API中的Lock接口(Lock interface)是什么？对比同步它有什么优势？ Hashtable的size()方法中明明只有一条语句”return count”，为什么还要做同步？ ConcurrentHashMap的并发度是什么？ ReentrantReadWriteLock读写锁的使用？ CyclicBarrier和CountDownLatch的用法及区别？ LockSupport工具？ Condition接口及其实现原理？ Fork/Join框架的理解? wait()和sleep()的区别? 线程的五个状态（五种状态，创建、就绪、运行、阻塞和死亡）? start()方法和run()方法的区别？ Runnable接口和Callable接口的区别？ volatile关键字的作用？ Java中如何获取到线程dump文件？ 线程和进程有什么区别？ 线程实现的方式有几种（四种）？ 高并发、任务执行时间短的业务怎样使用线程池？并发不高、任务执行时间长的业务怎样使用线程池？并发高、业务执行时间长的业务怎样使用线程池？ 如果你提交任务时，线程池队列已满，这时会发生什么？ 锁的等级：方法锁、对象锁、类锁? 如果同步块内的线程抛出异常会发生什么？ 并发编程（concurrency）并行编程（parallellism）有什么区别？ 如何保证多线程下 i++ 结果正确？ 一个线程如果出现了运行时异常会怎么样? 如何在两个线程之间共享数据? 生产者消费者模型的作用是什么? 怎么唤醒一个阻塞的线程? Java中用到的线程调度算法是什么 单例模式的线程安全性? 线程类的构造方法、静态块是被哪个线程调用的? 同步方法和同步块，哪个是更好的选择? 如何检测死锁？怎么预防死锁？
通俗的说：加锁的就是是线程安全的，不加锁的就是是线程不安全的
线程安全: 就是多线程访问时，采用了加锁机制，当一个线程访问该类的某个数据时，进行保护，其他线程不能进行访问，直到该线程读取完，其他线程才可使用。不会出现数据不一致或者数据污染 。集合类分成两组，线程安全和非线程安全的 。线程不安全：就是不提供数据访问保护，有可能出现多个线程先后更改数据造成所得到的数据是脏数据 自旋锁是SMP架构中的一种low-level的同步机制 。自选锁需要注意 ：
由于自旋时不释放CPU，因而持有自旋锁的线程应该尽快释放自旋锁，否则等待该自旋锁的线程会一直在那里自旋，这就会浪费CPU时间。 持有自旋锁的线程在sleep之前应该释放自旋锁以便其它线程可以获得自旋锁 。
参考https://segmentfault.com/q/1010000000530936
MonitorObject myMonitorObject = new MonitorObject();
public void doWait(){
public void doNotify(){
Java内存模型描述了在多线程代码中哪些行为是合法的，以及线程如何通过内存进行交互。它描述了“程序中的变量“ 和 ”从内存或者寄存器获取或存储它们的底层细节”之间的关系。Java内存模型通过使用各种各样的硬件和编译器的优化来正确实现以上事情 。Java包含了几个语言级别的关键字，包括：volatile, final以及synchronized，目的是为了帮助程序员向编译器描述一个程序的并发需求。Java内存模型定义了volatile和synchronized的行为，更重要的是保证了同步的java程序在所有的处理器架构下面都能正确的运行。
public void reader() {
JVM内存结构主要有三大块：堆内存、方法区和栈 。Eden空间、From Survivor空间、To Survivor空间 ,默认情况下年轻代按照8:1:1的比例来分配；方法区存储类信息、常量、静态变量等数据，是线程共享的区域 ，为与Java堆区分，方法区还有一个别名Non-Heap(非堆)；栈又分为java虚拟机栈和本地方法栈主要用于方法的执行。JAVA的JVM的内存可分为3个区：堆(heap)、栈(stack)和方法区(method)
可通过参数 -Xms 和-Xmx设置
Java堆是被所有线程共享,是Java虚拟机所管理的内存中最大的一块 Java堆在虚拟机启动时创建 。Java堆唯一的目的是存放对象实例，几乎所有的对象实例和数组都在这里 。Java堆为了便于更好的回收和分配内存，可以细分为：新生代和老年代 ；再细致一点的有Eden空间、From Survivor空间、To Survivor区 。
新生代 ：包括Eden区、From Survivor区、To Survivor区，系统默认大小Eden:Survivor=8:1。老年代 ：在年轻代中经历了N次垃圾回收后仍然存活的对象，就会被放到年老代中。因此，可以认为年老代中存放的都是一些生命周期较长的对象。
Survivor空间等Java堆可以处在物理上不连续的内存空间中，只要逻辑上是连续的即可（就像我们的磁盘空间一样。在实现时，既可以实现成固定大小的，也可以是可扩展的）。
据Java虚拟机规范的规定，当方法区无法满足内存分配需求时，将抛出OutOfMemoryError异常 。
可通过参数 栈帧是方法运行期的基础数据结构栈容量可由-Xss设置 Java虚拟机栈是线程私有的，它的生命周期与线程相同 。
每一个方法被调用直至执行完成的过程，就对应着一个栈帧在虚拟机栈中从入栈到出栈的过程。 虚拟机栈是执行Java方法的内存模型(也就是字节码)服务：每个方法在执行的同时都会创建一个栈帧 ，用于存储 局部变量表 、操作数栈 、动态链接 、方法出口 等信息。
局部变量表 ：32位变量槽，存放了编译期可知的各种基本数据类型、对象引用、returnAddress类型 。操作数栈 ：基于栈的执行引擎，虚拟机把操作数栈作为它的工作区，大多数指令都要从这里弹出数据、执行运算，然后把结果压回操作数栈。动态连接 ：每个栈帧都包含一个指向运行时常量池（方法区的一部分）中该栈帧所属方法的引用 。持有这个引用是为了支持方法调用过程中的动态连接。Class文件的常量池中有大量的符号引用，字节码中的方法调用指令就以常量池中指向方法的符号引用为参数。这些符号引用一部分会在类加载阶段或第一次使用的时候转化为直接引用，这种转化称为静态解析。另一部分将在每一次的运行期间转化为直接应用，这部分称为动态连接方法出口 ：返回方法被调用的位置，恢复上层方法的局部变量和操作数栈，如果无返回值，则把它压入调用者的操作数栈。
局部变量表所需的内存空间在编译期间完成分配 ，当进入一个方法时，这个方法需要在帧中分配多大的局部变量空间是完全确定的。在方法运行期间不会改变局部变量表的大小。主要存放了编译期可知的各种基本数据类型、对象引用 （reference类型）、returnAddress类型）。
undefinedjava虚拟机栈,规定了两种异常状况：
如果线程请求的深度大于虚拟机所允许的深度，将抛出StackOverflowError异常 。如果虚拟机栈动态扩展，而扩展时无法申请到足够的内存，就会抛出OutOfMemoryError异常 。
可通过参数 栈容量可由-Xss设置
虚拟机栈为虚拟机执行Java方法（也就是字节码）服务。
本地方法栈则是为虚拟机使用到的Native方法服务。有的虚拟机（譬如Sun HotSpot虚拟机）直接就把本地方法栈和虚拟机栈合二为一
可通过参数-XX:MaxPermSize设置
线程共享内存区域，用于储存已被虚拟机加载的类信息、常量、静态变量，即编译器编译后的代码，方法区也称持久代（Permanent Generation） 。
虽然Java虚拟机规范把方法区描述为堆的一个逻辑部分，但是它却有一个别名叫做Non-Heap（非堆） ，目的应该是与Java堆区分开来。 如何实现方法区，属于虚拟机的实现细节，不受虚拟机规范约束。 方法区主要存放java类定义信息，与垃圾回收关系不大，方法区可以选择不实现垃圾回收,但不是没有垃圾回收。 方法区域的内存回收目标主要是针对常量池的回收和对类型的卸载 。运行时常量池，也是方法区的一部分，虚拟机加载Class后把常量池中的数据放入运行时常量池 。
JDK1.6之前字符串常量池位于方法区之中 。JDK1.7字符串常量池已经被挪到堆之中 。可通过参数-XX:PermSize和-XX:MaxPermSize设置
常量池 （Constant Pool）：常量池数据编译期被确定，是Class文件中的一部分。存储了类、方法、接口等中的常量，当然也包括字符串常量 。字符串池/字符串常量池 （String Pool/String Constant Pool）：是常量池中的一部分，存储编译期类中产生的字符串类型数据。运行时常量池 （Runtime Constant Pool）：方法区的一部分，所有线程共享。虚拟机加载Class后把常量池中的数据放入到运行时常量池 。常量池：可以理解为Class文件之中的资源仓库，它是Class文件结构中与其他项目资源关联最多的数据类型。
常量池中主要存放两大类常量：字面量（Literal）和符号引用（Symbolic Reference）。 字面量：文本字符串、声明为final的常量值等。 符号引用：类和接口的完全限定名（Fully Qualified Name）、字段的名称和描述符（Descriptor）、方法的名称和描述符。
可通过-XX:MaxDirectMemorySize指定，如果不指定，则默认与Java堆的最大值（-Xmx指定）一样 。
直接内存（Direct Memory）并不是虚拟机运行时数据区的一部分，也不是Java虚拟机规范中定义的内存区域，但是这部分内存也被频繁地使用，而且也可能导致OutOfMemoryError异常出现 。
java堆（Java Heap）
Java堆是被所有线程共享 ,是Java虚拟机所管理的内存中最大的一块 Java堆在虚拟机启动时创建Java堆唯一的目的是存放对象实例，几乎所有的对象实例和数组都在这里 Java堆为了便于更好的回收和分配内存，可以细分为：新生代和老年代；再细致一点的有Eden空间、From Survivor空间、To Survivor区
新生代 ：包括Eden区、From Survivor区、To Survivor区，系统默认大小Eden:Survivor=8:1。老年代 ：在年轻代中经历了N次垃圾回收后仍然存活的对象，就会被放到年老代中。因此，可以认为年老代中存放的都是一些生命周期较长的对象。
java虚拟机栈(stack)
Java虚拟机栈是线程私有的，它的生命周期与线程相同 。每一个方法被调用直至执行完成的过程，就对应着一个栈帧在虚拟机栈中从入栈到出栈的过程。 虚拟机栈是执行Java方法的内存模型(也就是字节码)服务：每个方法在执行的同时都会创建一个栈帧，用于存储 局部变量表 、操作数栈 、动态链接 、方法出口 等信息
方法区（Method Area）
线程共享内存区域） ，用于储存已被虚拟机加载的类信息、常量、静态变量，即编译器编译后的代码 ，方法区也称持久代（Permanent Generation） 。方法区主要存放java类定义信息，与垃圾回收关系不大，方法区可以选择不实现垃圾回收,但不是没有垃圾回收。 方法区域的内存回收目标主要是针对常量池的回收和对类型的卸载。 运行时常量池，也是方法区的一部分，虚拟机加载Class后把常量池中的数据放入运行时常量池 。
CAS（compare and swap）的缩写，中文翻译成比较并交换 。利用CPU的CAS指令，同时借助JNI来完成Java的非阻塞算法,实现原子操作。其它原子操作都是利用类似的特性完成的 。CAS是项乐观锁技术 ，当多个线程尝试使用CAS同时更新同一个变量时，只有其中一个线程能更新变量的值，而其它线程都失败，失败的线程并不会被挂起，而是被告知这次竞争中失败，并可以再次尝试。
CAS有3个操作数，内存值V，旧的预期值A，要修改的新值B。当且仅当预期值A和内存值V相同时，将内存值V修改为B，否则什么都不做。
确保对内存的读-改-写操作都是原子操作执行
CAS虽然很高效的解决原子操作，但是CAS仍然存在三大问题。ABA问题，循环时间长开销大和只能保证一个共享变量的原子操作
使用CAS在线程冲突严重时，会大幅降低程序性能；CAS只适合于线程冲突较少的情况使用 。
synchronized在jdk1.6之后，已经改进优化。synchronized的底层实现主要依靠Lock-Free的队列，基本思路是自旋后阻塞，竞争切换后继续竞争锁，稍微牺牲了公平性，但获得了高吞吐量。在线程冲突较少的情况下，可以获得和CAS类似的性能；而线程冲突严重的情况下，性能远高于CAS 。
参考https://blog.52itstyle.com/archives/948/
Java在JDK1.5之前都是靠synchronized关键字保证同步的，这种通过使用一致的锁定协议来协调对共享状态的访问，可以确保无论哪个线程持有共享变量的锁，都采用独占的方式来访问这些变量。独占锁其实就是一种悲观锁，所以可以说synchronized是悲观锁。
乐观锁（ Optimistic Locking）其实是一种思想。相对悲观锁而言，乐观锁假设认为数据一般情况下不会造成冲突，所以在数据进行提交更新的时候，才会正式对数据的冲突与否进行检测，如果发现冲突了，则让返回用户错误的信息，让用户决定如何去做。
AbstractQueuedSynchronizer简称AQS，是一个用于构建锁和同步容器的框架 。事实上concurrent包内许多类都是基于AQS构建，例如ReentrantLock ，Semaphore，CountDownLatch，ReentrantReadWriteLock，FutureTask 等。AQS解决了在实现同步容器时设计的大量细节问题。AQS使用一个FIFO的队列表示排队等待锁的线程，队列头节点称作“哨兵节点”或者“哑节点”，它不与任何线程关联。其他的节点与等待线程关联，每个节点维护一个等待状态waitStatus。
参考https://blog.52itstyle.com/archives/948/
A线程写volatile变量，随后B线程读这个volatile变量。 A线程写volatile变量，随后B线程用CAS更新这个volatile变量。 A线程用CAS更新一个volatile变量，随后B线程用CAS更新这个volatile变量。 A线程用CAS更新一个volatile变量，随后B线程读这个volatile变量。
Java的CAS会使用现代处理器上提供的高效机器级别原子指令，这些原子指令以原子方式对内存执行读-改-写操作，这是在多处理器中实现同步的关键（从本质上来说，能够支持原子性读-改-写指令的计算机器，是顺序计算图灵机的异步等价机器，因此任何现代的多处理器都会去支持某种能对内存执行原子性读-改-写操作的原子指令）。同时，volatile变量的读/写和CAS可以实现线程之间的通信。把这些特性整合在一起，就形成了整个concurrent包得以实现的基石。如果我们仔细分析concurrent包的源代码实现，会发现一个通用化的实现模式：
state是独占的，还是共享的； state被获取后，其他线程需要等待； state被释放后，唤醒等待线程； 线程等不及时，如何退出等待。
至于线程是否可以获得state，如何释放state，就不是AQS关心的了，要由子类具体实现。AQS中还有一个表示状态的字段state，例如ReentrantLocky用它表示线程重入锁的次数，Semaphore用它表示剩余的许可数量，FutureTask用它表示任务的状态。对state变量值的更新都采用CAS操作保证更新操作的原子性 。https://www.cnblogs.com/maypattis/p/6403682.html
原子操作是指一个不受其他操作影响的操作任务单元。原子操作是在多线程环境下避免数据不一致必须的手段。
Executor框架同java.util.concurrent.Executor 接口在Java 5中被引入。newCachedThreadPool 创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。newFixedThreadPool 创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。newScheduledThreadPool 创建一个定长线程池，支持定时及周期性任务执行。newSingleThreadExecutor 创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。
JDK7提供了7个阻塞队列。（也属于并发容器）
ArrayBlockingQueue ：一个由数组结构组成的有界阻塞队列。 LinkedBlockingQueue ：一个由链表结构组成的有界阻塞队列。 PriorityBlockingQueue ：一个支持优先级排序的无界阻塞队列。 DelayQueue：一个使用优先级队列实现的无界阻塞队列。 SynchronousQueue：一个不存储元素的阻塞队列。 LinkedTransferQueue：一个由链表结构组成的无界阻塞队列。 LinkedBlockingDeque：一个由链表结构组成的双向阻塞队列。
插入 方法：队列满时，队列会阻塞插入元素的线程，直到队列不满。移除 方法：队列空时，获取元素的线程会等待队列变为非空。
方法\处理方式
抛出异常
返回特殊值
一直阻塞
超时退出
插入方法
add(e)
offer(e)
put(e)
offer(e,time,unit)
移除方法
remove()
poll()
take()
poll(time,unit)
检查方法
element()
peek()
不可用
不可用
JDK 7 提供了7个阻塞队列，如下ArrayBlockingQueue 数组结构组成的有界阻塞队列。LinkedBlockingQueue 一个由链表结构组成的有界阻塞队列PriorityBlockingQueue 支持优先级的无界阻塞队列DelayQueue 支持延时获取元素的无界阻塞队列，即可以指定多久才能从队列中获取当前元素SynchronousQueue 不存储元素的阻塞队列，每一个put必须等待一个take操作，否则不能继续添加元素。并且他支持公平访问队列。LinkedTransferQueue 由链表结构组成的无界阻塞TransferQueue队列。相对于其他阻塞队列，多了tryTransfer和transfer方法transfer方法 tryTransfer方法 LinkedBlockingDeque 链表结构的双向阻塞队列，优势在于多线程入队时，减少一半的竞争。
通知模式实现：所谓通知模式，就是当生产者往满的队列里添加元素时会阻塞住生产者，当消费者消费了一个队列中的元素后，会通知生产者当前队列可用。
为什么BlockingQueue适合解决生产者消费者问题 BlockingQueue是一种数据结构，支持一个线程往里存资源，另一个线程从里取资源。这正是解决生产者消费者问题所需要的，那么让我们开始解决该问题吧。 生产者
import java.util.concurrent.BlockingQueue;
/ 描述:生产者 @author yanpenglei @create 2018-03-14 15:52
protected BlockingQueue queue;
Producer(BlockingQueue theQueue) {
public void run() {
Object getResource () {< br /> try {< br /> Thread . sleep ( 100 );< br /> } catch ( InterruptedException ex ) {< br /> System . out . println ( "生产者 读 中断" );< br /> }< br /> return new Object ();< br /> }< br />}< br />**消费者**< br />以下代码用于消费者线程< br /> package io . ymq . example . thread ; import java.util.concurrent.BlockingQueue;
/ 描述: 消费者 @author yanpenglei @create 2018-03-14 15:54 queue;
Consumer(BlockingQueue theQueue) {
public void run() {
void take(Object obj) {测试该解决方案是否运行正常
/ 描述: 测试 @author yanpenglei @create 2018-03-14 15:58
public static void main(String[] args) throws InterruptedException {
int numProducers = 4 ;< br /> int numConsumers = 3 ; BlockingQueue < Object > myQueue = new LinkedBlockingQueue < Object >( 5 ); for ( int i = 0 ; i < numProducers ; i ++) {< br /> new Thread ( new Producer ( myQueue )). start ();< br /> } for ( int i = 0 ; i < numConsumers ; i ++) {< br /> new Thread ( new Consumer ( myQueue )). start ();< br /> } Thread . sleep ( 1000 ); System . exit ( 0 );< br /> }< br />}< br />**运行结果**< br />生产者资源队列大小= 1 < br />生产者资源队列大小= 1 < br />消费者 资源 队列大小 1 < br />生产者资源队列大小= 1 < br />消费者 资源 队列大小 1 < br />消费者 资源 队列大小 1 < br />生产者资源队列大小= 1 < br />生产者资源队列大小= 3 < br />消费对象 java . lang . Object@1e1aa52b < br />生产者资源队列大小= 2 < br />生产者资源队列大小= 5 < br />消费对象 java . lang . Object@6e740a76 < br />消费对象 java . lang . Object@697853f6 ……
消费对象 java.lang.Object@41a10cbc从输出结果中,我们可以发现队列大小永远不会超过5，消费者线程消费了生产者生产的资源 。
Callable 和 Future 是比较有趣的一对组合。当我们需要获取线程的执行结果时，就需要用到它们。Callable用于产生结果，Future用于获取结果 。Callable接口使用泛型去定义它的返回类型 。Executors类提供了一些有用的方法去在线程池中执行Callable内的任务。由于Callable任务是并行的，必须等待它返回的结果。java.util.concurrent.Future对象解决了这个问题。在线程池提交Callable任务后返回了一个Future对象 ，使用它可以知道Callable任务的状态和得到Callable返回的执行结果。Future提供了get()方法，等待Callable结束并获取它的执行结果。代码示例 Callable 是一个接口，它只包含一个call()方法。Callable是一个返回结果并且可能抛出异常的任务 。为了便于理解，我们可以将Callable比作一个Runnable接口，而Callable的call()方法则类似于Runnable的run()方法 。
public static void main(String[] args) throws InterruptedException, ExecutionException {
System . out . println ( "start main thread " ); ExecutorService exec = Executors . newFixedThreadPool ( 2 ); //新建一个Callable 任务，并将其提交到一个ExecutorService. 将返回一个描述任务情况的Future.<br /> Callable<String> call = new Callable<String>() { @Override < br /> public String call () throws Exception {< br /> System . out . println ( "start new thread " );< br /> Thread . sleep ( 5000 );< br /> System . out . println ( "end new thread " );< br /> return "我是返回的内容" ;< br /> }< br /> }; Future < String > task = exec . submit ( call );< br /> Thread . sleep ( 1000 );< br /> String retn = task . get ();< br /> //关闭线程池<br /> exec.shutdown();<br /> System.out.println(retn + "--end main thread");<br /> }<br />}<br />控制台打印<br />start main thread <br />start new thread<br />end new thread<br />我是返回的内容--end main thread
FutureTask可用于异步获取执行结果或取消执行任务的场景。通过传入Runnable或者Callable的任务给FutureTask，直接调用其run方法或者放入线程池执行，之后可以在外部通过FutureTask的get方法异步获取执行结果，因此，FutureTask非常适合用于耗时的计算，主线程可以在完成自己的任务后，再去获取结果。另外，FutureTask还可以确保即使调用了多次run方法，它都只会执行一次Runnable或者Callable任务，或者通过cancel取消FutureTask的执行等。
FutureTask执行多任务计算的使用场景
public class FutureTaskForMultiCompute {
public static void main(String[] args) {
FutureTaskForMultiCompute inst = new FutureTaskForMultiCompute ();< br /> // 创建任务集合<br /> List<FutureTask<Integer>> taskList = new ArrayList<FutureTask<Integer>>();<br /> // 创建线程池<br /> ExecutorService exec = Executors.newFixedThreadPool(5);<br /> for (int i = 0; i < 10; i++) {<br /> // 传入Callable对象创建FutureTask对象<br /> FutureTask<Integer> ft = new FutureTask<Integer>(inst.new ComputeTask(i, "" + i));<br /> taskList.add(ft);<br /> // 提交给线程池执行任务，也可以通过exec.invokeAll(taskList)一次性提交所有任务;<br /> exec.submit(ft);<br /> } System . out . println ( "所有计算任务提交完毕, 主线程接着干其他事情！" ); // 开始统计各计算线程计算结果<br /> Integer totalResult = 0;<br /> for (FutureTask<Integer> ft : taskList) {<br /> try {<br /> //FutureTask的get方法会自动阻塞,直到获取计算结果为止<br /> totalResult = totalResult + ft.get();<br /> } catch (InterruptedException e) {<br /> e.printStackTrace();<br /> } catch (ExecutionException e) {<br /> e.printStackTrace();<br /> }<br /> } // 关闭线程池<br /> exec.shutdown();<br /> System.out.println("多任务计算后的总结果是:" + totalResult); }
private class ComputeTask implements Callable {
private Integer result = 0 ;< br /> private String taskName = "" ; public ComputeTask ( Integer iniResult , String taskName ) {< br /> result = iniResult ;< br /> this . taskName = taskName ;< br /> System . out . println ( "生成子线程计算任务: " + taskName );< br /> } public String getTaskName () {< br /> return this . taskName ;< br /> } @Override < br /> public Integer call () throws Exception {< br /> // TODO Auto-generated method stub for ( int i = 0 ; i < 100 ; i ++) {< br /> result = + i ;< br /> }< br /> // 休眠5秒钟，观察主线程行为，预期的结果是主线程会继续执行，到要取得FutureTask的结果是等待直至完成。<br /> Thread.sleep(5000);<br /> System.out.println("子线程计算任务: " + taskName + " 执行完成!");<br /> return result;<br /> }<br /> }<br />}<br />生成子线程计算任务: 0<br />生成子线程计算任务: 1<br />生成子线程计算任务: 2<br />生成子线程计算任务: 3<br />生成子线程计算任务: 4<br />生成子线程计算任务: 5<br />生成子线程计算任务: 6<br />生成子线程计算任务: 7<br />生成子线程计算任务: 8<br />生成子线程计算任务: 9<br />所有计算任务提交完毕, 主线程接着干其他事情！<br />子线程计算任务: 0 执行完成!<br />子线程计算任务: 2 执行完成!<br />子线程计算任务: 3 执行完成!<br />子线程计算任务: 4 执行完成!<br />子线程计算任务: 1 执行完成!<br />子线程计算任务: 8 执行完成!<br />子线程计算任务: 7 执行完成!<br />子线程计算任务: 6 执行完成!<br />子线程计算任务: 9 执行完成!<br />子线程计算任务: 5 执行完成!<br />多任务计算后的总结果是:990
FutureTask在高并发环境下确保任务只执行一次 connectionPool = new HashMap();
public Connection getConnection(String key) {
//创建Connection > connectionPool = new ConcurrentHashMap>();
public Connection getConnection(String key) throws Exception { connectionTask = connectionPool.get(key); callable = new Callable() { newTask = new FutureTask(callable);
//创建Connection 经过这样的改造，可以避免由于并发带来的多次创建连接及锁的出现。
主要代表有Vector和Hashtable，以及Collections.synchronizedXxx等。
主要代表有ConcurrentHashMap、CopyOnWriteArrayList、ConcurrentSkipListMap、ConcurrentSkipListSet。JDK 7 ConcurrentHashMap JDK 8 ConcurrentHashMap
主要代表有LinkedBlockingQueue、ArrayBlockingQueue、PriorityBlockingQueue(Comparable,Comparator)、SynchronousQueue。
主要代表有ArrayDeque和LinkedBlockingDeque。
如果不需要阻塞队列，优先选择ConcurrentLinkedQueue；
什么是多线程？ 多线程的好处：
使用多线程可以把程序中占据时间长的任务放到后台去处理，如图片、视屏的下载 发挥多核处理器的优势，并发执行让系统运行的更快、更流畅，用户体验更好
多线程的缺点：
大量的线程降低代码的可读性； 更多的线程需要更多的内存空间 当多个线程对同一个资源出现争夺时候要注意线程安全的问题。
上下文切换过程中，CPU会停止处理当前运行的程序，并保存当前程序运行的具体位置以便之后继续运行 CPU通过时间片分配算法来循环执行任务，当前任务执行一个时间片后会切换到下一个任务。但是，在切换前会保存上一个任务的状态，以便下次切换回这个任务时，可以再次加载这个任务的状态
从任务保存到再加载的过程就是一次上下文切换
如何创建ThreadLocal变量 所有的线程都能访问到这个ThreadLocal实例，但是每个线程却只能访问到自己通过调用ThreadLocal的set()方法设置的值。即使是两个不同的线程在同一个ThreadLocal对象上设置了不同的值，他们仍然无法访问到对方的值 。如何访问ThreadLocal变量 为ThreadLocal指定泛型类型 myThreadLocal = new ThreadLocal();ThreadLocal的设计理念与作用 http://blog.csdn.net/u011860731/article/details/48733073http://blog.csdn.net/u011860731/article/details/48733073 )
threadLocal = new InheritableThreadLocal();InheritableThreadLocal允许一个线程以及该线程创建的所有子线程都可以访问它保存的值 。InheritableThreadLocal 原理 Java 多线程：InheritableThreadLocal 实现原理 http://blog.csdn.net/ni357103403/article/details/51970748
减少了创建和销毁线程的次数，每个工作线程都可以被重复利用，可执行多个任务。 可以根据系统的承受能力，调整线程池中工作线线程的数目，防止因为消耗过多的内存，而把服务器累趴下(每个线程需要大约1MB内存，线程开的越多，消耗的内存也就越大，最后死机)。 Java里面线程池的顶级接口是Executor，但是严格意义上讲Executor并不是一个线程池，而只是一个执行线程的工具。真正的线程池接口是ExecutorService。
每次new Thread新建对象性能差。
线程缺乏统一管理，可能无限制新建线程，相互之间竞争，及可能占用过多系统资源导致死机或oom。 缺乏更多功能，如定时执行、定期执行、线程中断。
减少在创建和销毁线程上所花的时间以及系统资源的开销 如不使用线程池，有可能造成系统创建大量线程而导致消耗完系统内存
Java提供的四种线程池的好处在于 ：
重用存在的线程，减少对象创建、销毁的开销，提高性能。 可有效控制最大并发线程数，提高系统资源的使用率，同时避免过多资源竞争，避免堵塞。 提供定时执行、定期执行、单线程、并发数控制等功能。
要配置一个线程池是比较复杂的，尤其是对于线程池的原理不是很清楚的情况下，很有可能配置的线程池不是较优的，因此在Executors类里面提供了一些静态工厂，生成一些常用的线程池。
newCachedThreadPool 创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。newFixedThreadPool 创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。newScheduledThreadPool 创建一个定长线程池，支持定时及周期性任务执行。newSingleThreadExecutor 创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。
使用ThreadPoolExecutor创建线程池 ThreadPoolExecutor的构造函数 workQueue,
corePoolSize 核心线程数大小，当线程数<corePoolSize ，会创建线程执行runnablemaximumPoolSize 最大线程数， 当线程数 >= corePoolSize的时候，会把runnable放入workQueue中keepAliveTime 保持存活时间，当线程数大于corePoolSize的空闲线程能保持的最大时间。unit 时间单位workQueue 保存任务的阻塞队列threadFactory 创建线程的工厂handler 拒绝策略
当线程数小于corePoolSize时，创建线程执行任务。
当线程数大于等于corePoolSize并且workQueue没有满时，放入workQueue中 线程数大于等于corePoolSize并且当workQueue满时，新任务新建线程运行，线程总数要小于maximumPoolSize 当线程总数等于maximumPoolSize并且workQueue满了的时候执行handler的rejectedExecution。也就是拒绝策略。
ThreadPoolExecutor.AbortPolicy() 直接抛出异常RejectedExecutionException
ThreadPoolExecutor.CallerRunsPolicy() 直接调用run方法并且阻塞执行ThreadPoolExecutor.DiscardPolicy() 直接丢弃后来的任务ThreadPoolExecutor.DiscardOldestPolicy() 丢弃在队列中队首的任务
当然可以自己继承 RejectedExecutionHandler 来写拒绝策略.
https://juejin.im/post/59df0c1af265da432f301c8d
阻塞队列 ArrayBlockingQueue 数组结构组成的有界阻塞队列。
CountDownLatch 允许一个或多个线程等待其他线程完成操作。应用场景
public static void main(String[] args) throws InterruptedException {
Thread parser2 = new Thread ( new Runnable () {< br /> @Override < br /> public void run () {< br /> System . out . println ( "parser2 finish" );< br /> }< br /> }); parser1 . start ();< br /> parser2 . start ();< br /> parser1 . join ();< br /> parser2 . join ();< br /> System . out . println ( "all parser finish" );< br />} }
方法isAlive()功能是判断当前线程是否处于活动状态。 活动状态就是线程启动且尚未终止，比如正在运行或准备开始运行。
public class Test {Java并发编程：CountDownLatch、CyclicBarrier和 Semaphore http://www.importnew.com/21889.html
java在编写多线程程序时，为了保证线程安全，需要对数据同步，经常用到两种同步方式就是Synchronized和重入锁ReentrantLock。
可重入锁 。可重入锁是指同一个线程可以多次获取同一把锁。ReentrantLock和synchronized都是可重入锁 。
可中断锁 。可中断锁是指线程尝试获取锁的过程中，是否可以响应中断。synchronized是不可中断锁，而ReentrantLock则提供了中断功能。公平锁与非公平锁 。公平锁是指多个线程同时尝试获取同一把锁时，获取锁的顺序按照线程达到的顺序，而非公平锁则允许线程“插队”。synchronized是非公平锁，而ReentrantLock的默认实现是非公平锁，但是也可以设置为公平锁。CAS操作(CompareAndSwap) 。CAS操作简单的说就是比较并交换。CAS 操作包含三个操作数 —— 内存位置（V）、预期原值（A）和新值(B)。如果内存位置的值与预期原值相匹配，那么处理器会自动将该位置值更新为新值。否则，处理器不做任何操作。无论哪种情况，它都会在 CAS 指令之前返回该位置的值。CAS 有效地说明了“我认为位置 V 应该包含值 A；如果包含该值，则将 B 放到这个位置；否则，不要更改该位置，只告诉我这个位置现在的值即可。”
当线程尝试获取锁的时候，如果获取不到锁会一直阻塞。 如果获取锁的线程进入休眠或者阻塞，除非当前线程异常，否则其他线程尝试获取锁必须一直等待。
**lock ()**, 如果获取了锁立即返回，如果别的线程持有锁，当前线程则一直处于休眠状态，直到获取锁tryLock() , 如果获取了锁立即返回true，如果别的线程正持有锁，立即返回false；tryLock(long timeout,TimeUnit unit)** ，如果获取了锁定立即返回true，如果别的线程正持有锁，会等待参数给定的时间，在等待的过程中，如果获取了锁定，就返回true，如果等待超时，返回false；lockInterruptibly :如果获取了锁定立即返回，如果没有获取锁定，当前线程处于休眠状态，直到或者锁定，或者当前线程被别的线程中断
ReentrantLock 一些特性
等待可中断避免，出现死锁的情况 （如果别的线程正持有锁，会等待参数给定的时间，在等待的过程中，如果获取了锁定，就返回true，如果等待超时，返回false）公平锁与非公平锁 多个线程等待同一个锁时，必须按照申请锁的时间顺序获得锁，Synchronized锁非公平锁，ReentrantLock默认的构造函数是创建的非公平锁，可以通过参数true设为公平锁 ，但公平锁表现的性能不是很好。
公平锁：线程获取锁的顺序和调用lock的顺序一样，FIFO；Java并发包(java.util.concurrent)中大量使用了CAS操作,涉及到并发的地方都调用了sun.misc.Unsafe类方法进行CAS操作 。
简单来说，ReenTrantLock的实现是一种自旋锁，通过循环调用CAS操作来实现加锁 。它的性能比较好也是因为避免了使线程进入内核态的阻塞状态。想尽办法避免线程进入内核的阻塞状态是我们去分析和理解锁设计的关键钥匙。
在Synchronized优化以前，synchronized的性能是比ReenTrantLock差很多的，但是自从Synchronized引入了偏向锁，轻量级锁（自旋锁）后，两者的性能就差不多了，在两种方法都可用的情况下，官方甚至建议使用synchronized，其实synchronized的优化我感觉就借鉴了ReenTrantLock中的CAS技术。都是试图在用户态就把加锁问题解决，避免进入内核态的线程阻塞。synchronized ：ReentrantLock :使用非公平锁是基于性能考虑 ，公平锁为了保证线程规规矩矩地排队，需要增加阻塞和唤醒的时间开销。如果直接插队获取非公平锁，跳过了对队列的处理，速度会更快。ReentrantLock实现原理 https://www.cnblogs.com/maypattis/p/6403682.html 分析ReentrantLock的实现原理 (ReentrantLock和同步工具类的实现基础都是AQS)https://www.jianshu.com/p/fe027772e156
Semaphore就是一个信号量，它的作用是限制某段代码块的并发数 。 Semaphore有一个构造函数，可以传入一个int型整数n，表示某段代码最多只有n个线程可以访问 ， 如果超出了n，那么请等待，等到某个线程执行完毕这段代码块，下一个线程再进入 。由此可以看出如果Semaphore构造函数中传入的int型整数n=1，相当于变成了一个synchronized了。
Semaphore类位于java.util.concurrent包下，它提供了2个构造器：
Semaphore类中比较重要的几个方法，首先是acquire()、release()方法： acquire()用来获取一个许可，若无许可能够获得，则会一直等待，直到获得许可。 release()用来释放许可。注意，在释放许可之前，必须先获获得许可。
Semaphore类中比较重要的几个方法，首先是acquire()、release()方法：
假若一个工厂有5台机器，但是有8个工人，一台机器同时只能被一个工人使用，只有使用完了，其他工人才能继续使用。那么我们就可以通过Semaphore来实现： new Worker(i,semaphore).start();
Lock接口比同步方法和同步块提供了更具扩展性的锁操作。他们允许更灵活的结构，可以具有完全不同的性质，并且可以支持多个相关类的条件对象。
可以使锁更公平 可以使线程在等待锁的时候响应中断 可以让线程尝试获取锁，并在无法获取锁的时候立即返回或者等待一段时间 可以在不同的范围，以不同的顺序获取和释放锁
同一时间只能有一条线程执行固定类的同步方法，但是对于类的非同步方法，可以多条线程同时访问。所以，这样就有问题了，可能线程A在执行Hashtable的put方法添加数据，线程B则可以正常调用size()方法读取Hashtable中当前元素的个数，那读取到的值可能不是最新的，可能线程A添加了完了数据，但是没有对size++，线程B就已经读取size了，那么对于线程B来说读取到的size一定是不准确的。而给size()方法加了同步之后，意味着线程B调用size()方法只有在线程A调用put方法完毕之后才可以调用，这样就保证了线程安全性
ConcurrentHashMap的并发度就是segment的大小，默认为16，这意味着最多同时可以有16条线程操作ConcurrentHashMap，这也是ConcurrentHashMap对Hashtable的最大优势
Lock比传统线程模型中的synchronized方式更加面向对象，与生活中的锁类似，锁本身也应该是一个对象。两个线程执行的代码片段要实现同步互斥的效果，它们必须用同一个Lock对象。读写锁 ：分为读锁和写锁，多个读锁不互斥，读锁与写锁互斥，这是由jvm自己控制的，你只要上好相应的锁即可 。如果你的代码只读数据，可以很多人同时读，但不能同时写，那就上读锁 ；ReentrantReadWriteLock会使用两把锁来解决问题，一个读锁，一个写锁 线程进入读锁的前提条件 ：
没有其他线程的写锁
没有写请求或者有写请求，但调用线程和持有锁的线程是同一个
线程进入写锁的前提条件 ：
没有其他线程的读锁 没有其他线程的写锁 读锁的重入是允许多个申请读操作的线程的，而写锁同时只允许单个线程占有，该线程的写操作可以重入。 如果一个线程占有了写锁，在不释放写锁的情况下，它还能占有读锁，即写锁降级为读锁。 对于同时占有读锁和写锁的线程，如果完全释放了写锁，那么它就完全转换成了读锁，以后的写操作无法重入，在写锁未完全释放时写操作是可以重入的。 公平模式下无论读锁还是写锁的申请都必须按照AQS锁等待队列先进先出的顺序。非公平模式下读操作插队的条件是锁等待队列head节点后的下一个节点是SHARED型节点，写锁则无条件插队。 读锁不允许newConditon获取Condition接口，而写锁的newCondition接口实现方法同ReentrantLock。
只读数据，可以很多人同时读，但不能同时写，那就上读锁 ；ReentrantReadWriteLock会使用两把锁来解决问题，一个读锁，一个写锁 线程进入读锁的前提条件 ：
没有其他线程的写锁 没有写请求或者有写请求，但调用线程和持有锁的线程是同一个
线程进入写锁的前提条件 ：
没有其他线程的读锁 没有其他线程的写锁 读锁的重入是允许多个申请读操作的线程的，而写锁同时只允许单个线程占有，该线程的写操作可以重入。 如果一个线程占有了写锁，在不释放写锁的情况下，它还能占有读锁，即写锁降级为读锁。 对于同时占有读锁和写锁的线程，如果完全释放了写锁，那么它就完全转换成了读锁，以后的写操作无法重入，在写锁未完全释放时写操作是可以重入的。 公平模式下无论读锁还是写锁的申请都必须按照AQS锁等待队列先进先出的顺序。非公平模式下读操作插队的条件是锁等待队列head节点后的下一个节点是SHARED型节点，写锁则无条件插队。 读锁不允许newConditon获取Condition接口，而写锁的newCondition接口实现方法同ReentrantLock。
image
