├── README.md
├── .idea
    ├── vcs.xml
    ├── modules.xml
    ├── misc.xml
    └── workspace.xml
├── src
    ├── chapter4
    │   ├── ThreadPool.java
    │   ├── SleepUtils.java
    │   ├── MultiThread.java
    │   ├── Profiler.java
    │   ├── ConnectionDriver.java
    │   ├── Join.java
    │   ├── Interrupted.java
    │   ├── ConnectionPool.java
    │   ├── WaitNotify.java
    │   ├── PoolTest.java
    │   ├── chapter4.md
    │   └── DefaultThreadPool.java
    ├── chapter7
    │   └── chapter7.md
    ├── chapter3
    │   ├── ReentrantLockExample.java
    │   └── chapter3.md
    ├── chapter1
    │   ├── chapter1.md
    │   └── DeadLockDemo.java
    ├── chapter9
    │   └── chapter9.md
    ├── chapter5
    │   ├── Cache.java
    │   ├── TwinsLockTest.java
    │   ├── Mutex.java
    │   ├── TwinsLock.java
    │   └── chapter5.md
    ├── chapter6
    │   ├── CountTask.java
    │   └── chapter6.md
    └── chapter2
    │   ├── Counter.java
    │   └── chapter2.md
└── Java_concurrent.iml


/README.md:
--------------------------------------------------------------------------------
1 | # java_concurrent_art
2 | java并发编程的艺术  笔记
3 | 
4 | 整理了一下初读java并发编程艺术一书的个人认为的重点，方便回顾。
5 | 


--------------------------------------------------------------------------------
/.idea/vcs.xml:
--------------------------------------------------------------------------------
1 | <?xml version="1.0" encoding="UTF-8"?>
2 | <project version="4">
3 |   <component name="VcsDirectoryMappings">
4 |     <mapping directory="$PROJECT_DIR$/../Java_concurrent" vcs="Git" />
5 |   </component>
6 | </project>


--------------------------------------------------------------------------------
/.idea/modules.xml:
--------------------------------------------------------------------------------
1 | <?xml version="1.0" encoding="UTF-8"?>
2 | <project version="4">
3 |   <component name="ProjectModuleManager">
4 |     <modules>
5 |       <module fileurl="file://$PROJECT_DIR$/Java_concurrent.iml" filepath="$PROJECT_DIR$/Java_concurrent.iml" />
6 |     </modules>
7 |   </component>
8 | </project>


--------------------------------------------------------------------------------
/src/chapter4/ThreadPool.java:
--------------------------------------------------------------------------------
 1 | package chapter4;
 2 | 
 3 | /**
 4 |  * Created by xdcao on 2017/5/4.
 5 |  */
 6 | public interface ThreadPool<Job extends Runnable> {
 7 | 
 8 |     void execute(Job job);
 9 | 
10 |     void shutDown();
11 | 
12 |     void addWorkers(int num);
13 | 
14 |     void removeWorker(int num);
15 | 
16 |     int getJobSize();
17 | 
18 | }
19 | 


--------------------------------------------------------------------------------
/src/chapter4/SleepUtils.java:
--------------------------------------------------------------------------------
 1 | package chapter4;
 2 | 
 3 | import java.util.concurrent.TimeUnit;
 4 | 
 5 | /**
 6 |  * Created by xdcao on 2017/5/3.
 7 |  */
 8 | public class SleepUtils {
 9 | 
10 |     public static final void second(long seconds){
11 |         try {
12 |             TimeUnit.SECONDS.sleep(seconds);
13 |         }catch (InterruptedException e){
14 | 
15 |         }
16 |     }
17 | 
18 | }
19 | 


--------------------------------------------------------------------------------
/Java_concurrent.iml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="UTF-8"?>
 2 | <module type="JAVA_MODULE" version="4">
 3 |   <component name="NewModuleRootManager" inherit-compiler-output="true">
 4 |     <exclude-output />
 5 |     <content url="file://$MODULE_DIR$/../Java_concurrent">
 6 |       <sourceFolder url="file://$MODULE_DIR$/../Java_concurrent/src" isTestSource="false" />
 7 |     </content>
 8 |     <orderEntry type="inheritedJdk" />
 9 |     <orderEntry type="sourceFolder" forTests="false" />
10 |   </component>
11 | </module>


--------------------------------------------------------------------------------
/src/chapter7/chapter7.md:
--------------------------------------------------------------------------------
 1 | #第七章 Java中的13个原子操作类
 2 | 
 3 | 包含4种类型的原子更新方式：原子更新基本类型、原子更新数组、原子更新引用、原子更新属性（字段）
 4 | 
 5 | ##一、原子更新基本类型
 6 | 
 7 | AtomicBoolean,AtomicInteger,AtomicLong
 8 | 
 9 | 其实就是用CAS实现，也可以采取源码中的思路自己写char、float、double的原子类
10 | 
11 | ##二、原子更新数组
12 | 
13 | AtomicLongArray,AtomicReferenceArray,AtomicIntegerArray
14 | 
15 | 注意：上述三种会将传入的数组复制一份，当其对内部的数组进行修改时，不会影响到传入的数组
16 | 
17 | ##三、原子更新引用类型
18 | 
19 | AtomicReference,AtomicReferenceFieldUpdater,AtomicMarkableReference
20 | 
21 | ##四、原子更新字段类
22 | 
23 | 创建更新器、
24 | 
25 | 更新类的字段必须使用volatile
26 | 
27 | AtomicIntegerFieldUpdater,AtomicLongfieldUpdater,AtomicStampedReference


--------------------------------------------------------------------------------
/src/chapter4/MultiThread.java:
--------------------------------------------------------------------------------
 1 | package chapter4;
 2 | 
 3 | import java.lang.management.ManagementFactory;
 4 | import java.lang.management.ThreadInfo;
 5 | import java.lang.management.ThreadMXBean;
 6 | 
 7 | /**
 8 |  * Created by xdcao on 2017/5/3.
 9 |  */
10 | public class MultiThread {
11 | 
12 |     public static void main(String[] args){
13 | 
14 |         ThreadMXBean threadMXBean= ManagementFactory.getThreadMXBean();
15 |         ThreadInfo[] threadInfos=threadMXBean.dumpAllThreads(false,false);
16 |         for (ThreadInfo threadInfo:threadInfos){
17 |             System.out.println("["+threadInfo.getThreadId()+"]"+threadInfo.getThreadName());
18 |         }
19 | 
20 |     }
21 | 
22 | }
23 | 


--------------------------------------------------------------------------------
/src/chapter3/ReentrantLockExample.java:
--------------------------------------------------------------------------------
 1 | package chapter3;
 2 | 
 3 | import java.util.SplittableRandom;
 4 | import java.util.concurrent.locks.ReentrantLock;
 5 | 
 6 | /**
 7 |  * Created by xdcao on 2017/5/2.
 8 |  */
 9 | public class ReentrantLockExample {
10 | 
11 |     int a=0;
12 | 
13 |     ReentrantLock lock=new ReentrantLock();
14 | 
15 |     public void writer(){
16 |         lock.lock();
17 |         try {
18 |             a++;
19 |         }finally {
20 |             lock.unlock();
21 |         }
22 |     }
23 | 
24 | 
25 |     public static void main(String[] args){
26 |         ReentrantLockExample reentrantLockExample=new ReentrantLockExample();
27 |         reentrantLockExample.writer();
28 |     }
29 | 
30 | 
31 | }
32 | 


--------------------------------------------------------------------------------
/.idea/misc.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="UTF-8"?>
 2 | <project version="4">
 3 |   <component name="ProjectRootManager" version="2" languageLevel="JDK_1_8" default="true" project-jdk-name="1.8" project-jdk-type="JavaSDK">
 4 |     <output url="file://$PROJECT_DIR$/../Java_concurrent/out" />
 5 |   </component>
 6 |   <component name="masterDetails">
 7 |     <states>
 8 |       <state key="ProjectJDKs.UI">
 9 |         <settings>
10 |           <last-edited>1.8</last-edited>
11 |           <splitter-proportions>
12 |             <option name="proportions">
13 |               <list>
14 |                 <option value="0.2" />
15 |               </list>
16 |             </option>
17 |           </splitter-proportions>
18 |         </settings>
19 |       </state>
20 |     </states>
21 |   </component>
22 | </project>


--------------------------------------------------------------------------------
/src/chapter1/chapter1.md:
--------------------------------------------------------------------------------
 1 | #第一章 并发编程的挑战
 2 | 
 3 | ##一、上下文切换
 4 | 
 5 | 即使是单核处理器也支持多线程执行代码，CPU通过给每个线程分配CPU时间片（一般为几十毫秒）实现这个机制。
 6 | 
 7 | 当前任务执行一个时间片后会切换到下一个任务。在切换前会保存上一个任务的状态，以便下次
 8 | 切换回这个任务时，可以再加载这个任务的状态。任务从保存到再加载的过程就是一次上下文切换。
 9 | 
10 | >如何减少上下文切换？
11 | >1. 无锁并发编程。多线程竞争锁时，会引起上下文切换，可以用一些办法避免使用锁，如将数据
12 | 的id取模分段，不同的线程处理不同段的数据
13 | >2. CAS算法：Java的Atomic包使用CAS算法来更新数据，不需要加锁
14 | >3. 使用最少线程，避免创建不需要的线程
15 | >4. 在单线程里实现多任务的调度，并在单线程里维持多个任务间的切换
16 | 
17 | ##二、死锁
18 | 
19 | 避免死锁的几个常见方法：
20 | 
21 | 1. 避免一个线程获取多个锁
22 | 2. 避免一个线程在锁内同时占用多个资源，尽量保证每个锁只占用一个资源
23 | 3. 尝试使用定时锁，使用lock.tryLock(timeout)来替代使用内部锁机制
24 | 4. 对于数据库锁，加锁和解锁必须在一个数据库连接里，否则会出现解锁失败的情况
25 | 
26 | ##三、资源限制的挑战
27 | 
28 | 问题：如果将某段串行的代码并发执行，因为受限于资源，仍然在串行执行，这时候程序不仅不会加快执行，
29 | 反而会更慢，因为增加了上下文切换和资源调度的时间。
30 | 
31 | 如何解决：
32 | 
33 | >对于硬件资源的限制，使用机群并行执行程序，通过搭建服务器集群，不同的机器处理不同的数据
34 | 
35 | >对于软件资源的限制，可以考虑使用资源池将资源复用
36 | 
37 | 根据不同的资源限制调整程序的并发度
38 | 


--------------------------------------------------------------------------------
/src/chapter4/Profiler.java:
--------------------------------------------------------------------------------
 1 | package chapter4;
 2 | 
 3 | import java.util.concurrent.TimeUnit;
 4 | 
 5 | /**
 6 |  * Created by xdcao on 2017/5/4.
 7 |  */
 8 | public class Profiler {
 9 | 
10 |     private static final ThreadLocal<Long> TIME_THREADLOCAL=new ThreadLocal<Long>(){
11 |         @Override
12 |         protected Long initialValue() {
13 |             return System.currentTimeMillis();
14 |         }
15 |     };
16 | 
17 |     public static final void begin(){
18 |         TIME_THREADLOCAL.set(System.currentTimeMillis());
19 |     }
20 | 
21 |     public static final Long end(){
22 |         return System.currentTimeMillis()-TIME_THREADLOCAL.get();
23 |     }
24 | 
25 | 
26 |     public static void main(String[] args) throws InterruptedException {
27 |         Profiler.begin();
28 |         TimeUnit.SECONDS.sleep(1);
29 |         System.out.println("Cost "+Profiler.end());
30 |     }
31 | 
32 | }
33 | 


--------------------------------------------------------------------------------
/src/chapter4/ConnectionDriver.java:
--------------------------------------------------------------------------------
 1 | package chapter4;
 2 | 
 3 | import java.lang.reflect.InvocationHandler;
 4 | import java.lang.reflect.Method;
 5 | import java.lang.reflect.Proxy;
 6 | import java.sql.Connection;
 7 | import java.util.concurrent.TimeUnit;
 8 | 
 9 | /**
10 |  * Created by xdcao on 2017/5/4.
11 |  */
12 | public class ConnectionDriver {
13 | 
14 |     static class ConnectionHandler implements InvocationHandler{
15 |         @Override
16 |         public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
17 |             if(method.getName().equals("commit")){
18 |                 TimeUnit.MILLISECONDS.sleep(100);
19 |             }
20 |             return null;
21 |         }
22 |     }
23 | 
24 |     public static Connection createConnection() {
25 | 
26 |         return (Connection) Proxy.newProxyInstance(ConnectionDriver.class.getClassLoader(),new Class<?>[] {Connection.class},new ConnectionHandler());
27 | 
28 |     }
29 | }
30 | 


--------------------------------------------------------------------------------
/src/chapter9/chapter9.md:
--------------------------------------------------------------------------------
 1 | #第9章 Java中的线程池
 2 | 
 3 | 带来的好处：
 4 |     
 5 |     1.降低资源消耗：通过重复利用已创建的线程降低线程创建和销毁造成的消耗
 6 |     2.提高响应速度：任务到达时，任务可以不需要等到线程创建就能立即执行
 7 |     3.提高线程的可管理性
 8 |     
 9 | ##一、实现原理
10 | 
11 | 提交一个新任务到线程池，处理流程：
12 | 
13 |     1.判断核心线程池里的线程是否都在执行任务。如果不是，则创建一个新的工作线程执行任务。如果是，则进入2
14 |     2.判断工作队列是否已满，如果工作队列没有满，则将新提交的任务存储在这个工作队列里。如果工作队列满，进入3
15 |     3.判断线程池的线程是否都处于工作状态。如果没有，则创建新的工作线程来执行任务。如果满了，则交给饱和
16 |     策略来处理这个任务。
17 |     
18 | 以ThreadPoolExecutor执行execute方法举例，分为4种情况：
19 | 
20 |     1.如果当前运行线程数少于corePoolSize，则创建新线程来执行任务
21 |     2.如果运行的线程等于或多余corePoolSize，则将任务加入BlockingQueue
22 |     3.如果BlockingQueue已满，则创建新的线程来处理任务
23 |     4.如果创建新线程将使当前运行的线程超出maximumPoolSize，任务将被拒绝，并调用对应的策略
24 |     
25 | 工作线程：线程池创建线程时，会将线程封装成工作线程Worker，Worker在执行完任务后，还会循环获取工作队列里
26 | 的任务来执行。
27 | 
28 | ##二、线程池的使用
29 | 
30 | 用ThreadPoolExecutor来创建
31 | 
32 | corePoolSize：线程池的基本大小：当提交一个任务到线程池时，线程池会创建一个线程执行任务，
33 | 即使其他空闲的基本线程能够执行新任务也会创建线程，等到需要执行的任务数大于线程池基本大小
34 | 时就不再继续创建。
35 | 
36 | 提交任务：execute提交不需要返回值得任务，submit提交需要返回值的
37 | 
38 | 


--------------------------------------------------------------------------------
/src/chapter4/Join.java:
--------------------------------------------------------------------------------
 1 | package chapter4;
 2 | 
 3 | import java.util.concurrent.TimeUnit;
 4 | 
 5 | /**
 6 |  * Created by xdcao on 2017/5/4.
 7 |  */
 8 | public class Join {
 9 | 
10 |     static class Domino implements Runnable{
11 | 
12 |         private Thread thread;
13 | 
14 |         private Domino(Thread thread){
15 |             this.thread=thread;
16 |         }
17 | 
18 |         @Override
19 |         public void run() {
20 |             try {
21 |                 thread.join();
22 |             }catch (InterruptedException e){
23 | 
24 |             }
25 |             System.out.println(Thread.currentThread().getName()+" terminate.");
26 |         }
27 |     }
28 | 
29 |     public static void main(String[] args) throws Exception{
30 | 
31 |         Thread previous=Thread.currentThread();
32 |         for(int i=0;i<10;i++){
33 |             Thread thread=new Thread(new Domino(previous),String.valueOf(i));
34 |             thread.start();
35 |             previous=thread;
36 |         }
37 |         TimeUnit.SECONDS.sleep(5);
38 |         System.out.println(Thread.currentThread().getName()+" terminate.");
39 | 
40 |     }
41 | 
42 | 
43 | }
44 | 


--------------------------------------------------------------------------------
/src/chapter1/DeadLockDemo.java:
--------------------------------------------------------------------------------
 1 | package chapter1;
 2 | 
 3 | import jdk.nashorn.internal.runtime.ECMAErrors;
 4 | 
 5 | /**
 6 |  * Created by xdcao on 2017/4/28.
 7 |  */
 8 | public class DeadLockDemo {
 9 | 
10 |     private static String A="A";
11 |     private static String B="B";
12 | 
13 |     public static void main(String[] args){
14 |         new DeadLockDemo().deadLocak();
15 |     }
16 | 
17 |     private void deadLocak(){
18 | 
19 |         Thread th1=new Thread(() -> {
20 |             synchronized (A){
21 |                 try {
22 |                     Thread.currentThread().sleep(2000);
23 |                 }catch (Exception e){
24 |                     e.printStackTrace();
25 |                 }
26 |                 synchronized (B){
27 |                     System.out.println(1);
28 |                 }
29 |             }
30 |         });
31 | 
32 |         Thread th2=new Thread(() -> {
33 |             synchronized (B){
34 |                 synchronized (A){
35 |                     System.out.println(2);
36 |                 }
37 |             }
38 |         });
39 | 
40 |         th1.start();
41 |         th2.start();
42 | 
43 |     }
44 | 
45 | }
46 | 


--------------------------------------------------------------------------------
/src/chapter5/Cache.java:
--------------------------------------------------------------------------------
 1 | package chapter5;
 2 | 
 3 | import java.util.HashMap;
 4 | import java.util.Map;
 5 | import java.util.concurrent.locks.Lock;
 6 | import java.util.concurrent.locks.ReentrantReadWriteLock;
 7 | 
 8 | /**
 9 |  * Created by xdcao on 2017/5/18.
10 |  */
11 | public class Cache {
12 | 
13 |     static Map<String,Object> map=new HashMap<String,Object>();
14 |     static ReentrantReadWriteLock rwl=new ReentrantReadWriteLock();
15 |     static Lock r=rwl.readLock();
16 |     static Lock w=rwl.writeLock();
17 | 
18 |     public static final Object get(String key){
19 |         r.lock();
20 |         try {
21 |             return map.get(key);
22 |         }finally {
23 |             r.unlock();
24 |         }
25 |     }
26 | 
27 |     public static final Object put(String key,Object value){
28 |         w.lock();
29 |         try {
30 |             return map.put(key,value);
31 |         }finally {
32 |             w.unlock();
33 |         }
34 |     }
35 | 
36 |     public static final void clear(){
37 |         w.lock();
38 |         try {
39 |             map.clear();
40 |         }finally {
41 |             w.unlock();
42 |         }
43 |     }
44 | 
45 | 
46 | }
47 | 


--------------------------------------------------------------------------------
/src/chapter5/TwinsLockTest.java:
--------------------------------------------------------------------------------
 1 | package chapter5;
 2 | 
 3 | import chapter4.SleepUtils;
 4 | 
 5 | import java.util.concurrent.locks.Lock;
 6 | 
 7 | /**
 8 |  * Created by xdcao on 2017/5/8.
 9 |  */
10 | public class TwinsLockTest {
11 | 
12 |     public static void main(String[] args){
13 | 
14 |         final Lock lock=new TwinsLock();
15 | 
16 |         class Worker extends Thread{
17 |             @Override
18 |             public void run() {
19 |                 while (true){
20 |                     lock.lock();
21 |                     try {
22 |                         SleepUtils.second(1);
23 |                         System.out.println(Thread.currentThread().getName());
24 |                         SleepUtils.second(1);
25 |                     }finally {
26 |                         lock.unlock();
27 |                     }
28 |                 }
29 |             }
30 |         }
31 | 
32 |         for(int i=0;i<10;i++){
33 |             Worker worker=new Worker();
34 |             worker.setDaemon(true);
35 |             worker.start();
36 |         }
37 | 
38 |         for (int i=0;i<10;i++){
39 |             SleepUtils.second(1);
40 |             System.out.println();
41 |         }
42 | 
43 | 
44 |     }
45 | 
46 | }
47 | 


--------------------------------------------------------------------------------
/src/chapter4/Interrupted.java:
--------------------------------------------------------------------------------
 1 | package chapter4;
 2 | 
 3 | import java.util.concurrent.TimeUnit;
 4 | 
 5 | /**
 6 |  * Created by xdcao on 2017/5/3.
 7 |  */
 8 | public class Interrupted {
 9 | 
10 |     static class SleepRunner implements Runnable{
11 | 
12 |         @Override
13 |         public void run() {
14 |             while (true){
15 |                 SleepUtils.second(10);
16 |             }
17 |         }
18 |     }
19 | 
20 |     static class BusyRunner implements Runnable{
21 | 
22 |         @Override
23 |         public void run() {
24 |             while (true){
25 | 
26 |             }
27 |         }
28 |     }
29 | 
30 | 
31 |     public static void main(String[] args) throws Exception{
32 | 
33 |         Thread sleepThread=new Thread(new SleepRunner(),"SleepThread");
34 |         sleepThread.setDaemon(true);
35 | 
36 |         Thread busyThread=new Thread(new BusyRunner(),"BusyRunner");
37 |         busyThread.setDaemon(true);
38 | 
39 |         sleepThread.start();
40 |         busyThread.start();
41 | 
42 |         TimeUnit.SECONDS.sleep(5);
43 |         sleepThread.interrupt();
44 |         busyThread.interrupt();
45 | 
46 |         System.out.println("SleepThread interrupted is "+sleepThread.isInterrupted());
47 |         System.out.println("BusyThread interrupted is "+busyThread.isInterrupted());
48 | 
49 |         SleepUtils.second(2);
50 | 
51 |     }
52 | 
53 | 
54 | 
55 | }
56 | 


--------------------------------------------------------------------------------
/src/chapter6/CountTask.java:
--------------------------------------------------------------------------------
 1 | package chapter6;
 2 | 
 3 | import java.util.concurrent.ForkJoinPool;
 4 | import java.util.concurrent.Future;
 5 | import java.util.concurrent.RecursiveTask;
 6 | 
 7 | /**
 8 |  * Created by xdcao on 2017/5/21.
 9 |  */
10 | public class CountTask extends RecursiveTask<Integer> {
11 | 
12 |     private static final int THRESHOLD=2;
13 | 
14 |     private int start;
15 |     private int end;
16 | 
17 |     public CountTask(int start, int end) {
18 |         this.start = start;
19 |         this.end = end;
20 |     }
21 | 
22 |     @Override
23 |     protected Integer compute() {
24 | 
25 |         int sum=0;
26 |         boolean canCompute=(end-start)<=THRESHOLD;
27 |         if (canCompute) {
28 |             for (int i=start;i<=end;i++){
29 |                 sum+=i;
30 |             }
31 |         }else {
32 |             int middle=(start+end)/2;
33 |             CountTask leftTask=new CountTask(start,middle);
34 |             CountTask rightTask=new CountTask(middle+1,end);
35 |             leftTask.fork();
36 |             rightTask.fork();
37 |             int leftResult=leftTask.join();
38 |             int rightResult=rightTask.join();
39 |             sum=leftResult+rightResult;
40 |         }
41 |         return sum;
42 | 
43 |     }
44 | 
45 |     public static void main(String[] args){
46 |         ForkJoinPool forkJoinPool=new ForkJoinPool();
47 |         CountTask countTask=new CountTask(1,4);
48 |         Future<Integer> result=forkJoinPool.submit(countTask);
49 |         try {
50 |             System.out.println(result.get());
51 |         }catch (Exception e){
52 | 
53 |         }
54 |     }
55 | 
56 | }
57 | 


--------------------------------------------------------------------------------
/src/chapter4/ConnectionPool.java:
--------------------------------------------------------------------------------
 1 | package chapter4;
 2 | 
 3 | import java.sql.Connection;
 4 | import java.util.LinkedList;
 5 | 
 6 | /**
 7 |  * Created by xdcao on 2017/5/4.
 8 |  */
 9 | public class ConnectionPool {
10 | 
11 |     private LinkedList<Connection> pool=new LinkedList<>();
12 | 
13 |     public ConnectionPool(int initialSize){
14 |         if(initialSize>0){
15 |             for (int i=0;i<initialSize;i++){
16 |                 pool.addLast(ConnectionDriver.createConnection());
17 |             }
18 |         }
19 |     }
20 | 
21 |     public void releaseConnection(Connection connection){
22 | 
23 |         if(connection!=null){
24 |             synchronized (pool){
25 |                 pool.addLast(connection);
26 |                 pool.notifyAll();
27 |             }
28 |         }
29 |     }
30 | 
31 |     public Connection fetchConnection(long mills) throws InterruptedException{
32 |         synchronized (pool){
33 |             if(mills<=0){
34 |                 while (pool.isEmpty()){
35 |                     pool.wait();
36 |                 }
37 |                 return pool.removeFirst();
38 |             }else {
39 |                 long future=System.currentTimeMillis()+mills;
40 |                 long remaining=mills;
41 |                 while (pool.isEmpty()&&remaining>0){
42 |                     pool.wait(remaining);
43 |                     remaining=future=System.currentTimeMillis();
44 |                 }
45 |                 Connection result=null;
46 |                 if(!pool.isEmpty()){
47 |                     result=pool.removeFirst();
48 |                 }
49 |                 return result;
50 |             }
51 |         }
52 |     }
53 | 
54 | }
55 | 


--------------------------------------------------------------------------------
/src/chapter2/Counter.java:
--------------------------------------------------------------------------------
 1 | package chapter2;
 2 | 
 3 | import java.util.ArrayList;
 4 | import java.util.List;
 5 | import java.util.concurrent.atomic.AtomicInteger;
 6 | 
 7 | /**
 8 |  * Created by xdcao on 2017/5/1.
 9 |  */
10 | public class Counter {
11 | 
12 |     private AtomicInteger atomicInteger=new AtomicInteger(0);
13 |     private int i=0;
14 | 
15 |     private void safeCount(){
16 |         for (;;){
17 |             int i=atomicInteger.get();
18 |             boolean suc=atomicInteger.compareAndSet(i,++i);
19 |             if (suc){
20 |                 break;
21 |             }
22 |         }
23 |     }
24 | 
25 |     private void count(){
26 |         i++;
27 |     }
28 | 
29 |     public static void main(String[] args){
30 | 
31 |         final Counter cas=new Counter();
32 |         List<Thread> ts=new ArrayList<>(600);
33 |         long start=System.currentTimeMillis();
34 |         for (int j=0;j<100;j++){
35 |             Thread t=new Thread(new Runnable() {
36 |                 @Override
37 |                 public void run() {
38 |                     for (int i=0;i<10000;i++){
39 |                         cas.count();
40 |                         cas.safeCount();
41 |                     }
42 |                 }
43 |             });
44 |             ts.add(t);
45 |         }
46 |         for (Thread t:ts){
47 |             t.start();
48 |         }
49 |         for (Thread t:ts){
50 |             try {
51 |                 t.join();
52 |             }catch (Exception e){
53 |                 e.printStackTrace();
54 |             }
55 |         }
56 | 
57 |         System.out.println(cas.i);
58 |         System.out.println(cas.atomicInteger.get());
59 |         System.out.println(System.currentTimeMillis()-start);
60 | 
61 |     }
62 | 
63 | }
64 | 


--------------------------------------------------------------------------------
/src/chapter4/WaitNotify.java:
--------------------------------------------------------------------------------
 1 | package chapter4;
 2 | 
 3 | import com.sun.xml.internal.bind.v2.model.annotation.RuntimeAnnotationReader;
 4 | 
 5 | import java.text.SimpleDateFormat;
 6 | import java.util.Date;
 7 | import java.util.concurrent.TimeUnit;
 8 | 
 9 | /**
10 |  * Created by xdcao on 2017/5/4.
11 |  */
12 | public class WaitNotify {
13 | 
14 |     static boolean flag=false;
15 |     static Object lock=new Object();
16 | 
17 |     static class Wait implements Runnable{
18 |         @Override
19 |         public void run() {
20 |             synchronized (lock){
21 |                 while (flag){
22 |                     try {
23 |                         System.out.println(Thread.currentThread()+" flag is true, wait @ "+new SimpleDateFormat("HH:mm:ss").format(new Date()));
24 |                         lock.wait();
25 |                     }catch (InterruptedException e){
26 | 
27 |                     }
28 |                 }
29 |                 System.out.println(Thread.currentThread()+" flag is false, running @ "+new SimpleDateFormat("HH:mm:ss").format(new Date()));
30 |             }
31 |         }
32 |     }
33 | 
34 |     static class Notify implements Runnable{
35 | 
36 |         @Override
37 |         public void run() {
38 |             synchronized (lock){
39 |                 System.out.println(Thread.currentThread()+" hold lock, notify @ "+
40 |                 new SimpleDateFormat("HH:mm:ss").format(new Date()));
41 |                 lock.notifyAll();
42 |                 flag=false;
43 |                 SleepUtils.second(5);
44 |             }
45 | 
46 |             synchronized (lock){
47 |                 System.out.println(Thread.currentThread()+" hold lock again, sleep @ "+
48 |                 new SimpleDateFormat("HH:mm:ss").format(new Date()));
49 |                 SleepUtils.second(5);
50 |             }
51 | 
52 |         }
53 |     }
54 | 
55 |     public static void main(String[] args) throws InterruptedException {
56 |         Thread waitThread=new Thread(new Wait(),"WaitThread");
57 |         waitThread.start();
58 |         TimeUnit.SECONDS.sleep(1);
59 |         Thread notifyThread=new Thread(new Notify(),"NotifyThread");
60 |         notifyThread.start();
61 |     }
62 | 
63 | }
64 | 


--------------------------------------------------------------------------------
/src/chapter5/Mutex.java:
--------------------------------------------------------------------------------
 1 | package chapter5;
 2 | 
 3 | import java.util.concurrent.TimeUnit;
 4 | import java.util.concurrent.locks.AbstractQueuedSynchronizer;
 5 | import java.util.concurrent.locks.Condition;
 6 | import java.util.concurrent.locks.Lock;
 7 | 
 8 | /**
 9 |  * Created by xdcao on 2017/5/5.
10 |  */
11 | public class Mutex implements Lock {
12 | 
13 |     private static class Sync extends AbstractQueuedSynchronizer{
14 | 
15 |         @Override
16 |         protected boolean isHeldExclusively() {
17 |             return getState()==1;
18 |         }
19 | 
20 |         @Override
21 |         protected boolean tryAcquire(int acqiures) {
22 |             if(compareAndSetState(0,1)){
23 |                 setExclusiveOwnerThread(Thread.currentThread());
24 |                 return true;
25 |             }
26 |             return false;
27 |         }
28 | 
29 |         @Override
30 |         protected boolean tryRelease(int releases) {
31 |             if (getState()==0)
32 |                 throw new IllegalMonitorStateException();
33 |             setExclusiveOwnerThread(null);
34 |             setState(0);
35 |             return true;
36 |         }
37 | 
38 |         Condition newCondition(){
39 |             return new ConditionObject();
40 |         }
41 | 
42 |     }
43 | 
44 |     private final Sync sync=new Sync();
45 | 
46 |     @Override
47 |     public void lock() {
48 |         sync.acquire(1);
49 |     }
50 | 
51 |     @Override
52 |     public void lockInterruptibly() throws InterruptedException {
53 |         sync.acquireInterruptibly(1);
54 |     }
55 | 
56 |     @Override
57 |     public boolean tryLock() {
58 |         return sync.tryAcquire(1);
59 |     }
60 | 
61 |     @Override
62 |     public boolean tryLock(long time, TimeUnit unit) throws InterruptedException {
63 |         return sync.tryAcquireNanos(1,unit.toNanos(time));
64 |     }
65 | 
66 |     @Override
67 |     public void unlock() {
68 |         sync.release(1);
69 |     }
70 | 
71 |     @Override
72 |     public Condition newCondition() {
73 |         return sync.newCondition();
74 |     }
75 | 
76 |     public boolean isLocked(){
77 |         return sync.isHeldExclusively();
78 |     }
79 | 
80 |     public boolean hasQueuedThreads(){
81 |         return sync.hasQueuedThreads();
82 |     }
83 | 
84 | }
85 | 


--------------------------------------------------------------------------------
/src/chapter5/TwinsLock.java:
--------------------------------------------------------------------------------
 1 | package chapter5;
 2 | 
 3 | import java.util.concurrent.TimeUnit;
 4 | import java.util.concurrent.locks.AbstractQueuedSynchronizer;
 5 | import java.util.concurrent.locks.Condition;
 6 | import java.util.concurrent.locks.Lock;
 7 | 
 8 | /**
 9 |  * Created by xdcao on 2017/5/8.
10 |  */
11 | public class TwinsLock implements Lock {
12 | 
13 |     private final  Sync sync=new Sync(2);
14 | 
15 |     private static final class Sync extends AbstractQueuedSynchronizer{
16 | 
17 |         Sync(int count){
18 |             if (count<0){
19 |                 throw new IllegalArgumentException("count must larger than 0");
20 |             }
21 |             setState(count);
22 |         }
23 | 
24 |         @Override
25 |         protected int tryAcquireShared(int reduceCount) {
26 |             for (;;){
27 |                 int current=getState();
28 |                 int newCount=current-reduceCount;
29 |                 if(newCount<0||compareAndSetState(current,newCount)){
30 |                     return newCount;
31 |                 }
32 |             }
33 |         }
34 | 
35 |         @Override
36 |         protected boolean tryReleaseShared(int returnCount) {
37 |             for(;;){
38 |                 int current=getState();
39 |                 int newCount=current+returnCount;
40 |                 if (compareAndSetState(current,newCount)){
41 |                     return true;
42 |                 }
43 |             }
44 |         }
45 |     }
46 | 
47 | 
48 |     @Override
49 |     public void lock() {
50 |         sync.acquireShared(1);
51 |     }
52 | 
53 |     @Override
54 |     public void lockInterruptibly() throws InterruptedException {
55 | 
56 |     }
57 | 
58 |     @Override
59 |     public boolean tryLock() {
60 |         int result=sync.tryAcquireShared(1);
61 |         if (result>0&&result<3){
62 |             return true;
63 |         }else {
64 |             return false;
65 |         }
66 |     }
67 | 
68 |     @Override
69 |     public boolean tryLock(long time, TimeUnit unit) throws InterruptedException {
70 |         return false;
71 |     }
72 | 
73 |     @Override
74 |     public void unlock() {
75 |         sync.releaseShared(1);
76 |     }
77 | 
78 |     @Override
79 |     public Condition newCondition() {
80 |         return null;
81 |     }
82 | }
83 | 


--------------------------------------------------------------------------------
/src/chapter4/PoolTest.java:
--------------------------------------------------------------------------------
 1 | package chapter4;
 2 | 
 3 | import java.sql.Connection;
 4 | import java.util.concurrent.CountDownLatch;
 5 | import java.util.concurrent.atomic.AtomicInteger;
 6 | 
 7 | /**
 8 |  * Created by xdcao on 2017/5/4.
 9 |  */
10 | public class PoolTest {
11 | 
12 |     static ConnectionPool pool=new ConnectionPool(10);
13 |     static CountDownLatch start=new CountDownLatch(1);
14 |     static CountDownLatch end;
15 | 
16 |     static class ConnectionRunner implements Runnable{
17 | 
18 |         int count;
19 |         AtomicInteger got;
20 |         AtomicInteger notGot;
21 | 
22 |         public ConnectionRunner(int count, AtomicInteger got, AtomicInteger notGot) {
23 |             this.count = count;
24 |             this.got = got;
25 |             this.notGot = notGot;
26 |         }
27 | 
28 |         @Override
29 |         public void run() {
30 | 
31 |             try {
32 |                 start.await();;
33 |             }catch (Exception e){
34 | 
35 |             }
36 |             while (count>0){
37 |                 try {
38 |                     Connection connection=pool.fetchConnection(1000);
39 |                     if (connection!=null){
40 |                         try {
41 |                             connection.createStatement();
42 |                             connection.commit();
43 |                         }finally {
44 |                             pool.releaseConnection(connection);
45 |                             got.incrementAndGet();
46 |                         }
47 |                     }else {
48 |                         notGot.incrementAndGet();
49 |                     }
50 |                 }catch (Exception e){
51 | 
52 |                 }finally {
53 |                     count--;
54 |                 }
55 |             }
56 |             end.countDown();
57 |         }
58 |     }
59 | 
60 | 
61 |     public static void main(String[] args) throws InterruptedException {
62 |         int threadCount=10;
63 |         end=new CountDownLatch(threadCount);
64 |         int count=20;
65 |         AtomicInteger got=new AtomicInteger();
66 |         AtomicInteger notGot=new AtomicInteger();
67 |         for (int i=0;i<threadCount;i++){
68 |             Thread thread=new Thread(new ConnectionRunner(count,got,notGot),"ConnectionRunnerThread");
69 |             thread.start();
70 |         }
71 |         start.countDown();
72 |         end.await();
73 |         System.out.println("total invoke : "+(threadCount*count));
74 |         System.out.println("got connecion: "+got);
75 |         System.out.println("not got connection: "+notGot);
76 |     }
77 | 
78 | }
79 | 


--------------------------------------------------------------------------------
/src/chapter6/chapter6.md:
--------------------------------------------------------------------------------
  1 | #第六章 Java并发容器和框架
  2 | 
  3 | ##一、ConcurrentHashMap
  4 | 
  5 | ###1.
  6 | 
  7 | 为什么使用：HashMap不安全，HashTable效率低
  8 | 
  9 | >这边得上网查
 10 | 
 11 | HashMap:并发执行put操作时会引起死循环，因为多线程会导致HashMap的Entry链表形成环形数据结构，Entry
 12 | 的next节点永远不为空，就会产生死循环获取Entry
 13 | 
 14 | HashTable:HashTable使用synchronized来保证线程安全，在线程竞争激烈的情况下其效率十分低下
 15 | 
 16 | ConcurrentHashMap：使用锁分段技术：首先将数据分成一段一段地存储，然后给每一段数据配一把锁，
 17 | 当一个线程占用锁访问其中一个段数据的时候，其他段的数据也能被其他线程访问。
 18 | 
 19 | ###2.ConcurrentHashMap的结构
 20 | 
 21 | Segment数组+HashEntry数组
 22 | 
 23 | segment是一种可重入锁，HashEntry用于存储键值对数据
 24 | 
 25 | 一个segment里包含一个HashEntry数组，每个segment守护着一个HashEntry数组里的元素，
 26 | 当对HashEntry数组的数据进行修改时，必须首先获得与它对应的segment锁
 27 | 
 28 | ###3、4初始化和定位segment
 29 | 
 30 | 这里主要讲了hash的散列算法之类的，目前不用去研究
 31 | 
 32 | ###5.ConCurrentHashMap的操作
 33 | 
 34 | （1）get
 35 | 
 36 | 整个get过程不需要加锁，除非读到的值是空的才会加锁重读。
 37 | 
 38 | 做法：get方法里将要使用的共享变量都定义成volatile类型。定义成volatile的变量，能够在线程之间保持可见性，
 39 | 能够被多线程同时读，并且保证不会读到过期的值，但是只能被单线程写。
 40 | 
 41 |     之所以不会读到过期的值，是因为根据java内存模型的happens before原则，
 42 |     对volatile变量的写入操作先于读操作。
 43 |     
 44 | >上面这是用volatile替换锁的经典应用场景。
 45 | 
 46 | （2）put
 47 | 
 48 | 加锁、扩容、定位添加
 49 | 
 50 | （3）size
 51 | 
 52 | 先尝试两次不加锁的统计（直接累加各segment的count），比对modcount变量看是不是发生变化，如果发生变化再通过加锁的方式统计。
 53 | 
 54 | ##二、ConcurrentLinkedQueue
 55 | 
 56 | 实现线程安全的队列两种方式：
 57 | 
 58 | 1.阻塞方式：使用一个锁（入队出队同一个）或两个锁（入队出队不同锁）
 59 | 
 60 | 2.非阻塞方式：使用循环CAS
 61 | 
 62 | ###1.入队
 63 | 
 64 | 入队过程：
 65 | 
 66 | （1）将入队节点设置成当前队列尾节点的下一个节点
 67 | 
 68 | （2）更新tail节点，如果tail节点的next节点不为空，则将入队节点设置成tail节点，
 69 | 如果tail节点的next节点为空，则将入队节点设置成tail的next节点，所以tail节点并不总是尾节点
 70 | 
 71 |     为什么不设计成tail永远是尾节点？
 72 | 
 73 |     这样做每次都需要使用循环cas更新tail节点，而大师的做法可以明显减少循环cas的次数，虽然会
 74 |     增加定位真实尾节点的时间，但是实际开销还是减少了
 75 |     
 76 | ###2.出队
 77 | 
 78 | 并不是每次出队时都更新head节点，当head节点里有元素时，直接弹出head里的元素，而不会更新head节点。
 79 | 只有head节点里没有元素时，出队操作才会更新head节点。这种做法也是通过hops变量来减少使用CAS更新head节点的
 80 | 消耗，从而提高出队效率。
 81 | 
 82 | ##三、Java中的阻塞队列
 83 | 
 84 | 阻塞队列：支持阻塞的插入和移除方法
 85 | 
 86 | （1）支持阻塞的插入方法：当队列满时，队列会阻塞插入元素的线程，直到队列不满
 87 | 
 88 | （2）支持阻塞的移除方法：队列为空时，获取元素的线程会等待队列变为非空
 89 | 
 90 |     抛出异常：add、remove
 91 |     返回特殊值：offer、poll
 92 |     一直阻塞：put、take
 93 |     
 94 | java提供了7种阻塞队列：
 95 | 
 96 | 1. ArrayBlockingQueue
 97 | 
 98 | 数组实现的有界队列，FIFO，默认情况下不保证线程公平的访问队列
 99 | 
100 | 2. LinkedBlockingQueue
101 | 
102 | 用链表实现的有界阻塞队列，FIFO
103 | 
104 | 3. PriorityBlockingQueue
105 | 
106 | 支持优先级的无界阻塞队列，默认情况下元素采取自然顺序升序排列，也可以自定义比较方法来指定元素排列规则
107 | 
108 | 4. DelayQueue
109 | 
110 | 支持延时获取元素的无界阻塞队列。队列使用PriorityQueue来实现。队列中的元素必须实现Delay接口，在创建
111 | 元素时可以指定多久才能从队列中获取当前元素。只有在延迟期满时才能从队列中提取元素。
112 | 
113 | DelayQueue的应用场景：
114 | 
115 |     缓存系统的设计：用DelayQueue保存缓存元素的有效期，使用一个线程循环查询DelqyQueue，一旦能从DelayQueue
116 |     中获取元素，表示缓存有效期到了。
117 |     定时任务调度：使用DelayQueue保存当天将会执行的任务和执行时间，一旦从DelayQueue中获取到任务就开始执行，
118 |     比如TimerQueue就是使用DelayQueue实现的。
119 |     
120 | 5. SynchronousQueue、
121 | 
122 | 不存储元素的阻塞队列。每一个put操作必须等待一个take操作，否则不能继续添加元素。
123 | 
124 | SynchronousQueue可以看做一个传球手，负责把生产者线程处理的数据直接传递给消费者线程，队列本身并不
125 | 存储任何元素，非常适合传递性场景
126 |     
127 | 6. LinkedTransferQueue
128 | 
129 | 由链表结构组成的无界阻塞TransferQueue队列，注意其transfer方法
130 | 
131 | 7. LinkedBlockingDeque
132 | 
133 | 链表结构组成的双向阻塞队列
134 | 
135 | ###阻塞队列的实现
136 | 
137 | 使用通知模式实现（condition）
138 | 
139 | ##四、Fork/Join框架
140 | 
141 | 一个把大任务分割成若干个小任务，最终汇总每个小任务结果后得到大任务结果的框架。
142 | 
143 |     工作窃取算法


--------------------------------------------------------------------------------
/src/chapter4/chapter4.md:
--------------------------------------------------------------------------------
  1 | #第四章 Java并发编程基础
  2 | 
  3 | ##一、线程简介
  4 | 
  5 | 使用多线程的原因：
  6 | 
  7 |     1.更多的处理器核心：一个线程在一个时刻只能运行在一个处理器核心上
  8 |     2.更快的响应时间
  9 |     3.更好的编程模型
 10 |     
 11 | 线程优先级：
 12 | 
 13 | 操作系统基本采用时分的形式调度运行的线程，操作系统会分出一个个时间片，线程会分配到若干时间片，
 14 | 当线程的时间片用完了就会发生线程调度，并等待着下次分配，线程分配到的时间片多少就决定了线程使用
 15 | 处理器资源的多少。
 16 | 
 17 | 线程的状态：6种，在给定的时刻只能处于一种状态
 18 | 
 19 |     NEW：初始状态，线程被构建，但还没有调用start方法
 20 |     RUNNABLE：运行状态，java线程将就绪和运行两种状态统称为运行状态
 21 |     BLOCKED：阻塞状态，表明线程阻塞于锁
 22 |     WAITING：等待状态，等待其他线程的通知或中断
 23 |     TIME_WAITING：超时等待状态，可以在指定的时间自行返回
 24 |     TERMINATED：终止状态，表示当前线程已经执行完毕
 25 |     
 26 | Daemon线程（守护线程）
 27 | 
 28 | 当一个java虚拟机中不存在非守护线程时，虚拟机将会退出。
 29 | 
 30 | ps. 在构建Daemon线程时，不能依靠finally块中的内容来确保执行关闭或清理资源的逻辑
 31 | 
 32 | ##二、启动和终止线程
 33 | 
 34 | 一个新构造的线程对象是由其父线程来进行空间分配的，而子线程的各种属性继承自父线程，同时还会分配一个唯一的ID。
 35 | 
 36 | 启动线程：start方法：当前线程同步告知虚拟机：只要线程规划器空闲，应立即启动调用start方法的线程
 37 | 
 38 | 中断：
 39 | 
 40 | 可以理解为线程的一个标识符属性，它标识一个运行中的线程是否被其他线程进行了中断操作。
 41 | 线程通过isInterrupted（）方法判断是否被中断，也可以调用静态方法Thread.interrupted()
 42 | 对当前的线程中断标识位进行复位。
 43 | 
 44 |     从java的API可以看出，许多声明抛出InterruptedException的方法在抛出这个异常前，java虚拟机会
 45 |     先将该线程的中断标志位清除，然后再抛异常。此时调用isInterrupted返回false
 46 |     
 47 | ##三、线程间通信（重点）
 48 | 
 49 | ###1、volatile和synchronized关键字
 50 | 
 51 |     volatile:告知程序任何对该变量的访问均需要从共享内存中获取，而对他的改变必须同步刷新回主内存，
 52 |     他能保证所有线程对变量访问的可见性。
 53 |     synchronized：确保多个线程在同一个时刻，只能有一个线程处于方法或同步块中，
 54 |     保证了线程对变量访问的可见性和排他性。
 55 |     
 56 | 关于synchronized：本质是对一个对象的监视器（monitor）的获取，而这个获取过程是排他的，也就是同一时刻
 57 | 只能有一个线程获取到有synchronized所保护对象的监视器。任意一个对象都拥有自己的监视器。
 58 | 
 59 |     任意线程对Object的访问，首先要获得Object的监视器。如果获取失败，线程进入同步队列，
 60 |     线程状态变为BLOCKED。当访问Object的前驱（获得了锁的线程）释放了锁，则该释放操作
 61 |     唤醒阻塞在同步队列中的线程，使其重新尝试对监视器的获取。
 62 |     
 63 | ###2、等待/通知机制（生产者-消费者模型）
 64 | 
 65 | 等待/通知机制，是指一个线程A调用了对象O的wait方法进入等待状态，而另一个线程B调用了对象O的notify
 66 | 或notifyall方法，线程A收到通知后从对象O的wait方法返回，进而执行后续操作。
 67 | 
 68 | 注意： 
 69 | 
 70 | （1）使用wait、notify、notifyAll时需要先对调用对象加锁
 71 | 
 72 | （2）调用wait方法后，线程状态由RUNNING变为WAITING，并将当前线程防止到对象的等待队列
 73 | 
 74 | （3）notify或notifyAll方法调用后，等待线程依旧不会从wait返回，需要调用notify或
 75 | notifyAll的线程释放锁之后，等待线程才有机会从wait返回
 76 | 
 77 | （4）notify方法将等待队列中的等待线程从等待队列中移到同步队列中，被移动的线程从WAITING变为BLOCKED
 78 | 
 79 | （5）从wait方法返回的前提是获得了调用对象的锁
 80 | 
 81 |     P101页的图
 82 |     
 83 | ###3、等待/通知经典范式
 84 | 
 85 |     等待方：1.获取对象的锁
 86 |            2.如果条件不满足，那么调用对象的wait方法，被通知后仍要检查条件
 87 |            3.条件满足则执行对应的逻辑
 88 |            
 89 |             伪代码：
 90 |                    synchronized(对象){
 91 |                         while(条件不满足){
 92 |                             对象.wait();
 93 |                         }
 94 |                         对应的处理逻辑
 95 |                    }
 96 |     
 97 |     通知方：1.获得对象的锁
 98 |             2.改变条件
 99 |            3.通知所有等待在对象上的线程
100 |            
101 |            伪代码：
102 |                    synchronized(对象){
103 |                         改变条件
104 |                         对象.notify();
105 |                    }
106 |     
107 | ###4、管道输入输出流
108 | 
109 | PipedOutputStream、PipedInputStream(字节数据)
110 | 
111 | PipedReader、PipedWriter(字符)
112 | 
113 | 对于piped类型的流，使用时必须先调用connect方法进行绑定，否则会抛出异常
114 | 
115 | ###5、Thread.join()
116 | 
117 | 含义：当前线程等待thread线程终止之后才从thread.join返回。
118 | 另外还有两个join(long millis)具备超时特性的方法（如果线程在给定的时间内没有终止，那么将会从该超时方法返回）。
119 | 
120 | ###6、ThreadLocal
121 | 
122 | ##四、应用实例
123 | 
124 | 
125 | 


--------------------------------------------------------------------------------
/src/chapter5/chapter5.md:
--------------------------------------------------------------------------------
  1 | #第五章 java中的锁（使用与实现）
  2 | 
  3 | ##一、Lock接口
  4 | 
  5 | 提供了synchronized不具有的特性：
  6 | 
  7 |     1.尝试非阻塞地获取锁：tryLock()，调用方法后立刻返回
  8 |     2.能被中断地获取锁：lockInterruptibly():在锁的获取中可以中断当前线程
  9 |     3.超时获取锁:tryLock(time,unit)，超时返回
 10 |     
 11 | Lock接口的实现基本都是通过聚合了一个同步器的子类来完成线程访问控制的。
 12 |     
 13 | ##二、队列同步器
 14 |     
 15 | 队列同步器AbstractQueuedSynchronizer是用来构建锁或其他同步组件的基础框架。
 16 | 它使用一个int成员变量表示同步状态，通过内置的FIFO队列来完成资源获取线程的排队工作。
 17 | 
 18 | 同步器是实现锁的关键，在锁的实现中聚合同步器，利用同步器实现锁的语义。
 19 | 理解两者的关系：
 20 | 
 21 |     锁是面向使用者的，它定义了使用者与锁交互的接口，隐藏了实现细节；
 22 |     同步器是面向锁的实现者，它简化了锁的实现方式，屏蔽了同步状态管理、线程的排队、等待
 23 |     和唤醒等底层操作。
 24 |     
 25 | ###队列同步器的实现分析
 26 | 
 27 | ####1.同步队列
 28 | 
 29 | 通过一个FIFO双向队列来完成同步状态的管理，当前线程获取同步状态失败时，同步器会将当前线程以及等待状态等信息
 30 | 构造成一个Node并将其加入同步队列，同时会阻塞当前线程，当同步状态释放时，会把首节点中的线程唤醒，使其再次尝试
 31 | 获取同步状态。
 32 | 
 33 | 首节点是获取同步状态成功的节点，首节点在释放同步状态时，会唤醒后继节点，而后继节点在获取同步状态成功时将自己设置为首节点。
 34 | 
 35 | ####2.独占式同步状态获取和释放
 36 | 
 37 |      public final void acquire(int arg) {
 38 |             if (!tryAcquire(arg) &&acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
 39 |                 selfInterrupt();
 40 |      }
 41 |      
 42 |      
 43 |      
 44 |      
 45 | 代码分析：
 46 | 首先尝试获取同步状态，如果获取失败，构造独占式同步节点并将其加入到节点的尾部，
 47 | 然后调用acquireQueued，使节点一死循环的方式去获取同步状态，如果获取不到就阻塞节点中的线程。
 48 | 
 49 | 两个死循环：入队、入队后
 50 |  
 51 | 只有前驱节点是头结点才能尝试获取同步状态，原因：
 52 | 
 53 | 1. 头结点是成功获取到同步状态的节点，而头结点的线程释放了同步状态后，将会唤醒其后继节点，后继节点的线程
 54 | 被唤醒后需要检查自己的前驱节点是否为头节点。
 55 | 
 56 | 2. 维护同步队列的FIFO原则
 57 | 
 58 | 
 59 |         p128页的图非常重要
 60 | 
 61 |     总结：在获取同步状态时，同步器维护一个同步队列，获取状态失败的线程都会被加入到队列中并在队列中进行自旋，
 62 |     移出队列（停止自旋）的条件是前驱节点是头结点且成功获取了同步状态。在释放同步状态时，同步器调用tryRelease
 63 |     方法释放同步状态，然后唤醒头结点的后继节点
 64 |    
 65 |    
 66 | ####3.共享式同步状态获取和释放
 67 | 
 68 | 主要区别：同一时刻是否有多个线程同时获取到同步状态
 69 | 
 70 |     共享式访问资源时，其他共享式的访问均被允许，而独占式访问被阻塞。独占式访问资源时，同一时刻其他访问均被阻塞。
 71 |     
 72 | 
 73 | ##三、重入锁（ReentrantLock）
 74 | 
 75 | synchronized关键字隐式地支持重入
 76 | 
 77 | ReentrantLock不像synchronized隐式支持，在调用lock方法时，已经获取到锁的线程，能够再次调用lock方法获取锁而不被阻塞。
 78 | 
 79 | 事实上，公平的锁机制往往没有非公平的效率高，但是公平锁的好处在于：公平锁能够减少“饥饿”发生的概率，等待越久的请求越是能够得到
 80 | 优先满足。
 81 | 
 82 | ###1.重入的实现
 83 | 
 84 | 两个问题：再次获取锁、最终释放
 85 | 
 86 | ###2.公平锁与非公平锁的区别：
 87 | 
 88 | 如果一个锁是公平的，那么锁的获取顺序就应该符合请求的绝对时间顺序，也就是FIFO
 89 | 
 90 |     公平锁：CAS成功，且是队列的首节点
 91 |     非公平锁：CAS成功即可
 92 |     
 93 | 重入锁的默认实现是非公平锁，原因：虽然会导致饥饿，但是非公平锁的的开销少（线程切换次数少），从而可以有更高的吞吐量。
 94 | 
 95 | ##四、读写锁（ReentrantReadWriteLock）
 96 | 
 97 | 前文中的锁基本都是排他锁，在同一时刻只允许一个线程访问。
 98 | 
 99 | 读写所在同一时刻可以允许多个读线程访问，但在写线程访问时，所有读线程和其他写线程均被阻塞。（保证了写操作的可见性）
100 | 
101 | 读写锁维护了一对锁，一个读锁和一个写锁，通过分离读锁和写锁，使得并发性相比一般的排他锁有了很大提升。
102 | 
103 | ###读写锁的实现分析
104 | 
105 | ####1.读写状态的设计
106 | 
107 | 依赖自定义同步器，读写锁的自定义同步器需要在同步状态（一个int值）上维护多个读线程和一个写线程的状态，高16位表示读，低16位
108 | 表示写。
109 | 
110 |     位运算
111 |     
112 | ####2.写锁的获取与释放
113 | 
114 | 写锁是一个支持重入的排他锁，如果当前线程已经获取了写锁，则增加写状态。
115 | 如果当前线程在获取写锁时，读锁已经被获取或者该线程不是已经获取写锁的线程，则当前线程进入等待状态。
116 | 
117 | ####3.读锁的获取与释放
118 | 
119 | 在没有其他写线程访问时，读锁总会被成功地获取。如果写锁已经被其他线程获取，则进入等待状态。
120 | 
121 | 读状态的线程安全由CAS保证
122 | 
123 | ####4.锁降级（写锁降级成为读锁）
124 | 
125 | 定义：把持住写锁，再获取到读锁，随后释放写锁的过程
126 | 
127 |     writeLock.lock();
128 |     readLock.lock();
129 |     writeLock.unlock();
130 | 
131 | >这边不是很理解。。。。
132 | 
133 | 锁降级中读锁获取的必要性：
134 | 
135 |     为了保证数据的可见性，如果当前线程不获取读锁而是直接释放写锁，假设此刻另一个线程获取了写锁
136 |     并修改了数据，那么当前线程无法感知到数据的更新.如果当前线程获取读锁，则另一个线程会被阻塞，
137 |     直到当前线程使用数据并释放锁之后，另一个线程才能获取写锁进行数据更新。
138 |     
139 | ##五、LockSupport工具
140 | 
141 | 略，感觉不是很重要
142 | 
143 | ##六、Condition接口
144 | 
145 | 略，等待通知模式，有空回头再看
146 | 
147 |     


--------------------------------------------------------------------------------
/src/chapter4/DefaultThreadPool.java:
--------------------------------------------------------------------------------
  1 | package chapter4;
  2 | 
  3 | import java.util.ArrayList;
  4 | import java.util.Collections;
  5 | import java.util.LinkedList;
  6 | import java.util.List;
  7 | import java.util.concurrent.atomic.AtomicInteger;
  8 | import java.util.concurrent.atomic.AtomicLong;
  9 | 
 10 | /**
 11 |  * Created by xdcao on 2017/5/4.
 12 |  */
 13 | public class DefaultThreadPool<Job extends Runnable> implements ThreadPool<Job> {
 14 | 
 15 |     private static final int MAX_WORKER_NUMBERS=10;
 16 | 
 17 |     private static final int DEFAULT_WORKER_NUMBERS=5;
 18 | 
 19 |     private static final int MIN_WORKER_NUMBERS=1;
 20 | 
 21 |     private final LinkedList<Job> jobs=new LinkedList<Job>();
 22 | 
 23 |     private final List<Worker> workers= Collections.synchronizedList(new ArrayList<Worker>());
 24 | 
 25 |     private int workerNum=DEFAULT_WORKER_NUMBERS;
 26 | 
 27 |     private AtomicLong threadNum=new AtomicLong();
 28 | 
 29 | 
 30 |     public DefaultThreadPool() {
 31 |         initializeWorkers(DEFAULT_WORKER_NUMBERS);
 32 |     }
 33 | 
 34 |     public DefaultThreadPool(int workerNum){
 35 |         this.workerNum=workerNum>MAX_WORKER_NUMBERS?MAX_WORKER_NUMBERS:workerNum<MIN_WORKER_NUMBERS?MIN_WORKER_NUMBERS:workerNum;
 36 |         initializeWorkers(workerNum);
 37 |     }
 38 | 
 39 |     private void initializeWorkers(int defaultWorkerNumbers) {
 40 |         for (int i=0;i<defaultWorkerNumbers;i++){
 41 |             Worker worker=new Worker();
 42 |             workers.add(worker);
 43 |             Thread thread=new Thread(worker,"ThreadPool-worker-"+threadNum.incrementAndGet());
 44 |             thread.start();
 45 |         }
 46 |     }
 47 | 
 48 |     @Override
 49 |     public void execute(Job job) {
 50 |         if(job!=null){
 51 |             synchronized (jobs){
 52 |                 jobs.addLast(job);
 53 |                 jobs.notify();
 54 |             }
 55 |         }
 56 |     }
 57 | 
 58 |     @Override
 59 |     public void shutDown() {
 60 |         for (Worker worker:workers){
 61 |             worker.shutDown();
 62 |         }
 63 |     }
 64 | 
 65 |     @Override
 66 |     public void addWorkers(int num) {
 67 |         synchronized (jobs){
 68 |             if(num+this.workerNum>MAX_WORKER_NUMBERS){
 69 |                 num=MAX_WORKER_NUMBERS-this.workerNum;
 70 |             }
 71 |             initializeWorkers(num);
 72 |             this.workerNum+=num;
 73 |         }
 74 |     }
 75 | 
 76 |     @Override
 77 |     public void removeWorker(int num) {
 78 |         synchronized (jobs){
 79 |             if(num>=this.workerNum){
 80 |                 throw new IllegalArgumentException("beyond workNum");
 81 |             }
 82 |             int count=0;
 83 |             while (count<num){
 84 |                 Worker worker=workers.get(count);
 85 |                 if(workers.remove(worker)){
 86 |                     worker.shutDown();
 87 |                     count++;
 88 |                 }
 89 |             }
 90 |             this.workerNum-=count;
 91 |         }
 92 |     }
 93 | 
 94 |     @Override
 95 |     public int getJobSize() {
 96 |         return jobs.size();
 97 |     }
 98 | 
 99 | 
100 |     class Worker implements Runnable{
101 | 
102 |         private volatile boolean isRunning=false;
103 | 
104 |         @Override
105 |         public void run() {
106 |             while (isRunning){
107 |                 Job job=null;
108 |                 synchronized (jobs){
109 |                     while (jobs.isEmpty()){
110 |                         try {
111 |                             jobs.wait();
112 |                         }catch (InterruptedException e){
113 |                             Thread.currentThread().interrupt();
114 |                             return;
115 |                         }
116 |                     }
117 |                     job=jobs.removeFirst();
118 |                 }
119 |                 if (job!=null){
120 |                     try {
121 |                         job.run();
122 |                     }catch (Exception e){
123 | 
124 |                     }
125 |                 }
126 |             }
127 |         }
128 | 
129 |         public void shutDown() {
130 |             isRunning=false;
131 |         }
132 |     }
133 | 
134 | }
135 | 


--------------------------------------------------------------------------------
/src/chapter3/chapter3.md:
--------------------------------------------------------------------------------
  1 | #第三章 Java内存模型
  2 | 
  3 | ##一、基础
  4 | 
  5 | ###1、并发的两个关键问题
  6 | 
  7 | 线程间通信和线程间同步
  8 | 
  9 | 线程通信机制：
 10 | 
 11 |     共享内存：隐式通信，显式同步
 12 |     
 13 |     消息传递：显式通信，隐式同步
 14 |     
 15 | Java的并发采用的是共享内存模型。
 16 |     
 17 | ###2、java内存结构
 18 | 
 19 | JMM定义了线程和主内存之间的抽象关系：线程之间的共享变量存储在主内存中，每个线程都有一个
 20 | 私有的本地内存，本地内存中存储了该线程读/写共享变量的副本。
 21 | >本地内存是JMM的一个抽象概念，并不真实存在，涵盖了缓存、写缓冲区、寄存器以及其他的硬件和编译器优化
 22 | 
 23 | 线程A与线程B之间要通信必须经过以下两个步骤：
 24 | 
 25 |     1、线程A把本地内存A中更新过的共享变量刷新到主内存中去
 26 |     2、线程B到主内存中去读取A之前已更新过的共享变量
 27 | 
 28 | JMM通过控制主内存与每个线程的本地内存之间的交互来为java程序员提供内存可见性保证
 29 | 
 30 | ###3、指令重排序
 31 | 
 32 | 源码--------》编译器优化重排序-------》指令级并行重排序----------》内存系统重排序---------》最终的指令序列
 33 | 
 34 | 后面两个属于处理器的重排序
 35 | 
 36 | 对于编译器，JMM的编译器会禁止特定类型的编译器重排序。对于处理器重排序，JMM的处理器重排序规则
 37 | 会要求Java编译器在生成指令序列时，插入特定的内存屏障指令，从而禁止特定类型的处理器重排序。
 38 | 
 39 | ###4、并发模型分类
 40 | 
 41 | 四种内存屏障：
 42 | 
 43 |     LoadLoad：确保load1的数据先于laod2及后续所有load指令进行装载
 44 |     StoreStore：确保store1的数据对其他处理器的可见性先于store2及后续所有存储指令
 45 |     LoadStore：确保load装载先于store的存储刷新到内存
 46 |     StoreLoad：该屏障前的指令全部完成之后才会执行后面的指令（开销大）
 47 |     
 48 | ###5、先行发生（happens-before）
 49 | 
 50 | JMM中，如果一个操作执行的结果需要对另一个操作可见，那么这两个操作之间必须存在happens-before关系。
 51 | 
 52 | ##二、重排序
 53 | 
 54 | 数据依赖性
 55 | 
 56 | 在单线程程序中，对存在控制依赖的操作重排序不会改变执行结果；但在多线程程序中，对存在控制
 57 | 依赖的操作重排序，可能会改变程序的执行结果。
 58 | 
 59 |     详见30页的例子
 60 | 
 61 | ##三、顺序一致性
 62 | 
 63 | ##四、volatile内存语义
 64 | 
 65 | volatile变量特性：
 66 | 
 67 |     可见性：对一个volatile变量的读，总是能看到（任意线程）对这个变量最后的写入
 68 |     原子性：对任意单个volatile变量的读、写具有原子性（包括long、double），但类似volatile++
 69 |     这种复合操作不具有原子性。
 70 |     
 71 | volatile写-读的内存语义：
 72 | 
 73 | 写：当写一个volatile变量时，JMM会把线程对应的本地内存中的共享变量值刷新到主内存
 74 | 
 75 | 读：当读一个volatile变量时，JMM会把该线程对应的本地内存置为无效。线程接下来从主内存中读取共享变量
 76 | 
 77 | ###内存语义的实现：
 78 | 
 79 | 为了实现volatile的内存语义，编译器在生成字节码时，会在指令序列中插入内存屏障来禁止特定类型
 80 | 的处理器重排序。
 81 | 
 82 | JMM内存屏障插入策略：
 83 | 
 84 |     在每个volatile写操作前面插入StoreStore屏障
 85 |     在每个volatile写操作后面插入StoreLoad屏障
 86 |     在每个volatile读操作后面插入一个LoadLoad、一个LoadStore
 87 | 
 88 | ##五、锁的内存语义
 89 | 
 90 | 锁的释放和获取的内存语义（和volatile一样）
 91 | 
 92 | 线程释放锁时，会把本地内存中的共享变量刷新到主内存中（对应volatile写）
 93 | 
 94 | 线程获取锁时，会将线程对应的本地内存置为无效，从而临界区代码必须从主内存读取共享变量（对应volatile读）
 95 | 
 96 | 锁内存语义的实现：分析ReentrantLock源码
 97 | 
 98 | 公平锁和非公平锁语义总结：
 99 | 
100 |     公平锁和非公平锁释放时，最后都要写一个volatile变量state
101 |     公平锁获取时，首先会去读volatile变量
102 |     非公平锁获取时，首先会用CAS更新volatile变量，这个操作同时具有volatile读和volatile写的内存语义
103 |     
104 | 可以看出：锁释放-获取的内存语义的实现至少有下面两种方式
105 | 
106 |     1、利用volatile变量的写-读所具有的内存语义
107 |     2、利用CAS所附带的volatile读和volatile写的内存语义
108 |     
109 | CAS是如何同时具有volatile读和volatile写的内存语义的？
110 | 
111 | >多处理器环境，会为cmpxchg指令加上lock前缀，单处理器不用加（单处理器会维护自身的顺序一致性）
112 | 
113 | Lock前缀：
114 | 
115 |     1、确保对内存的读-改-写操作原子执行，使用缓存锁定来保证
116 |     2、禁止该指令与之前和之后的读和写指令重排序
117 |     3、把写缓冲区的所有数据刷新到内存中
118 |     
119 | 上面2、3两点具有的内存屏障效果，足以同时实现volatile读和volatile写的内存语义
120 | 
121 | ###concurrent包的通用实现模式
122 | 
123 |     首先，声明共享变量为volatile
124 |     然后，使用CAS的原子条件更新来实现线程之间的同步
125 |     同时，配合以volatile的读、写和CAS所具有的volatile读和写的内存语义来实现线程之间的通信
126 |     
127 | ##六、final域的内存语义
128 | 
129 | ###1、final域的重排序规则
130 | 
131 | （1）写：在构造函数内对一个final域的写入，与随后把这个被构造对象的引用赋值给一个引用变量，这两个操作不能重排序
132 | 
133 | （2）读：初次读一个包含final域的对象的引用，与随后初次读这个final域，这两个操作不能重排序。
134 | 
135 | ###2、写final域的重排序规则
136 | 
137 | 禁止把final域的写重排序到构造函数之外包含两方面：
138 | 
139 |     1、编译器： JMM禁止编译器把final域的写重排序到构造函数之外
140 |     2、处理器： 编译器会在final域的写之后，构造函数return之前，插入一个StoreStore屏障。这个屏障禁止处理器把final域
141 |     的写重排序到构造函数之外
142 |     
143 | 上述规则可以确保：
144 | 
145 | 在对象引用为任意线程可见之前，对象的final域已经被正确初始化过了，而普通域不具有这个保障。
146 | 
147 | ###3、读final域的重排序规则
148 | 
149 | 处理器：在一个线程中，初次读对象引用与初次读该对象所包含的final域，JMM禁止处理器重排序这两个操作
150 | 
151 | 编译器：编译器会在读final域操作的前面插入一个LoadLoad屏障
152 | 
153 | 上述重排序规则可以确保：在读一个对象的final域之前，一定会先读包含这个final域的对象的引用
154 | 
155 | ###4、当final域为引用类型
156 | 
157 | 对于引用类型，写final域的重排序规则增加下面的约束：
158 | 
159 |     在构造函数内对一个final引用对象的成员域的写入，与随后在构造函数外把这个被构造对象的引用赋值给一个引用变量，
160 |     这两个操作不能重排序。
161 |     
162 | ###5、为什么final域不能从构造函数内溢出
163 | 
164 | 在构造函数返回前，被构造对象的引用不能为其他线程所见，因为此时的final域可能还没有初始化。
165 | 
166 | ##七、happens-before
167 | 
168 | as-if-serial语义给编写单线程程序的程序员创造了一个幻境：单线程程序是按程序的顺序执行的。happens-before关系给编写正确同步的
169 | 多线程程序员创造了一个幻境：正确同步的多线程程序是按happens-before指定的顺序执行的。
170 | 
171 | 这么做的目的：为了在不改变程序的执行结果的前提下，尽可能地提高程序执行的并行度。
172 | 
173 | ##八、双重检查锁定与延迟初始化
174 | 
175 | 在单例的懒汉模式中，必须给实例添加volatile修饰符
176 | 
177 | 原因：在构造实例时，对象引用指针的操作和初始化操作可能会被重排序，
178 | 这就导致在if(instance==null)的时候认为对象已经创建，但这个时候还没有进行初始化
179 | 
180 |     1.分配对象的内存空间
181 |     2.初始化对象
182 |     3.设置instance指向内存空间
183 |     4.初次访问对象
184 |     
185 |     3和2可能会被重排序，导致1342这样的问题
186 |     
187 | 解决方式：
188 | 
189 | 1. volatile
190 | 
191 | 2. 基于类初始化的解决方案（还没好好看，记得回头补上）P72
192 | 
193 | 
194 | 


--------------------------------------------------------------------------------
/src/chapter2/chapter2.md:
--------------------------------------------------------------------------------
  1 | #第二章 Java并发机制的底层实现原理
  2 | 
  3 | ##一、volatile的应用
  4 | 
  5 | 如果volatile变量修饰符使用得当，它比synchronized的使用和执行成本更低，
  6 | 因为它不会引起线程上下文的切换和调度。
  7 | 
  8 | ###1. volatile的定义和实现原理
  9 | 
 10 | 有volatile变量修饰符的共享变量进行写操作的时候会多出一个lock前缀的指令
 11 | 
 12 | lock前缀的指令在多核处理器中引发两件事情
 13 | 
 14 | （1）将当前处理器缓存行的数据写回内存
 15 | 
 16 | （2）这个写回内存的操作会使在其他CPU里缓存了该内存地址的数据无效
 17 | 
 18 | >为了提高处理速度，处理器不直接和内存通信，而是先将内存中的数据读到cache中
 19 | 再进行操作，但操作完全不知道何时会写到内存。如果对声明了volatile变量的进行写操作
 20 | ，JVM就会向处理器发送一条Lock前缀的指令，将这个变量所在缓存行的数据写回到系统内存。
 21 | 但是，就算写回到内存，如果其他处理器缓存的值还是旧的，再进行计算操作就会有问题。所以，
 22 | 多处理器下，要实行缓存一致性协议，每个处理器通过嗅探在总线上传播的数据来检查自己缓存的
 23 | 值是不是过期，如果过期，就将当前处理器的缓存行设置成无效状态，当处理器对这个数据进行
 24 | 修改操作的时候，会重新从系统内存中把数据读到处理器缓存中。
 25 | 
 26 | ###2. volatile使用优化
 27 | 
 28 | 将共享变量追加到64字节(貌似不生效了，在源码中没看到)
 29 | 
 30 | LinkedTransferQueue
 31 | 
 32 | 处理器的Cache的高速缓存行是64字节，不支持部分填充缓存行。通过追加到64字节的方式
 33 | 来填满高速缓冲区的缓存行，避免头结点和尾节点加载到同一个缓存行，使头、尾节点在修改时不会互相锁定。
 34 | 
 35 | 并不是所有使用volatile变量的时候都要追加到64字节
 36 | 
 37 | 1. 缓存行非64字节宽
 38 | 2. 共享变量不会被频繁读写
 39 | 
 40 | ##二、synchronized的实现原理与应用（重量级锁）
 41 | 
 42 | synchronize基础：java中的每个对象都可以作为锁。具体表现为3种形式：
 43 | 1. 对于普通同步方法，锁是当前实例对象
 44 | 2. 对于静态同步方法，锁是当前类的class对象
 45 | 3. 对于同步方法块，锁是synchronize括号里的对象
 46 | 
 47 | >锁到底存在哪里？锁里面会存储什么信息？
 48 | 
 49 | Synchronized在JVM中的实现原理：
 50 | 
 51 | JVM基于进入和退出Monitor对象来实现方法同步和代码块同步，但两者的表现细节不同。
 52 | 
 53 | 代码块同步使用monitorenter和monitorexit指令实现，而方法同步是使用另外一种实现方式实现的，细节
 54 | 并没有在JVM中说明。但是，方法同步同样可以使用上述两个指令实现。
 55 | >monitorenter指令是在编译后插入到同步代码块的开始位置，而monitorexit是插入到方法结束处和异常处
 56 | ，JVM要保证每个monitorenter必须有对应的monitorexit与之配对。任何对象都有一个monitor与之关联，
 57 | 且当一个monitor被持有后，它将处于锁定状态。线程执行到monitorenter指令时，将会尝试获取对象所对应的
 58 | monitor的所有权，即尝试获得对象的锁。
 59 | 
 60 |     在博客上找一下
 61 | 
 62 | ###1、java对象头
 63 | 
 64 | 对象头三种数据：Mark Word（对象hashcode、锁信息等）、Class元数据地址、数组长度（数组类型的对象才有），
 65 | 这三种数据分别占据一个Word（4字节）。
 66 | 
 67 | mark word里存储的数据会随着锁标志位的变化而变化
 68 | 
 69 | ###2、锁的升级与对比
 70 | 
 71 | from JDK1.6
 72 | 
 73 | 锁一共有4中状态，由低到高为：无锁、偏向锁、轻量级锁、重量级锁，这几个状态会随着竞争情况逐渐升级。
 74 | 锁可以升级但不能降级（提高获得锁和释放锁的效率）
 75 | 
 76 | ####偏向锁：
 77 | 
 78 | 大多数情况下，锁不仅不存在多线程竞争，而且总是由同一线程多次获得，为了让线程获得锁的代价
 79 | 更低，引入了偏向锁。
 80 | 
 81 | 当一个线程访问同步块并获取锁时，会在对象头和栈帧的锁记录里存储锁偏向的线程ID，以后该线程在进入
 82 | 和退出同步块时不需要进行CAS操作来加锁和解锁，只需简单测试对象头里的mark word里是否存储着指向
 83 | 当前线程的偏向锁。
 84 | 
 85 | 如果测试成功，表示线程已经获得了锁。如果测试失败，则需要再测试一下mark word中偏向锁的标识是否
 86 | 设置成1：如果没有设置，则使用CAS竞争锁；如果设置了，则尝试使用CAS将对象头的偏向锁指向当前线程。
 87 | 
 88 | （1）偏向锁的撤销
 89 | 
 90 | 偏向锁使用了一种等到竞争出现才释放锁的机制，所以当其他线程尝试竞争偏向锁时，持有偏向锁的
 91 | 线程才会释放锁。偏向锁的撤销，需要等待全局安全点（在这个时间上没有正在执行的字节码）。
 92 | 
 93 | 首先暂停拥有偏向锁的线程，，然后检查持有偏向锁的线程是否活着，如果线程不处于活动状态，则
 94 | 将对象头设置成无锁状态；如果线程仍然活着，拥有偏向锁的栈会被执行，遍历偏向对象的锁记录，栈中的
 95 | 锁记录和对象头的mark word要么重新偏向于其他线程，要么恢复到无锁或者标记对象不适合作为偏向锁。
 96 | 
 97 |     这一块还是不清楚，得上网再看看
 98 |     
 99 | （2）关闭偏向锁
100 | 
101 | java6、7默认启用偏向锁，但是在程序启动后会有几秒延迟，如有必要可以关闭延迟
102 | -XX:BiasedLockingStartupDelay=0,如果确定程序里所有的锁通常处于竞争状态，可以通过JVM参数关闭偏向锁：
103 | -XX:UseBaisedLocking=false,那么程序会默认进入轻量级锁状态
104 | 
105 | ####轻量级锁
106 | 
107 | （1）加锁
108 | 
109 | 线程在执行同步块之前，JVM会先在当前线程的栈帧中创建用于存储锁记录的空间，并将对象头中的
110 | Mark word复制到锁记录中（Displaced Mark Word）。然后线程尝试使用CAS将对象头中的
111 | Mark word替换为指向锁记录的指针。如果成功，当前线程获得锁，如果失败，表示其他线程竞争锁，
112 | 当前线程便尝试使用自旋来获取锁。
113 | 
114 | （2）解锁
115 | 
116 | 解锁时，会使用原子的CAS操作将Displaced Mark Word替换回到对象头，如果成功，则表示没有竞争发生。
117 | 如果失败，表示当前锁存在竞争，锁就会膨胀成重量级锁。
118 | 
119 | 因为自旋会消耗CPU，为了避免无用的自旋，一旦升级成重量级锁，就不会再恢复到轻量级锁状态。当
120 | 锁处于这个状态下，其他线程试图获取锁时，都会被阻塞住，当持有锁的线程释放锁之后会唤醒这些线程，
121 | 被唤醒的线程就会进行新一轮的夺锁之争。
122 | 
123 | ###3、锁的优缺点对比
124 | 
125 |     偏向锁：
126 |         优点：加锁解锁不需要额外的消耗
127 |         缺点：如果线程间存在锁竞争，会带来额外的锁撤销的消耗
128 |         适用于只有一个线程访问同步块的场景
129 | 
130 |     轻量级锁：
131 |         优点：竞争的线程不会阻塞，提高了程序的响应速度
132 |         缺点：如果始终得不到锁竞争的线程，使用自旋会消耗CPU
133 |         使用场景：追求响应时间，同步块执行速度非常快
134 |         
135 |     重量级锁：
136 |         优点：线程竞争不使用自旋，不会消耗CPU
137 |         缺点：线程阻塞，响应时间慢
138 |         适用场景：追求吞吐量，同步块执行时间较长
139 |         
140 | ##三、原子操作的实现原理
141 | 
142 | ###1、术语
143 |     
144 |     CAS：比较并交换
145 |     缓存行：缓存的最小操作单位
146 |     内存顺序冲突：一般由假共享引起，出现内存顺序冲突时，CPU必须清空流水线
147 |     假共享：多个CPU同时修改同一个缓存行的不同部分而引起其中一个CPU的操作无效
148 |     
149 | ###2、处理器实现原子操作
150 | 
151 | （1）通过总线锁保证原子性
152 | 
153 | 如果多个处理器同时对共享变量进行读改写操作（i++），那么共享变量就会被多个处理器同时进行操作，
154 | 这样读改写操作就不是原子的，操作完之后共享变量的值会和期望的不一致。
155 | 
156 | 总线锁：当一个处理器在总线上输出LOCK #信号时，其他处理器的请求将被阻塞住，那么该处理器
157 | 可以独占共享内存。
158 | 
159 | （2）使用缓存锁保证原子性
160 | 
161 | 总线锁定把CPU和内存之间的通信锁住了，锁定期间，其他处理器不能操作其他内存地址的数据，
162 | 因此总线锁定的开销比较大。
163 | 
164 | 缓存锁定：内存区域如果被缓存在处理器的缓存行中，并且在LOCK期间被锁定，那么当他执行锁操作
165 | 会写到内存时，处理器不在总线上声言LOCK #信号，而是修改内部的内存地址，并允许它的缓存一致性机制来保证
166 | 操作的原子性，因为缓存一致性机制会阻止同时修改由两个以上处理器缓存的内存区域数据，当
167 | 其他处理器回写已被锁定的缓存行的数据时，会使缓存行无效。
168 | 
169 |     两种情况不会使用缓存锁定：
170 |         1、数据不能被缓存在处理器内部，或操作的数据跨多个缓存行，此时用总线锁定
171 |         2、有些处理器不支持缓存锁定
172 |         
173 | ###3、Java实现原子操作（锁和循环CAS）
174 | 
175 | （1）循环CAS机制
176 | 
177 | 处理器的CMPXCHG指令
178 | 
179 | 自旋CAS：循环进行CAS操作直至成功为止
180 | 
181 | CAS实现原子操作的三大问题：
182 |     
183 |     1、ABA问题：A到B再到A，CAS检查值时会以为没有发生变化，实际却发生了变化，解决方式是
184 |     在变量前面追加版本号：1A到2B到3C
185 |     2、循环时间长开销大：自旋CAS如果长时间不成功，会给CPU带来非常大的执行开销
186 |     3、只能保证一个共享变量的原子操作：此时用锁或者将几个共享变量合并
187 |     
188 | （2）锁机制
189 | 
190 | 除了偏向锁，另外两种锁都使用了循环CAS机制,即当一个线程进入同步块的时候使用循环CAS的方式
191 | 获取锁，当他退出同步块的时候使用循环CAS释放锁。


--------------------------------------------------------------------------------
/.idea/workspace.xml:
--------------------------------------------------------------------------------
   1 | <?xml version="1.0" encoding="UTF-8"?>
   2 | <project version="4">
   3 |   <component name="ChangeListManager">
   4 |     <list default="true" id="1682a6fa-df50-4a59-87f5-38adb006d7f2" name="Default" comment="">
   5 |       <change type="NEW" beforePath="" afterPath="$PROJECT_DIR$/../Java_concurrent/src/chapter9/chapter9.md" />
   6 |       <change type="MODIFICATION" beforePath="$PROJECT_DIR$/../Java_concurrent/.idea/workspace.xml" afterPath="$PROJECT_DIR$/../Java_concurrent/.idea/workspace.xml" />
   7 |     </list>
   8 |     <ignored path="$PROJECT_DIR$/../Java_concurrent/out/" />
   9 |     <option name="EXCLUDED_CONVERTED_TO_IGNORED" value="true" />
  10 |     <option name="TRACKING_ENABLED" value="true" />
  11 |     <option name="SHOW_DIALOG" value="false" />
  12 |     <option name="HIGHLIGHT_CONFLICTS" value="true" />
  13 |     <option name="HIGHLIGHT_NON_ACTIVE_CHANGELIST" value="false" />
  14 |     <option name="LAST_RESOLUTION" value="IGNORE" />
  15 |   </component>
  16 |   <component name="ExecutionTargetManager" SELECTED_TARGET="default_target" />
  17 |   <component name="FileEditorManager">
  18 |     <leaf SIDE_TABS_SIZE_LIMIT_KEY="300">
  19 |       <file leaf-file-name="chapter7.md" pinned="false" current-in-tab="false">
  20 |         <entry file="file://$PROJECT_DIR$/../Java_concurrent/src/chapter7/chapter7.md">
  21 |           <provider selected="true" editor-type-id="split-provider[text-editor;markdown-preview-editor]">
  22 |             <state split_layout="SPLIT">
  23 |               <first_editor relative-caret-position="285">
  24 |                 <caret line="15" column="0" lean-forward="true" selection-start-line="15" selection-start-column="0" selection-end-line="15" selection-end-column="0" />
  25 |                 <folding />
  26 |               </first_editor>
  27 |               <second_editor />
  28 |             </state>
  29 |           </provider>
  30 |         </entry>
  31 |       </file>
  32 |       <file leaf-file-name="chapter9.md" pinned="false" current-in-tab="true">
  33 |         <entry file="file://$PROJECT_DIR$/../Java_concurrent/src/chapter9/chapter9.md">
  34 |           <provider selected="true" editor-type-id="split-provider[text-editor;markdown-preview-editor]">
  35 |             <state split_layout="SPLIT">
  36 |               <first_editor relative-caret-position="646">
  37 |                 <caret line="37" column="0" lean-forward="true" selection-start-line="37" selection-start-column="0" selection-end-line="37" selection-end-column="0" />
  38 |                 <folding />
  39 |               </first_editor>
  40 |               <second_editor />
  41 |             </state>
  42 |           </provider>
  43 |         </entry>
  44 |       </file>
  45 |       <file leaf-file-name="chapter6.md" pinned="false" current-in-tab="false">
  46 |         <entry file="file://$PROJECT_DIR$/../Java_concurrent/src/chapter6/chapter6.md">
  47 |           <provider selected="true" editor-type-id="split-provider[text-editor;markdown-preview-editor]">
  48 |             <state split_layout="SPLIT">
  49 |               <first_editor relative-caret-position="556">
  50 |                 <caret line="142" column="10" lean-forward="true" selection-start-line="0" selection-start-column="0" selection-end-line="142" selection-end-column="10" />
  51 |                 <folding />
  52 |               </first_editor>
  53 |               <second_editor />
  54 |             </state>
  55 |           </provider>
  56 |         </entry>
  57 |       </file>
  58 |     </leaf>
  59 |   </component>
  60 |   <component name="FileTemplateManagerImpl">
  61 |     <option name="RECENT_TEMPLATES">
  62 |       <list>
  63 |         <option value="Interface" />
  64 |         <option value="Class" />
  65 |       </list>
  66 |     </option>
  67 |   </component>
  68 |   <component name="FindInProjectRecents">
  69 |     <findStrings>
  70 |       <find>acquire</find>
  71 |     </findStrings>
  72 |   </component>
  73 |   <component name="Git.Settings">
  74 |     <option name="RECENT_GIT_ROOT_PATH" value="$PROJECT_DIR$/../Java_concurrent" />
  75 |   </component>
  76 |   <component name="GradleLocalSettings">
  77 |     <option name="externalProjectsViewState">
  78 |       <projects_view />
  79 |     </option>
  80 |   </component>
  81 |   <component name="IdeDocumentHistory">
  82 |     <option name="CHANGED_PATHS">
  83 |       <list>
  84 |         <option value="$PROJECT_DIR$/../Java_concurrent/src/chapter1/DeadLockDemo.java" />
  85 |         <option value="$PROJECT_DIR$/../Java_concurrent/src/chapter1/chapter1.md" />
  86 |         <option value="$PROJECT_DIR$/../Java_concurrent/src/chapter2/Counter.java" />
  87 |         <option value="$PROJECT_DIR$/../Java_concurrent/src/chapter2/chapter2.md" />
  88 |         <option value="$PROJECT_DIR$/../Java_concurrent/src/chapter3/ReorderExample.java" />
  89 |         <option value="$PROJECT_DIR$/../Java_concurrent/src/chapter3/ReentrantLockExample.java" />
  90 |         <option value="$PROJECT_DIR$/../Java_concurrent/src/chapter3/chapter3.md" />
  91 |         <option value="$PROJECT_DIR$/../Java_concurrent/src/chapter4/MultiThread.java" />
  92 |         <option value="$PROJECT_DIR$/../Java_concurrent/src/chapter4/SleepUtils.java" />
  93 |         <option value="$PROJECT_DIR$/../Java_concurrent/src/chapter4/Interrupted.java" />
  94 |         <option value="$PROJECT_DIR$/../Java_concurrent/src/chapter4/WaitNotify.java" />
  95 |         <option value="$PROJECT_DIR$/../Java_concurrent/src/chapter4/Join.java" />
  96 |         <option value="$PROJECT_DIR$/../Java_concurrent/src/chapter4/Profiler.java" />
  97 |         <option value="$PROJECT_DIR$/../Java_concurrent/src/chapter4/chapter4.md" />
  98 |         <option value="$PROJECT_DIR$/../Java_concurrent/src/chapter4/ConnectionPool.java" />
  99 |         <option value="$PROJECT_DIR$/../Java_concurrent/src/chapter4/PoolTest.java" />
 100 |         <option value="$PROJECT_DIR$/../Java_concurrent/src/chapter4/ConnectionDriver.java" />
 101 |         <option value="$PROJECT_DIR$/../Java_concurrent/src/chapter4/ThreadPool.java" />
 102 |         <option value="$PROJECT_DIR$/../Java_concurrent/src/chapter4/DefaultThreadPool.java" />
 103 |         <option value="$PROJECT_DIR$/../Java_concurrent/src/chapter5/Mutex.java" />
 104 |         <option value="$PROJECT_DIR$/../Java_concurrent/src/chapter5/TwinsLock.java" />
 105 |         <option value="$PROJECT_DIR$/../Java_concurrent/src/chapter5/TwinsLockTest.java" />
 106 |         <option value="$PROJECT_DIR$/../Java_concurrent/src/chapter5/FairAndUnfairTest.java" />
 107 |         <option value="$PROJECT_DIR$/../Java_concurrent/src/chapter5/Cache.java" />
 108 |         <option value="$PROJECT_DIR$/../Java_concurrent/src/chapter5/chapter5.md" />
 109 |         <option value="$PROJECT_DIR$/../Java_concurrent/src/chapter6/chapter6.md" />
 110 |         <option value="$PROJECT_DIR$/../Java_concurrent/src/chapter6/CountTask.java" />
 111 |         <option value="$PROJECT_DIR$/../Java_concurrent/src/chapter7/chapter7.md" />
 112 |         <option value="$PROJECT_DIR$/../Java_concurrent/src/chapter9/chapter9.md" />
 113 |       </list>
 114 |     </option>
 115 |   </component>
 116 |   <component name="JsBuildToolGruntFileManager" detection-done="true" sorting="DEFINITION_ORDER" />
 117 |   <component name="JsBuildToolPackageJson" detection-done="true" sorting="DEFINITION_ORDER" />
 118 |   <component name="JsGulpfileManager">
 119 |     <detection-done>true</detection-done>
 120 |     <sorting>DEFINITION_ORDER</sorting>
 121 |   </component>
 122 |   <component name="ProjectFrameBounds">
 123 |     <option name="x" value="-7" />
 124 |     <option name="width" value="1692" />
 125 |     <option name="height" value="1017" />
 126 |   </component>
 127 |   <component name="ProjectLevelVcsManager" settingsEditedManually="true" />
 128 |   <component name="ProjectView">
 129 |     <navigator currentView="ProjectPane" proportions="" version="1">
 130 |       <flattenPackages />
 131 |       <showMembers />
 132 |       <showModules />
 133 |       <showLibraryContents />
 134 |       <hideEmptyPackages />
 135 |       <abbreviatePackageNames />
 136 |       <autoscrollToSource />
 137 |       <autoscrollFromSource />
 138 |       <sortByType />
 139 |       <manualOrder />
 140 |       <foldersAlwaysOnTop value="true" />
 141 |     </navigator>
 142 |     <panes>
 143 |       <pane id="Scratches" />
 144 |       <pane id="PackagesPane" />
 145 |       <pane id="Scope" />
 146 |       <pane id="ProjectPane">
 147 |         <subPane>
 148 |           <PATH>
 149 |             <PATH_ELEMENT>
 150 |               <option name="myItemId" value="Java_concurrent" />
 151 |               <option name="myItemType" value="com.intellij.ide.projectView.impl.nodes.ProjectViewProjectNode" />
 152 |             </PATH_ELEMENT>
 153 |             <PATH_ELEMENT>
 154 |               <option name="myItemId" value="Java_concurrent" />
 155 |               <option name="myItemType" value="com.intellij.ide.projectView.impl.nodes.PsiDirectoryNode" />
 156 |             </PATH_ELEMENT>
 157 |           </PATH>
 158 |           <PATH>
 159 |             <PATH_ELEMENT>
 160 |               <option name="myItemId" value="Java_concurrent" />
 161 |               <option name="myItemType" value="com.intellij.ide.projectView.impl.nodes.ProjectViewProjectNode" />
 162 |             </PATH_ELEMENT>
 163 |             <PATH_ELEMENT>
 164 |               <option name="myItemId" value="Java_concurrent" />
 165 |               <option name="myItemType" value="com.intellij.ide.projectView.impl.nodes.PsiDirectoryNode" />
 166 |             </PATH_ELEMENT>
 167 |             <PATH_ELEMENT>
 168 |               <option name="myItemId" value="src" />
 169 |               <option name="myItemType" value="com.intellij.ide.projectView.impl.nodes.PsiDirectoryNode" />
 170 |             </PATH_ELEMENT>
 171 |           </PATH>
 172 |         </subPane>
 173 |       </pane>
 174 |     </panes>
 175 |   </component>
 176 |   <component name="PropertiesComponent">
 177 |     <property name="WebServerToolWindowFactoryState" value="false" />
 178 |     <property name="aspect.path.notification.shown" value="true" />
 179 |     <property name="last_opened_file_path" value="$PROJECT_DIR$/../spring-boot-demo-master" />
 180 |     <property name="SearchEverywhereHistoryKey" value="Concurre&#9;PSI&#9;JAVA://java.util.concurrent.ConcurrentHashMap&#10;Abstrac&#9;FILE&#9;jar://C:/Program Files/Java/jdk1.8.0_77/src.zip!/java/util/concurrent/locks/AbstractQueuedSynchronizer.java&#10;AbstractQueued&#9;FILE&#9;jar://C:/Program Files/Java/jdk1.8.0_77/src.zip!/java/util/concurrent/locks/AbstractQueuedSynchronizer.java&#10;LinkedTransfer&#9;PSI&#9;JAVA://java.util.concurrent.LinkedTransferQueue&#10;linked&#9;null&#9;null" />
 181 |   </component>
 182 |   <component name="RecentsManager">
 183 |     <key name="CreateClassDialog.RecentsKey">
 184 |       <recent name="chapter4" />
 185 |     </key>
 186 |   </component>
 187 |   <component name="RunDashboard">
 188 |     <option name="ruleStates">
 189 |       <list>
 190 |         <RuleState>
 191 |           <option name="name" value="ConfigurationTypeDashboardGroupingRule" />
 192 |         </RuleState>
 193 |         <RuleState>
 194 |           <option name="name" value="StatusDashboardGroupingRule" />
 195 |         </RuleState>
 196 |       </list>
 197 |     </option>
 198 |   </component>
 199 |   <component name="RunManager" selected="Application.CountTask">
 200 |     <configuration default="false" name="Join" type="Application" factoryName="Application" temporary="true" nameIsGenerated="true">
 201 |       <extension name="coverage" enabled="false" merge="false" sample_coverage="true" runner="idea">
 202 |         <pattern>
 203 |           <option name="PATTERN" value="chapter4.*" />
 204 |           <option name="ENABLED" value="true" />
 205 |         </pattern>
 206 |       </extension>
 207 |       <option name="MAIN_CLASS_NAME" value="chapter4.Join" />
 208 |       <option name="VM_PARAMETERS" />
 209 |       <option name="PROGRAM_PARAMETERS" />
 210 |       <option name="WORKING_DIRECTORY" value="$PROJECT_DIR$/../Java_concurrent" />
 211 |       <option name="ALTERNATIVE_JRE_PATH_ENABLED" value="false" />
 212 |       <option name="ALTERNATIVE_JRE_PATH" />
 213 |       <option name="ENABLE_SWING_INSPECTOR" value="false" />
 214 |       <option name="ENV_VARIABLES" />
 215 |       <option name="PASS_PARENT_ENVS" value="true" />
 216 |       <module name="Java_concurrent" />
 217 |       <envs />
 218 |       <method />
 219 |     </configuration>
 220 |     <configuration default="false" name="Profiler" type="Application" factoryName="Application" temporary="true" nameIsGenerated="true">
 221 |       <extension name="coverage" enabled="false" merge="false" sample_coverage="true" runner="idea">
 222 |         <pattern>
 223 |           <option name="PATTERN" value="chapter4.*" />
 224 |           <option name="ENABLED" value="true" />
 225 |         </pattern>
 226 |       </extension>
 227 |       <option name="MAIN_CLASS_NAME" value="chapter4.Profiler" />
 228 |       <option name="VM_PARAMETERS" />
 229 |       <option name="PROGRAM_PARAMETERS" />
 230 |       <option name="WORKING_DIRECTORY" value="$PROJECT_DIR$/../Java_concurrent" />
 231 |       <option name="ALTERNATIVE_JRE_PATH_ENABLED" value="false" />
 232 |       <option name="ALTERNATIVE_JRE_PATH" />
 233 |       <option name="ENABLE_SWING_INSPECTOR" value="false" />
 234 |       <option name="ENV_VARIABLES" />
 235 |       <option name="PASS_PARENT_ENVS" value="true" />
 236 |       <module name="Java_concurrent" />
 237 |       <envs />
 238 |       <method />
 239 |     </configuration>
 240 |     <configuration default="false" name="PoolTest" type="Application" factoryName="Application" temporary="true" nameIsGenerated="true">
 241 |       <extension name="coverage" enabled="false" merge="false" sample_coverage="true" runner="idea">
 242 |         <pattern>
 243 |           <option name="PATTERN" value="chapter4.*" />
 244 |           <option name="ENABLED" value="true" />
 245 |         </pattern>
 246 |       </extension>
 247 |       <option name="MAIN_CLASS_NAME" value="chapter4.PoolTest" />
 248 |       <option name="VM_PARAMETERS" />
 249 |       <option name="PROGRAM_PARAMETERS" />
 250 |       <option name="WORKING_DIRECTORY" value="$PROJECT_DIR$/../Java_concurrent" />
 251 |       <option name="ALTERNATIVE_JRE_PATH_ENABLED" value="false" />
 252 |       <option name="ALTERNATIVE_JRE_PATH" />
 253 |       <option name="ENABLE_SWING_INSPECTOR" value="false" />
 254 |       <option name="ENV_VARIABLES" />
 255 |       <option name="PASS_PARENT_ENVS" value="true" />
 256 |       <module name="Java_concurrent" />
 257 |       <envs />
 258 |       <method />
 259 |     </configuration>
 260 |     <configuration default="false" name="TwinsLockTest" type="Application" factoryName="Application" temporary="true" nameIsGenerated="true">
 261 |       <extension name="coverage" enabled="false" merge="false" sample_coverage="true" runner="idea">
 262 |         <pattern>
 263 |           <option name="PATTERN" value="chapter5.*" />
 264 |           <option name="ENABLED" value="true" />
 265 |         </pattern>
 266 |       </extension>
 267 |       <option name="MAIN_CLASS_NAME" value="chapter5.TwinsLockTest" />
 268 |       <option name="VM_PARAMETERS" />
 269 |       <option name="PROGRAM_PARAMETERS" />
 270 |       <option name="WORKING_DIRECTORY" value="$PROJECT_DIR$/../Java_concurrent" />
 271 |       <option name="ALTERNATIVE_JRE_PATH_ENABLED" value="false" />
 272 |       <option name="ALTERNATIVE_JRE_PATH" />
 273 |       <option name="ENABLE_SWING_INSPECTOR" value="false" />
 274 |       <option name="ENV_VARIABLES" />
 275 |       <option name="PASS_PARENT_ENVS" value="true" />
 276 |       <module name="Java_concurrent" />
 277 |       <envs />
 278 |       <method />
 279 |     </configuration>
 280 |     <configuration default="false" name="CountTask" type="Application" factoryName="Application" temporary="true" nameIsGenerated="true">
 281 |       <extension name="coverage" enabled="false" merge="false" sample_coverage="true" runner="idea">
 282 |         <pattern>
 283 |           <option name="PATTERN" value="chapter6.*" />
 284 |           <option name="ENABLED" value="true" />
 285 |         </pattern>
 286 |       </extension>
 287 |       <option name="MAIN_CLASS_NAME" value="chapter6.CountTask" />
 288 |       <option name="VM_PARAMETERS" />
 289 |       <option name="PROGRAM_PARAMETERS" />
 290 |       <option name="WORKING_DIRECTORY" value="$PROJECT_DIR$/../Java_concurrent" />
 291 |       <option name="ALTERNATIVE_JRE_PATH_ENABLED" value="false" />
 292 |       <option name="ALTERNATIVE_JRE_PATH" />
 293 |       <option name="ENABLE_SWING_INSPECTOR" value="false" />
 294 |       <option name="ENV_VARIABLES" />
 295 |       <option name="PASS_PARENT_ENVS" value="true" />
 296 |       <module name="Java_concurrent" />
 297 |       <envs />
 298 |       <method />
 299 |     </configuration>
 300 |     <configuration default="true" type="#org.jetbrains.idea.devkit.run.PluginConfigurationType" factoryName="Plugin">
 301 |       <module name="" />
 302 |       <option name="VM_PARAMETERS" value="-Xmx512m -Xms256m -XX:MaxPermSize=250m -ea" />
 303 |       <option name="PROGRAM_PARAMETERS" />
 304 |       <predefined_log_file id="idea.log" enabled="true" />
 305 |       <method />
 306 |     </configuration>
 307 |     <configuration default="true" type="AndroidRunConfigurationType" factoryName="Android App">
 308 |       <module name="" />
 309 |       <option name="DEPLOY" value="true" />
 310 |       <option name="ARTIFACT_NAME" value="" />
 311 |       <option name="PM_INSTALL_OPTIONS" value="" />
 312 |       <option name="ACTIVITY_EXTRA_FLAGS" value="" />
 313 |       <option name="MODE" value="default_activity" />
 314 |       <option name="TARGET_SELECTION_MODE" value="SHOW_DIALOG" />
 315 |       <option name="PREFERRED_AVD" value="" />
 316 |       <option name="CLEAR_LOGCAT" value="false" />
 317 |       <option name="SHOW_LOGCAT_AUTOMATICALLY" value="false" />
 318 |       <option name="SKIP_NOOP_APK_INSTALLATIONS" value="true" />
 319 |       <option name="FORCE_STOP_RUNNING_APP" value="true" />
 320 |       <option name="DEBUGGER_TYPE" value="Java" />
 321 |       <option name="USE_LAST_SELECTED_DEVICE" value="false" />
 322 |       <option name="PREFERRED_AVD" value="" />
 323 |       <Java />
 324 |       <Profilers>
 325 |         <option name="ENABLE_ADVANCED_PROFILING" value="true" />
 326 |         <option name="GAPID_ENABLED" value="false" />
 327 |         <option name="GAPID_DISABLE_PCS" value="false" />
 328 |         <option name="SUPPORT_LIB_ENABLED" value="true" />
 329 |         <option name="INSTRUMENTATION_ENABLED" value="true" />
 330 |       </Profilers>
 331 |       <option name="DEEP_LINK" value="" />
 332 |       <option name="ACTIVITY_CLASS" value="" />
 333 |       <method />
 334 |     </configuration>
 335 |     <configuration default="true" type="AndroidTestRunConfigurationType" factoryName="Android Tests">
 336 |       <module name="" />
 337 |       <option name="TESTING_TYPE" value="0" />
 338 |       <option name="INSTRUMENTATION_RUNNER_CLASS" value="" />
 339 |       <option name="METHOD_NAME" value="" />
 340 |       <option name="CLASS_NAME" value="" />
 341 |       <option name="PACKAGE_NAME" value="" />
 342 |       <option name="EXTRA_OPTIONS" value="" />
 343 |       <option name="TARGET_SELECTION_MODE" value="SHOW_DIALOG" />
 344 |       <option name="PREFERRED_AVD" value="" />
 345 |       <option name="CLEAR_LOGCAT" value="false" />
 346 |       <option name="SHOW_LOGCAT_AUTOMATICALLY" value="false" />
 347 |       <option name="SKIP_NOOP_APK_INSTALLATIONS" value="true" />
 348 |       <option name="FORCE_STOP_RUNNING_APP" value="true" />
 349 |       <option name="DEBUGGER_TYPE" value="Java" />
 350 |       <option name="USE_LAST_SELECTED_DEVICE" value="false" />
 351 |       <option name="PREFERRED_AVD" value="" />
 352 |       <Java />
 353 |       <Profilers>
 354 |         <option name="ENABLE_ADVANCED_PROFILING" value="true" />
 355 |         <option name="GAPID_ENABLED" value="false" />
 356 |         <option name="GAPID_DISABLE_PCS" value="false" />
 357 |         <option name="SUPPORT_LIB_ENABLED" value="true" />
 358 |         <option name="INSTRUMENTATION_ENABLED" value="true" />
 359 |       </Profilers>
 360 |       <method />
 361 |     </configuration>
 362 |     <configuration default="true" type="Applet" factoryName="Applet">
 363 |       <option name="HTML_USED" value="false" />
 364 |       <option name="WIDTH" value="400" />
 365 |       <option name="HEIGHT" value="300" />
 366 |       <option name="POLICY_FILE" value="$APPLICATION_HOME_DIR$/bin/appletviewer.policy" />
 367 |       <module />
 368 |       <method />
 369 |     </configuration>
 370 |     <configuration default="true" type="Application" factoryName="Application">
 371 |       <extension name="coverage" enabled="false" merge="false" sample_coverage="true" runner="idea" />
 372 |       <option name="MAIN_CLASS_NAME" />
 373 |       <option name="VM_PARAMETERS" />
 374 |       <option name="PROGRAM_PARAMETERS" />
 375 |       <option name="WORKING_DIRECTORY" value="$PROJECT_DIR$/../Java_concurrent" />
 376 |       <option name="ALTERNATIVE_JRE_PATH_ENABLED" value="false" />
 377 |       <option name="ALTERNATIVE_JRE_PATH" />
 378 |       <option name="ENABLE_SWING_INSPECTOR" value="false" />
 379 |       <option name="ENV_VARIABLES" />
 380 |       <option name="PASS_PARENT_ENVS" value="true" />
 381 |       <module name="" />
 382 |       <envs />
 383 |       <method />
 384 |     </configuration>
 385 |     <configuration default="true" type="ArquillianJUnit" factoryName="" nameIsGenerated="true">
 386 |       <extension name="coverage" enabled="false" merge="false" sample_coverage="true" runner="idea" />
 387 |       <module name="" />
 388 |       <option name="arquillianRunConfiguration">
 389 |         <value>
 390 |           <option name="containerStateName" value="" />
 391 |         </value>
 392 |       </option>
 393 |       <option name="ALTERNATIVE_JRE_PATH_ENABLED" value="false" />
 394 |       <option name="ALTERNATIVE_JRE_PATH" />
 395 |       <option name="PACKAGE_NAME" />
 396 |       <option name="MAIN_CLASS_NAME" />
 397 |       <option name="METHOD_NAME" />
 398 |       <option name="TEST_OBJECT" value="class" />
 399 |       <option name="VM_PARAMETERS" />
 400 |       <option name="PARAMETERS" />
 401 |       <option name="WORKING_DIRECTORY" />
 402 |       <option name="ENV_VARIABLES" />
 403 |       <option name="PASS_PARENT_ENVS" value="true" />
 404 |       <option name="TEST_SEARCH_SCOPE">
 405 |         <value defaultName="singleModule" />
 406 |       </option>
 407 |       <envs />
 408 |       <patterns />
 409 |       <method />
 410 |     </configuration>
 411 |     <configuration default="true" type="ArquillianTestNG" factoryName="">
 412 |       <extension name="coverage" enabled="false" merge="false" sample_coverage="true" runner="idea" />
 413 |       <module name="" />
 414 |       <option name="arquillianRunConfiguration">
 415 |         <value>
 416 |           <option name="containerStateName" value="" />
 417 |         </value>
 418 |       </option>
 419 |       <option name="ALTERNATIVE_JRE_PATH_ENABLED" value="false" />
 420 |       <option name="ALTERNATIVE_JRE_PATH" />
 421 |       <option name="SUITE_NAME" />
 422 |       <option name="PACKAGE_NAME" />
 423 |       <option name="MAIN_CLASS_NAME" />
 424 |       <option name="METHOD_NAME" />
 425 |       <option name="GROUP_NAME" />
 426 |       <option name="TEST_OBJECT" value="CLASS" />
 427 |       <option name="VM_PARAMETERS" />
 428 |       <option name="PARAMETERS" />
 429 |       <option name="WORKING_DIRECTORY" />
 430 |       <option name="OUTPUT_DIRECTORY" />
 431 |       <option name="ANNOTATION_TYPE" />
 432 |       <option name="ENV_VARIABLES" />
 433 |       <option name="PASS_PARENT_ENVS" value="true" />
 434 |       <option name="TEST_SEARCH_SCOPE">
 435 |         <value defaultName="singleModule" />
 436 |       </option>
 437 |       <option name="USE_DEFAULT_REPORTERS" value="false" />
 438 |       <option name="PROPERTIES_FILE" />
 439 |       <envs />
 440 |       <properties />
 441 |       <listeners />
 442 |       <method />
 443 |     </configuration>
 444 |     <configuration default="true" type="Cold Fusion runner description" factoryName="Cold Fusion" custom_browser="" web_path="">
 445 |       <method />
 446 |     </configuration>
 447 |     <configuration default="true" type="CucumberJavaRunConfigurationType" factoryName="Cucumber java">
 448 |       <extension name="coverage" enabled="false" merge="false" sample_coverage="true" runner="idea" />
 449 |       <option name="myFilePath" />
 450 |       <option name="GLUE" />
 451 |       <option name="myNameFilter" />
 452 |       <option name="myGeneratedName" />
 453 |       <option name="MAIN_CLASS_NAME" />
 454 |       <option name="VM_PARAMETERS" />
 455 |       <option name="PROGRAM_PARAMETERS" />
 456 |       <option name="WORKING_DIRECTORY" />
 457 |       <option name="ALTERNATIVE_JRE_PATH_ENABLED" value="false" />
 458 |       <option name="ALTERNATIVE_JRE_PATH" />
 459 |       <option name="ENABLE_SWING_INSPECTOR" value="false" />
 460 |       <option name="ENV_VARIABLES" />
 461 |       <option name="PASS_PARENT_ENVS" value="true" />
 462 |       <module name="" />
 463 |       <envs />
 464 |       <method />
 465 |     </configuration>
 466 |     <configuration default="true" type="FlashRunConfigurationType" factoryName="Flash App">
 467 |       <option name="BCName" value="" />
 468 |       <option name="IOSSimulatorSdkPath" value="" />
 469 |       <option name="adlOptions" value="" />
 470 |       <option name="airProgramParameters" value="" />
 471 |       <option name="appDescriptorForEmulator" value="Android" />
 472 |       <option name="debugTransport" value="USB" />
 473 |       <option name="debuggerSdkRaw" value="BC SDK" />
 474 |       <option name="emulator" value="NexusOne" />
 475 |       <option name="emulatorAdlOptions" value="" />
 476 |       <option name="fastPackaging" value="true" />
 477 |       <option name="fullScreenHeight" value="0" />
 478 |       <option name="fullScreenWidth" value="0" />
 479 |       <option name="launchUrl" value="false" />
 480 |       <option name="launcherParameters">
 481 |         <LauncherParameters>
 482 |           <option name="browser" value="a7bb68e0-33c0-4d6f-a81a-aac1fdb870c8" />
 483 |           <option name="launcherType" value="OSDefault" />
 484 |           <option name="newPlayerInstance" value="false" />
 485 |           <option name="playerPath" value="FlashPlayerDebugger.exe" />
 486 |         </LauncherParameters>
 487 |       </option>
 488 |       <option name="mobileRunTarget" value="Emulator" />
 489 |       <option name="moduleName" value="" />
 490 |       <option name="overriddenMainClass" value="" />
 491 |       <option name="overriddenOutputFileName" value="" />
 492 |       <option name="overrideMainClass" value="false" />
 493 |       <option name="runTrusted" value="true" />
 494 |       <option name="screenDpi" value="0" />
 495 |       <option name="screenHeight" value="0" />
 496 |       <option name="screenWidth" value="0" />
 497 |       <option name="url" value="http://" />
 498 |       <option name="usbDebugPort" value="7936" />
 499 |       <method />
 500 |     </configuration>
 501 |     <configuration default="true" type="FlexUnitRunConfigurationType" factoryName="FlexUnit" appDescriptorForEmulator="Android" class_name="" emulatorAdlOptions="" method_name="" package_name="" scope="Class">
 502 |       <option name="BCName" value="" />
 503 |       <option name="launcherParameters">
 504 |         <LauncherParameters>
 505 |           <option name="browser" value="a7bb68e0-33c0-4d6f-a81a-aac1fdb870c8" />
 506 |           <option name="launcherType" value="OSDefault" />
 507 |           <option name="newPlayerInstance" value="false" />
 508 |           <option name="playerPath" value="FlashPlayerDebugger.exe" />
 509 |         </LauncherParameters>
 510 |       </option>
 511 |       <option name="moduleName" value="" />
 512 |       <option name="trusted" value="true" />
 513 |       <method />
 514 |     </configuration>
 515 |     <configuration default="true" type="GradleRunConfiguration" factoryName="Gradle">
 516 |       <ExternalSystemSettings>
 517 |         <option name="executionName" />
 518 |         <option name="externalProjectPath" />
 519 |         <option name="externalSystemIdString" value="GRADLE" />
 520 |         <option name="scriptParameters" />
 521 |         <option name="taskDescriptions">
 522 |           <list />
 523 |         </option>
 524 |         <option name="taskNames">
 525 |           <list />
 526 |         </option>
 527 |         <option name="vmOptions" />
 528 |       </ExternalSystemSettings>
 529 |       <method />
 530 |     </configuration>
 531 |     <configuration default="true" type="GrailsRunConfigurationType" factoryName="Grails">
 532 |       <setting name="vmparams" value="" />
 533 |       <setting name="cmdLine" value="run-app" />
 534 |       <setting name="passParentEnv" value="true" />
 535 |       <setting name="launchBrowser" value="true" />
 536 |       <setting name="launchBrowserUrl" value="" />
 537 |       <setting name="depsClasspath" value="false" />
 538 |       <method />
 539 |     </configuration>
 540 |     <configuration default="true" type="JUnit" factoryName="JUnit">
 541 |       <extension name="coverage" enabled="false" merge="false" sample_coverage="true" runner="idea" />
 542 |       <module name="" />
 543 |       <option name="ALTERNATIVE_JRE_PATH_ENABLED" value="false" />
 544 |       <option name="ALTERNATIVE_JRE_PATH" />
 545 |       <option name="PACKAGE_NAME" />
 546 |       <option name="MAIN_CLASS_NAME" />
 547 |       <option name="METHOD_NAME" />
 548 |       <option name="TEST_OBJECT" value="class" />
 549 |       <option name="VM_PARAMETERS" value="-ea" />
 550 |       <option name="PARAMETERS" />
 551 |       <option name="WORKING_DIRECTORY" value="$MODULE_DIR$" />
 552 |       <option name="ENV_VARIABLES" />
 553 |       <option name="PASS_PARENT_ENVS" value="true" />
 554 |       <option name="TEST_SEARCH_SCOPE">
 555 |         <value defaultName="singleModule" />
 556 |       </option>
 557 |       <envs />
 558 |       <patterns />
 559 |       <method />
 560 |     </configuration>
 561 |     <configuration default="true" type="JarApplication" factoryName="JAR Application">
 562 |       <extension name="coverage" enabled="false" merge="false" sample_coverage="true" runner="idea" />
 563 |       <envs />
 564 |       <method />
 565 |     </configuration>
 566 |     <configuration default="true" type="Java Scratch" factoryName="Java Scratch">
 567 |       <extension name="coverage" enabled="false" merge="false" sample_coverage="true" runner="idea" />
 568 |       <option name="SCRATCH_FILE_ID" value="0" />
 569 |       <option name="MAIN_CLASS_NAME" />
 570 |       <option name="VM_PARAMETERS" />
 571 |       <option name="PROGRAM_PARAMETERS" />
 572 |       <option name="WORKING_DIRECTORY" />
 573 |       <option name="ALTERNATIVE_JRE_PATH_ENABLED" value="false" />
 574 |       <option name="ALTERNATIVE_JRE_PATH" />
 575 |       <option name="ENABLE_SWING_INSPECTOR" value="false" />
 576 |       <option name="ENV_VARIABLES" />
 577 |       <option name="PASS_PARENT_ENVS" value="true" />
 578 |       <module name="" />
 579 |       <envs />
 580 |       <method />
 581 |     </configuration>
 582 |     <configuration default="true" type="JavaScriptTestRunnerJest" factoryName="Jest">
 583 |       <node-interpreter value="project" />
 584 |       <working-dir value="" />
 585 |       <envs />
 586 |       <scope-kind value="ALL" />
 587 |       <method />
 588 |     </configuration>
 589 |     <configuration default="true" type="JavaScriptTestRunnerProtractor" factoryName="Protractor">
 590 |       <config-file value="" />
 591 |       <node-interpreter value="project" />
 592 |       <envs />
 593 |       <method />
 594 |     </configuration>
 595 |     <configuration default="true" type="JavascriptDebugType" factoryName="JavaScript Debug">
 596 |       <method />
 597 |     </configuration>
 598 |     <configuration default="true" type="JetRunConfigurationType" factoryName="Kotlin">
 599 |       <extension name="coverage" enabled="false" merge="false" sample_coverage="true" runner="idea" />
 600 |       <option name="MAIN_CLASS_NAME" />
 601 |       <option name="VM_PARAMETERS" />
 602 |       <option name="PROGRAM_PARAMETERS" />
 603 |       <option name="WORKING_DIRECTORY" />
 604 |       <option name="ALTERNATIVE_JRE_PATH_ENABLED" value="false" />
 605 |       <option name="ALTERNATIVE_JRE_PATH" />
 606 |       <option name="PASS_PARENT_ENVS" value="true" />
 607 |       <module name="Java_concurrent" />
 608 |       <envs />
 609 |       <method />
 610 |     </configuration>
 611 |     <configuration default="true" type="KotlinStandaloneScriptRunConfigurationType" factoryName="Kotlin script">
 612 |       <extension name="coverage" enabled="false" merge="false" sample_coverage="true" runner="idea" />
 613 |       <option name="filePath" />
 614 |       <option name="vmParameters" />
 615 |       <option name="alternativeJrePath" />
 616 |       <option name="programParameters" />
 617 |       <option name="passParentEnvs" value="true" />
 618 |       <option name="workingDirectory" />
 619 |       <option name="isAlternativeJrePathEnabled" value="false" />
 620 |       <envs />
 621 |       <method />
 622 |     </configuration>
 623 |     <configuration default="true" type="Remote" factoryName="Remote">
 624 |       <option name="USE_SOCKET_TRANSPORT" value="true" />
 625 |       <option name="SERVER_MODE" value="false" />
 626 |       <option name="SHMEM_ADDRESS" value="javadebug" />
 627 |       <option name="HOST" value="localhost" />
 628 |       <option name="PORT" value="5005" />
 629 |       <method />
 630 |     </configuration>
 631 |     <configuration default="true" type="SpringBootApplicationConfigurationType" factoryName="Spring Boot">
 632 |       <extension name="coverage" enabled="false" merge="false" sample_coverage="true" runner="idea" />
 633 |       <module name="" />
 634 |       <envs />
 635 |       <method />
 636 |     </configuration>
 637 |     <configuration default="true" type="TestNG" factoryName="TestNG">
 638 |       <extension name="coverage" enabled="false" merge="false" sample_coverage="true" runner="idea" />
 639 |       <module name="" />
 640 |       <option name="ALTERNATIVE_JRE_PATH_ENABLED" value="false" />
 641 |       <option name="ALTERNATIVE_JRE_PATH" />
 642 |       <option name="SUITE_NAME" />
 643 |       <option name="PACKAGE_NAME" />
 644 |       <option name="MAIN_CLASS_NAME" />
 645 |       <option name="METHOD_NAME" />
 646 |       <option name="GROUP_NAME" />
 647 |       <option name="TEST_OBJECT" value="CLASS" />
 648 |       <option name="VM_PARAMETERS" value="-ea" />
 649 |       <option name="PARAMETERS" />
 650 |       <option name="WORKING_DIRECTORY" value="$MODULE_DIR$" />
 651 |       <option name="OUTPUT_DIRECTORY" />
 652 |       <option name="ANNOTATION_TYPE" />
 653 |       <option name="ENV_VARIABLES" />
 654 |       <option name="PASS_PARENT_ENVS" value="true" />
 655 |       <option name="TEST_SEARCH_SCOPE">
 656 |         <value defaultName="singleModule" />
 657 |       </option>
 658 |       <option name="USE_DEFAULT_REPORTERS" value="false" />
 659 |       <option name="PROPERTIES_FILE" />
 660 |       <envs />
 661 |       <properties />
 662 |       <listeners />
 663 |       <method />
 664 |     </configuration>
 665 |     <configuration default="true" type="js.build_tools.gulp" factoryName="Gulp.js">
 666 |       <node-interpreter>project</node-interpreter>
 667 |       <node-options />
 668 |       <gulpfile />
 669 |       <tasks />
 670 |       <arguments />
 671 |       <envs />
 672 |       <method />
 673 |     </configuration>
 674 |     <configuration default="true" type="js.build_tools.npm" factoryName="npm">
 675 |       <command value="run" />
 676 |       <scripts />
 677 |       <node-interpreter value="project" />
 678 |       <envs />
 679 |       <method />
 680 |     </configuration>
 681 |     <configuration default="true" type="osgi.bnd.run" factoryName="Run Launcher">
 682 |       <method />
 683 |     </configuration>
 684 |     <configuration default="true" type="osgi.bnd.run" factoryName="Test Launcher (JUnit)">
 685 |       <method />
 686 |     </configuration>
 687 |     <list size="5">
 688 |       <item index="0" class="java.lang.String" itemvalue="Application.Join" />
 689 |       <item index="1" class="java.lang.String" itemvalue="Application.Profiler" />
 690 |       <item index="2" class="java.lang.String" itemvalue="Application.PoolTest" />
 691 |       <item index="3" class="java.lang.String" itemvalue="Application.TwinsLockTest" />
 692 |       <item index="4" class="java.lang.String" itemvalue="Application.CountTask" />
 693 |     </list>
 694 |     <recent_temporary>
 695 |       <list size="5">
 696 |         <item index="0" class="java.lang.String" itemvalue="Application.CountTask" />
 697 |         <item index="1" class="java.lang.String" itemvalue="Application.TwinsLockTest" />
 698 |         <item index="2" class="java.lang.String" itemvalue="Application.PoolTest" />
 699 |         <item index="3" class="java.lang.String" itemvalue="Application.Profiler" />
 700 |         <item index="4" class="java.lang.String" itemvalue="Application.Join" />
 701 |       </list>
 702 |     </recent_temporary>
 703 |   </component>
 704 |   <component name="ShelveChangesManager" show_recycled="false">
 705 |     <option name="remove_strategy" value="false" />
 706 |   </component>
 707 |   <component name="SvnConfiguration">
 708 |     <configuration />
 709 |   </component>
 710 |   <component name="TaskManager">
 711 |     <task active="true" id="Default" summary="Default task">
 712 |       <changelist id="1682a6fa-df50-4a59-87f5-38adb006d7f2" name="Default" comment="" />
 713 |       <created>1493305898572</created>
 714 |       <option name="number" value="Default" />
 715 |       <option name="presentableId" value="Default" />
 716 |       <updated>1493305898572</updated>
 717 |       <workItem from="1493305901341" duration="1424000" />
 718 |       <workItem from="1493365099280" duration="11043000" />
 719 |       <workItem from="1493571257920" duration="8384000" />
 720 |       <workItem from="1493692711697" duration="18582000" />
 721 |       <workItem from="1493811400917" duration="12282000" />
 722 |       <workItem from="1493899433497" duration="7041000" />
 723 |       <workItem from="1493961283826" duration="7699000" />
 724 |       <workItem from="1494231090763" duration="7394000" />
 725 |       <workItem from="1495030539506" duration="24334000" />
 726 |     </task>
 727 |     <task id="LOCAL-00001" summary="start">
 728 |       <created>1493306114538</created>
 729 |       <option name="number" value="00001" />
 730 |       <option name="presentableId" value="LOCAL-00001" />
 731 |       <option name="project" value="LOCAL" />
 732 |       <updated>1493306114538</updated>
 733 |     </task>
 734 |     <task id="LOCAL-00002" summary="chapter 1">
 735 |       <created>1493392674136</created>
 736 |       <option name="number" value="00002" />
 737 |       <option name="presentableId" value="LOCAL-00002" />
 738 |       <option name="project" value="LOCAL" />
 739 |       <updated>1493392674136</updated>
 740 |     </task>
 741 |     <task id="LOCAL-00003" summary="chapter 2 over">
 742 |       <created>1493607922099</created>
 743 |       <option name="number" value="00003" />
 744 |       <option name="presentableId" value="LOCAL-00003" />
 745 |       <option name="project" value="LOCAL" />
 746 |       <updated>1493607922099</updated>
 747 |     </task>
 748 |     <task id="LOCAL-00004" summary="chapter 2 over">
 749 |       <created>1493608678194</created>
 750 |       <option name="number" value="00004" />
 751 |       <option name="presentableId" value="LOCAL-00004" />
 752 |       <option name="project" value="LOCAL" />
 753 |       <updated>1493608678194</updated>
 754 |     </task>
 755 |     <task id="LOCAL-00005" summary="chapter 3.4">
 756 |       <created>1493696439287</created>
 757 |       <option name="number" value="00005" />
 758 |       <option name="presentableId" value="LOCAL-00005" />
 759 |       <option name="project" value="LOCAL" />
 760 |       <updated>1493696439287</updated>
 761 |     </task>
 762 |     <task id="LOCAL-00006" summary="chapter 3 over">
 763 |       <created>1493791913475</created>
 764 |       <option name="number" value="00006" />
 765 |       <option name="presentableId" value="LOCAL-00006" />
 766 |       <option name="project" value="LOCAL" />
 767 |       <updated>1493791913475</updated>
 768 |     </task>
 769 |     <task id="LOCAL-00007" summary="chapter 4.3">
 770 |       <created>1493818454397</created>
 771 |       <option name="number" value="00007" />
 772 |       <option name="presentableId" value="LOCAL-00007" />
 773 |       <option name="project" value="LOCAL" />
 774 |       <updated>1493818454397</updated>
 775 |     </task>
 776 |     <task id="LOCAL-00008" summary="chapter 4 over">
 777 |       <created>1493905227024</created>
 778 |       <option name="number" value="00008" />
 779 |       <option name="presentableId" value="LOCAL-00008" />
 780 |       <option name="project" value="LOCAL" />
 781 |       <updated>1493905227024</updated>
 782 |     </task>
 783 |     <task id="LOCAL-00009" summary="chapter 5.2.2">
 784 |       <created>1494007819442</created>
 785 |       <option name="number" value="00009" />
 786 |       <option name="presentableId" value="LOCAL-00009" />
 787 |       <option name="project" value="LOCAL" />
 788 |       <updated>1494007819442</updated>
 789 |     </task>
 790 |     <task id="LOCAL-00010" summary="chapter 5.3">
 791 |       <created>1494259226228</created>
 792 |       <option name="number" value="00010" />
 793 |       <option name="presentableId" value="LOCAL-00010" />
 794 |       <option name="project" value="LOCAL" />
 795 |       <updated>1494259226228</updated>
 796 |     </task>
 797 |     <task id="LOCAL-00011" summary="chapter 5.4">
 798 |       <created>1495034700490</created>
 799 |       <option name="number" value="00011" />
 800 |       <option name="presentableId" value="LOCAL-00011" />
 801 |       <option name="project" value="LOCAL" />
 802 |       <updated>1495034700490</updated>
 803 |     </task>
 804 |     <task id="LOCAL-00012" summary="chapter 5.4">
 805 |       <created>1495034707647</created>
 806 |       <option name="number" value="00012" />
 807 |       <option name="presentableId" value="LOCAL-00012" />
 808 |       <option name="project" value="LOCAL" />
 809 |       <updated>1495034707647</updated>
 810 |     </task>
 811 |     <task id="LOCAL-00013" summary="chapter 5 over">
 812 |       <created>1495114711465</created>
 813 |       <option name="number" value="00013" />
 814 |       <option name="presentableId" value="LOCAL-00013" />
 815 |       <option name="project" value="LOCAL" />
 816 |       <updated>1495114711465</updated>
 817 |     </task>
 818 |     <task id="LOCAL-00014" summary="chapter 6.1">
 819 |       <created>1495207639128</created>
 820 |       <option name="number" value="00014" />
 821 |       <option name="presentableId" value="LOCAL-00014" />
 822 |       <option name="project" value="LOCAL" />
 823 |       <updated>1495207639128</updated>
 824 |     </task>
 825 |     <task id="LOCAL-00015" summary="chapter 6 over">
 826 |       <created>1495374805901</created>
 827 |       <option name="number" value="00015" />
 828 |       <option name="presentableId" value="LOCAL-00015" />
 829 |       <option name="project" value="LOCAL" />
 830 |       <updated>1495374805901</updated>
 831 |     </task>
 832 |     <task id="LOCAL-00016" summary="chapter 7 over">
 833 |       <created>1495376355939</created>
 834 |       <option name="number" value="00016" />
 835 |       <option name="presentableId" value="LOCAL-00016" />
 836 |       <option name="project" value="LOCAL" />
 837 |       <updated>1495376355939</updated>
 838 |     </task>
 839 |     <option name="localTasksCounter" value="17" />
 840 |     <servers />
 841 |   </component>
 842 |   <component name="TimeTrackingManager">
 843 |     <option name="totallyTimeSpent" value="98183000" />
 844 |   </component>
 845 |   <component name="ToolWindowManager">
 846 |     <frame x="-7" y="0" width="1692" height="1017" extended-state="0" />
 847 |     <editor active="true" />
 848 |     <layout>
 849 |       <window_info id="Palette" active="false" anchor="right" auto_hide="false" internal_type="DOCKED" type="DOCKED" visible="false" show_stripe_button="true" weight="0.33" sideWeight="0.5" order="3" side_tool="false" content_ui="tabs" />
 850 |       <window_info id="TODO" active="false" anchor="bottom" auto_hide="false" internal_type="DOCKED" type="DOCKED" visible="false" show_stripe_button="true" weight="0.33" sideWeight="0.5" order="6" side_tool="false" content_ui="tabs" />
 851 |       <window_info id="Nl-Palette" active="false" anchor="left" auto_hide="false" internal_type="DOCKED" type="DOCKED" visible="false" show_stripe_button="true" weight="0.33" sideWeight="0.5" order="2" side_tool="false" content_ui="tabs" />
 852 |       <window_info id="Messages" active="false" anchor="bottom" auto_hide="false" internal_type="DOCKED" type="DOCKED" visible="false" show_stripe_button="true" weight="0.33" sideWeight="0.5" order="7" side_tool="false" content_ui="tabs" />
 853 |       <window_info id="Palette&#9;" active="false" anchor="right" auto_hide="false" internal_type="DOCKED" type="DOCKED" visible="false" show_stripe_button="true" weight="0.33" sideWeight="0.5" order="3" side_tool="false" content_ui="tabs" />
 854 |       <window_info id="Image Layers" active="false" anchor="left" auto_hide="false" internal_type="DOCKED" type="DOCKED" visible="false" show_stripe_button="true" weight="0.33" sideWeight="0.5" order="2" side_tool="false" content_ui="tabs" />
 855 |       <window_info id="Capture Analysis" active="false" anchor="right" auto_hide="false" internal_type="DOCKED" type="DOCKED" visible="false" show_stripe_button="true" weight="0.33" sideWeight="0.5" order="3" side_tool="false" content_ui="tabs" />
 856 |       <window_info id="Event Log" active="false" anchor="bottom" auto_hide="false" internal_type="DOCKED" type="DOCKED" visible="false" show_stripe_button="true" weight="0.33" sideWeight="0.5" order="7" side_tool="true" content_ui="tabs" />
 857 |       <window_info id="Maven Projects" active="false" anchor="right" auto_hide="false" internal_type="DOCKED" type="DOCKED" visible="false" show_stripe_button="true" weight="0.33" sideWeight="0.5" order="3" side_tool="false" content_ui="tabs" />
 858 |       <window_info id="Run" active="false" anchor="bottom" auto_hide="false" internal_type="DOCKED" type="DOCKED" visible="true" show_stripe_button="true" weight="0.16647792" sideWeight="0.5" order="2" side_tool="false" content_ui="tabs" />
 859 |       <window_info id="Version Control" active="false" anchor="bottom" auto_hide="false" internal_type="DOCKED" type="DOCKED" visible="false" show_stripe_button="true" weight="0.33" sideWeight="0.5" order="7" side_tool="false" content_ui="tabs" />
 860 |       <window_info id="Properties" active="false" anchor="right" auto_hide="false" internal_type="DOCKED" type="DOCKED" visible="false" show_stripe_button="true" weight="0.33" sideWeight="0.5" order="3" side_tool="false" content_ui="tabs" />
 861 |       <window_info id="Terminal" active="false" anchor="bottom" auto_hide="false" internal_type="DOCKED" type="DOCKED" visible="false" show_stripe_button="true" weight="0.33" sideWeight="0.5" order="7" side_tool="false" content_ui="tabs" />
 862 |       <window_info id="Capture Tool" active="false" anchor="left" auto_hide="false" internal_type="DOCKED" type="DOCKED" visible="false" show_stripe_button="true" weight="0.33" sideWeight="0.5" order="2" side_tool="false" content_ui="tabs" />
 863 |       <window_info id="Designer" active="false" anchor="left" auto_hide="false" internal_type="DOCKED" type="DOCKED" visible="false" show_stripe_button="true" weight="0.33" sideWeight="0.5" order="2" side_tool="false" content_ui="tabs" />
 864 |       <window_info id="Project" active="false" anchor="left" auto_hide="false" internal_type="DOCKED" type="DOCKED" visible="true" show_stripe_button="true" weight="0.21568628" sideWeight="0.5" order="0" side_tool="false" content_ui="tabs" />
 865 |       <window_info id="Database" active="false" anchor="right" auto_hide="false" internal_type="DOCKED" type="DOCKED" visible="false" show_stripe_button="true" weight="0.33" sideWeight="0.5" order="3" side_tool="false" content_ui="tabs" />
 866 |       <window_info id="Structure" active="false" anchor="left" auto_hide="false" internal_type="DOCKED" type="DOCKED" visible="false" show_stripe_button="true" weight="0.25" sideWeight="0.5" order="1" side_tool="false" content_ui="tabs" />
 867 |       <window_info id="Ant Build" active="false" anchor="right" auto_hide="false" internal_type="DOCKED" type="DOCKED" visible="false" show_stripe_button="true" weight="0.25" sideWeight="0.5" order="1" side_tool="false" content_ui="tabs" />
 868 |       <window_info id="UI Designer" active="false" anchor="left" auto_hide="false" internal_type="DOCKED" type="DOCKED" visible="false" show_stripe_button="true" weight="0.33" sideWeight="0.5" order="2" side_tool="false" content_ui="tabs" />
 869 |       <window_info id="Theme Preview" active="false" anchor="right" auto_hide="false" internal_type="DOCKED" type="DOCKED" visible="false" show_stripe_button="true" weight="0.33" sideWeight="0.5" order="3" side_tool="false" content_ui="tabs" />
 870 |       <window_info id="Debug" active="false" anchor="bottom" auto_hide="false" internal_type="DOCKED" type="DOCKED" visible="false" show_stripe_button="true" weight="0.3997735" sideWeight="0.5" order="3" side_tool="false" content_ui="tabs" />
 871 |       <window_info id="Favorites" active="false" anchor="left" auto_hide="false" internal_type="DOCKED" type="DOCKED" visible="false" show_stripe_button="true" weight="0.33" sideWeight="0.5" order="2" side_tool="true" content_ui="tabs" />
 872 |       <window_info id="Cvs" active="false" anchor="bottom" auto_hide="false" internal_type="DOCKED" type="DOCKED" visible="false" show_stripe_button="true" weight="0.25" sideWeight="0.5" order="4" side_tool="false" content_ui="tabs" />
 873 |       <window_info id="Message" active="false" anchor="bottom" auto_hide="false" internal_type="DOCKED" type="DOCKED" visible="false" show_stripe_button="true" weight="0.33" sideWeight="0.5" order="0" side_tool="false" content_ui="tabs" />
 874 |       <window_info id="Commander" active="false" anchor="right" auto_hide="false" internal_type="SLIDING" type="SLIDING" visible="false" show_stripe_button="true" weight="0.4" sideWeight="0.5" order="0" side_tool="false" content_ui="tabs" />
 875 |       <window_info id="Hierarchy" active="false" anchor="right" auto_hide="false" internal_type="DOCKED" type="DOCKED" visible="false" show_stripe_button="true" weight="0.25" sideWeight="0.5" order="2" side_tool="false" content_ui="combo" />
 876 |       <window_info id="Inspection" active="false" anchor="bottom" auto_hide="false" internal_type="DOCKED" type="DOCKED" visible="false" show_stripe_button="true" weight="0.4" sideWeight="0.5" order="5" side_tool="false" content_ui="tabs" />
 877 |       <window_info id="Find" active="false" anchor="bottom" auto_hide="false" internal_type="DOCKED" type="DOCKED" visible="false" show_stripe_button="true" weight="0.33" sideWeight="0.5" order="1" side_tool="false" content_ui="tabs" />
 878 |     </layout>
 879 |   </component>
 880 |   <component name="TypeScriptGeneratedFilesManager">
 881 |     <option name="processedProjectFiles" value="true" />
 882 |   </component>
 883 |   <component name="VcsContentAnnotationSettings">
 884 |     <option name="myLimit" value="2678400000" />
 885 |   </component>
 886 |   <component name="VcsManagerConfiguration">
 887 |     <MESSAGE value="start" />
 888 |     <MESSAGE value="chapter 1" />
 889 |     <MESSAGE value="chapter 2 over" />
 890 |     <MESSAGE value="chapter 3.4" />
 891 |     <MESSAGE value="chapter 3 over" />
 892 |     <MESSAGE value="chapter 4.3" />
 893 |     <MESSAGE value="chapter 4 over" />
 894 |     <MESSAGE value="chapter 5.2.2" />
 895 |     <MESSAGE value="chapter 5.3" />
 896 |     <MESSAGE value="chapter 5.4" />
 897 |     <MESSAGE value="chapter 5 over" />
 898 |     <MESSAGE value="chapter 6.1" />
 899 |     <MESSAGE value="chapter 6 over" />
 900 |     <MESSAGE value="chapter 7 over" />
 901 |     <option name="LAST_COMMIT_MESSAGE" value="chapter 7 over" />
 902 |   </component>
 903 |   <component name="XDebuggerManager">
 904 |     <breakpoint-manager>
 905 |       <option name="time" value="3" />
 906 |     </breakpoint-manager>
 907 |     <watches-manager />
 908 |   </component>
 909 |   <component name="antWorkspaceConfiguration">
 910 |     <option name="IS_AUTOSCROLL_TO_SOURCE" value="false" />
 911 |     <option name="FILTER_TARGETS" value="false" />
 912 |   </component>
 913 |   <component name="editorHistoryManager">
 914 |     <entry file="file://$PROJECT_DIR$/../Java_concurrent/src/chapter1/DeadLockDemo.java">
 915 |       <provider selected="true" editor-type-id="text-editor">
 916 |         <state relative-caret-position="665">
 917 |           <caret line="37" column="11" lean-forward="false" selection-start-line="37" selection-start-column="11" selection-end-line="37" selection-end-column="11" />
 918 |         </state>
 919 |       </provider>
 920 |     </entry>
 921 |     <entry file="file://$PROJECT_DIR$/../Java_concurrent/src/chapter3/chapter3.md">
 922 |       <provider selected="true" editor-type-id="split-provider[text-editor;markdown-preview-editor]">
 923 |         <state split_layout="SPLIT">
 924 |           <first_editor relative-caret-position="3173">
 925 |             <caret line="167" column="47" lean-forward="false" selection-start-line="167" selection-start-column="47" selection-end-line="167" selection-end-column="47" />
 926 |           </first_editor>
 927 |           <second_editor />
 928 |         </state>
 929 |       </provider>
 930 |     </entry>
 931 |     <entry file="file://$PROJECT_DIR$/../Java_concurrent/src/chapter1/chapter1.md">
 932 |       <provider selected="true" editor-type-id="split-provider[text-editor;markdown-preview-editor]">
 933 |         <state split_layout="SPLIT">
 934 |           <first_editor relative-caret-position="684">
 935 |             <caret line="36" column="17" lean-forward="false" selection-start-line="36" selection-start-column="17" selection-end-line="36" selection-end-column="17" />
 936 |           </first_editor>
 937 |           <second_editor />
 938 |         </state>
 939 |       </provider>
 940 |     </entry>
 941 |     <entry file="file://$PROJECT_DIR$/../Java_concurrent/src/chapter2/chapter2.md">
 942 |       <provider selected="true" editor-type-id="split-provider[text-editor;markdown-preview-editor]">
 943 |         <state split_layout="SPLIT">
 944 |           <first_editor relative-caret-position="3591">
 945 |             <caret line="189" column="17" lean-forward="false" selection-start-line="189" selection-start-column="17" selection-end-line="189" selection-end-column="17" />
 946 |           </first_editor>
 947 |           <second_editor />
 948 |         </state>
 949 |       </provider>
 950 |     </entry>
 951 |     <entry file="jar://C:/Program Files/Java/jdk1.8.0_77/src.zip!/java/util/concurrent/LinkedTransferQueue.java">
 952 |       <provider selected="true" editor-type-id="text-editor">
 953 |         <state relative-caret-position="209">
 954 |           <caret line="53" column="69" lean-forward="false" selection-start-line="53" selection-start-column="69" selection-end-line="53" selection-end-column="69" />
 955 |         </state>
 956 |       </provider>
 957 |     </entry>
 958 |     <entry file="file://$PROJECT_DIR$/../Java_concurrent/src/chapter1/DeadLockDemo.java">
 959 |       <provider selected="true" editor-type-id="text-editor">
 960 |         <state relative-caret-position="665">
 961 |           <caret line="37" column="11" lean-forward="false" selection-start-line="37" selection-start-column="11" selection-end-line="37" selection-end-column="11" />
 962 |         </state>
 963 |       </provider>
 964 |     </entry>
 965 |     <entry file="jar://C:/Program Files/Java/jdk1.8.0_77/src.zip!/java/lang/Runnable.java">
 966 |       <provider selected="true" editor-type-id="text-editor">
 967 |         <state relative-caret-position="836">
 968 |           <caret line="67" column="20" lean-forward="false" selection-start-line="67" selection-start-column="20" selection-end-line="67" selection-end-column="25" />
 969 |         </state>
 970 |       </provider>
 971 |     </entry>
 972 |     <entry file="file://$PROJECT_DIR$/../Java_concurrent/src/chapter2/Counter.java">
 973 |       <provider selected="true" editor-type-id="text-editor">
 974 |         <state relative-caret-position="532">
 975 |           <caret line="32" column="46" lean-forward="true" selection-start-line="32" selection-start-column="46" selection-end-line="32" selection-end-column="46" />
 976 |         </state>
 977 |       </provider>
 978 |     </entry>
 979 |     <entry file="file://$PROJECT_DIR$/../Java_concurrent/src/chapter1/chapter1.md">
 980 |       <provider selected="true" editor-type-id="split-provider[text-editor;markdown-preview-editor]">
 981 |         <state split_layout="SPLIT">
 982 |           <first_editor relative-caret-position="684">
 983 |             <caret line="36" column="17" lean-forward="false" selection-start-line="36" selection-start-column="17" selection-end-line="36" selection-end-column="17" />
 984 |           </first_editor>
 985 |           <second_editor />
 986 |         </state>
 987 |       </provider>
 988 |     </entry>
 989 |     <entry file="jar://C:/Program Files/Java/jdk1.8.0_77/src.zip!/java/util/concurrent/LinkedTransferQueue.java">
 990 |       <provider selected="true" editor-type-id="text-editor">
 991 |         <state relative-caret-position="1007">
 992 |           <caret line="53" column="69" lean-forward="true" selection-start-line="53" selection-start-column="69" selection-end-line="53" selection-end-column="69" />
 993 |         </state>
 994 |       </provider>
 995 |     </entry>
 996 |     <entry file="file://$PROJECT_DIR$/../Java_concurrent/src/chapter1/DeadLockDemo.java">
 997 |       <provider selected="true" editor-type-id="text-editor">
 998 |         <state relative-caret-position="665">
 999 |           <caret line="37" column="11" lean-forward="true" selection-start-line="37" selection-start-column="11" selection-end-line="37" selection-end-column="11" />
1000 |         </state>
1001 |       </provider>
1002 |     </entry>
1003 |     <entry file="jar://C:/Program Files/Java/jdk1.8.0_77/src.zip!/java/lang/Runnable.java">
1004 |       <provider selected="true" editor-type-id="text-editor">
1005 |         <state relative-caret-position="836">
1006 |           <caret line="67" column="20" lean-forward="false" selection-start-line="67" selection-start-column="20" selection-end-line="67" selection-end-column="25" />
1007 |         </state>
1008 |       </provider>
1009 |     </entry>
1010 |     <entry file="file://$PROJECT_DIR$/../Java_concurrent/src/chapter2/chapter2.md">
1011 |       <provider selected="true" editor-type-id="split-provider[text-editor;markdown-preview-editor]">
1012 |         <state split_layout="SPLIT">
1013 |           <first_editor relative-caret-position="1425">
1014 |             <caret line="75" column="0" lean-forward="true" selection-start-line="75" selection-start-column="0" selection-end-line="75" selection-end-column="0" />
1015 |           </first_editor>
1016 |           <second_editor />
1017 |         </state>
1018 |       </provider>
1019 |     </entry>
1020 |     <entry file="jar://C:/Program Files/Java/jdk1.8.0_77/src.zip!/java/lang/Runnable.java">
1021 |       <provider selected="true" editor-type-id="text-editor">
1022 |         <state relative-caret-position="836">
1023 |           <caret line="67" column="20" lean-forward="false" selection-start-line="67" selection-start-column="20" selection-end-line="67" selection-end-column="25" />
1024 |         </state>
1025 |       </provider>
1026 |     </entry>
1027 |     <entry file="file://$PROJECT_DIR$/../Java_concurrent/src/chapter1/DeadLockDemo.java">
1028 |       <provider selected="true" editor-type-id="text-editor">
1029 |         <state relative-caret-position="665">
1030 |           <caret line="37" column="11" lean-forward="false" selection-start-line="37" selection-start-column="11" selection-end-line="37" selection-end-column="11" />
1031 |         </state>
1032 |       </provider>
1033 |     </entry>
1034 |     <entry file="jar://C:/Program Files/Java/jdk1.8.0_77/src.zip!/java/util/concurrent/LinkedTransferQueue.java">
1035 |       <provider selected="true" editor-type-id="text-editor">
1036 |         <state relative-caret-position="209">
1037 |           <caret line="53" column="69" lean-forward="false" selection-start-line="53" selection-start-column="69" selection-end-line="53" selection-end-column="69" />
1038 |         </state>
1039 |       </provider>
1040 |     </entry>
1041 |     <entry file="file://$PROJECT_DIR$/../Java_concurrent/src/chapter2/Counter.java">
1042 |       <provider selected="true" editor-type-id="text-editor">
1043 |         <state relative-caret-position="399">
1044 |           <caret line="23" column="0" lean-forward="false" selection-start-line="23" selection-start-column="0" selection-end-line="23" selection-end-column="0" />
1045 |         </state>
1046 |       </provider>
1047 |     </entry>
1048 |     <entry file="file://$PROJECT_DIR$/../Java_concurrent/src/chapter1/chapter1.md">
1049 |       <provider selected="true" editor-type-id="split-provider[text-editor;markdown-preview-editor]">
1050 |         <state split_layout="SPLIT">
1051 |           <first_editor relative-caret-position="703">
1052 |             <caret line="37" column="0" lean-forward="false" selection-start-line="0" selection-start-column="0" selection-end-line="37" selection-end-column="0" />
1053 |           </first_editor>
1054 |           <second_editor />
1055 |         </state>
1056 |       </provider>
1057 |     </entry>
1058 |     <entry file="file://$PROJECT_DIR$/../Java_concurrent/src/chapter2/chapter2.md">
1059 |       <provider selected="true" editor-type-id="split-provider[text-editor;markdown-preview-editor]">
1060 |         <state split_layout="SPLIT">
1061 |           <first_editor relative-caret-position="3344">
1062 |             <caret line="176" column="13" lean-forward="false" selection-start-line="176" selection-start-column="13" selection-end-line="176" selection-end-column="13" />
1063 |           </first_editor>
1064 |           <second_editor />
1065 |         </state>
1066 |       </provider>
1067 |     </entry>
1068 |     <entry file="file://$PROJECT_DIR$/../Java_concurrent/src/chapter3/ReorderExample.java" />
1069 |     <entry file="file://$PROJECT_DIR$/../Java_concurrent/src/chapter3/ReentrantLockExample.java">
1070 |       <provider selected="true" editor-type-id="text-editor">
1071 |         <state relative-caret-position="209">
1072 |           <caret line="12" column="13" lean-forward="false" selection-start-line="12" selection-start-column="13" selection-end-line="12" selection-end-column="13" />
1073 |         </state>
1074 |       </provider>
1075 |     </entry>
1076 |     <entry file="jar://C:/Program Files/Java/jdk1.8.0_77/src.zip!/java/util/concurrent/locks/ReentrantLock.java">
1077 |       <provider selected="true" editor-type-id="text-editor">
1078 |         <state relative-caret-position="1862">
1079 |           <caret line="132" column="36" lean-forward="false" selection-start-line="132" selection-start-column="36" selection-end-line="132" selection-end-column="36" />
1080 |         </state>
1081 |       </provider>
1082 |     </entry>
1083 |     <entry file="file://$PROJECT_DIR$/../Java_concurrent/src/chapter3/chapter3.md">
1084 |       <provider selected="true" editor-type-id="split-provider[text-editor;markdown-preview-editor]">
1085 |         <state split_layout="SPLIT">
1086 |           <first_editor relative-caret-position="3496">
1087 |             <caret line="184" column="26" lean-forward="false" selection-start-line="184" selection-start-column="26" selection-end-line="184" selection-end-column="26" />
1088 |           </first_editor>
1089 |           <second_editor />
1090 |         </state>
1091 |       </provider>
1092 |     </entry>
1093 |     <entry file="file://$PROJECT_DIR$/../Java_concurrent/src/chapter4/MultiThread.java">
1094 |       <provider selected="true" editor-type-id="text-editor">
1095 |         <state relative-caret-position="266">
1096 |           <caret line="16" column="91" lean-forward="false" selection-start-line="16" selection-start-column="91" selection-end-line="16" selection-end-column="91" />
1097 |         </state>
1098 |       </provider>
1099 |     </entry>
1100 |     <entry file="file://$PROJECT_DIR$/../Java_concurrent/src/chapter4/SleepUtils.java">
1101 |       <provider selected="true" editor-type-id="text-editor">
1102 |         <state relative-caret-position="247">
1103 |           <caret line="13" column="12" lean-forward="false" selection-start-line="13" selection-start-column="12" selection-end-line="13" selection-end-column="12" />
1104 |         </state>
1105 |       </provider>
1106 |     </entry>
1107 |     <entry file="file://$PROJECT_DIR$/../Java_concurrent/src/chapter4/Interrupted.java">
1108 |       <provider selected="true" editor-type-id="text-editor">
1109 |         <state relative-caret-position="912">
1110 |           <caret line="48" column="27" lean-forward="false" selection-start-line="48" selection-start-column="27" selection-end-line="48" selection-end-column="27" />
1111 |         </state>
1112 |       </provider>
1113 |     </entry>
1114 |     <entry file="file://$PROJECT_DIR$/../Java_concurrent/src/chapter4/WaitNotify.java">
1115 |       <provider selected="true" editor-type-id="text-editor">
1116 |         <state relative-caret-position="779">
1117 |           <caret line="45" column="32" lean-forward="false" selection-start-line="45" selection-start-column="32" selection-end-line="45" selection-end-column="32" />
1118 |         </state>
1119 |       </provider>
1120 |     </entry>
1121 |     <entry file="file://$PROJECT_DIR$/../Java_concurrent/src/chapter4/Join.java">
1122 |       <provider selected="true" editor-type-id="text-editor">
1123 |         <state relative-caret-position="665">
1124 |           <caret line="37" column="72" lean-forward="false" selection-start-line="37" selection-start-column="72" selection-end-line="37" selection-end-column="72" />
1125 |         </state>
1126 |       </provider>
1127 |     </entry>
1128 |     <entry file="file://$PROJECT_DIR$/../Java_concurrent/src/chapter4/Profiler.java">
1129 |       <provider selected="true" editor-type-id="text-editor">
1130 |         <state relative-caret-position="380">
1131 |           <caret line="27" column="34" lean-forward="false" selection-start-line="27" selection-start-column="34" selection-end-line="27" selection-end-column="34" />
1132 |         </state>
1133 |       </provider>
1134 |     </entry>
1135 |     <entry file="file://$PROJECT_DIR$/../Java_concurrent/src/chapter4/ConnectionPool.java">
1136 |       <provider selected="true" editor-type-id="text-editor">
1137 |         <state relative-caret-position="665">
1138 |           <caret line="36" column="42" lean-forward="false" selection-start-line="36" selection-start-column="42" selection-end-line="36" selection-end-column="42" />
1139 |         </state>
1140 |       </provider>
1141 |     </entry>
1142 |     <entry file="file://$PROJECT_DIR$/../Java_concurrent/src/chapter4/PoolTest.java">
1143 |       <provider selected="true" editor-type-id="text-editor">
1144 |         <state relative-caret-position="1178">
1145 |           <caret line="64" column="46" lean-forward="false" selection-start-line="64" selection-start-column="46" selection-end-line="64" selection-end-column="46" />
1146 |         </state>
1147 |       </provider>
1148 |     </entry>
1149 |     <entry file="file://$PROJECT_DIR$/../Java_concurrent/src/chapter4/ConnectionDriver.java">
1150 |       <provider selected="true" editor-type-id="text-editor">
1151 |         <state relative-caret-position="247">
1152 |           <caret line="17" column="30" lean-forward="false" selection-start-line="17" selection-start-column="30" selection-end-line="17" selection-end-column="30" />
1153 |         </state>
1154 |       </provider>
1155 |     </entry>
1156 |     <entry file="file://$PROJECT_DIR$/../Java_concurrent/src/chapter4/ThreadPool.java">
1157 |       <provider selected="true" editor-type-id="text-editor">
1158 |         <state relative-caret-position="304">
1159 |           <caret line="16" column="0" lean-forward="false" selection-start-line="16" selection-start-column="0" selection-end-line="16" selection-end-column="0" />
1160 |           <folding />
1161 |         </state>
1162 |       </provider>
1163 |     </entry>
1164 |     <entry file="file://$PROJECT_DIR$/../Java_concurrent/src/chapter4/DefaultThreadPool.java">
1165 |       <provider selected="true" editor-type-id="text-editor">
1166 |         <state relative-caret-position="285">
1167 |           <caret line="20" column="31" lean-forward="false" selection-start-line="20" selection-start-column="31" selection-end-line="20" selection-end-column="31" />
1168 |           <folding>
1169 |             <element signature="imports" expanded="false" />
1170 |             <element signature="e#806#807#0" expanded="false" />
1171 |             <element signature="e#863#864#0" expanded="false" />
1172 |             <element signature="e#2581#2582#0" expanded="false" />
1173 |             <element signature="e#2615#2616#0" expanded="false" />
1174 |             <element signature="e#3467#3468#0" expanded="false" />
1175 |             <element signature="e#3506#3507#0" expanded="false" />
1176 |           </folding>
1177 |         </state>
1178 |       </provider>
1179 |     </entry>
1180 |     <entry file="file://$PROJECT_DIR$/../Java_concurrent/src/chapter5/Mutex.java">
1181 |       <provider selected="true" editor-type-id="text-editor">
1182 |         <state relative-caret-position="1178">
1183 |           <caret line="80" column="39" lean-forward="false" selection-start-line="80" selection-start-column="39" selection-end-line="80" selection-end-column="39" />
1184 |           <folding>
1185 |             <element signature="imports" expanded="false" />
1186 |             <element signature="e#415#416#0" expanded="false" />
1187 |             <element signature="e#459#460#0" expanded="false" />
1188 |             <element signature="e#1015#1016#0" expanded="false" />
1189 |             <element signature="e#1067#1068#0" expanded="false" />
1190 |             <element signature="e#1155#1156#0" expanded="false" />
1191 |             <element signature="e#1186#1187#0" expanded="false" />
1192 |             <element signature="e#1357#1358#0" expanded="false" />
1193 |             <element signature="e#1398#1399#0" expanded="false" />
1194 |             <element signature="e#1603#1604#0" expanded="false" />
1195 |             <element signature="e#1634#1635#0" expanded="false" />
1196 |             <element signature="e#1687#1688#0" expanded="false" />
1197 |             <element signature="e#1729#1730#0" expanded="false" />
1198 |             <element signature="e#1761#1762#0" expanded="false" />
1199 |             <element signature="e#1808#1809#0" expanded="false" />
1200 |             <element signature="e#1848#1849#0" expanded="false" />
1201 |             <element signature="e#1894#1895#0" expanded="false" />
1202 |           </folding>
1203 |         </state>
1204 |       </provider>
1205 |     </entry>
1206 |     <entry file="file://$USER_HOME$/Desktop/861438-20170217172109816-1400916986.png">
1207 |       <provider selected="true" editor-type-id="images">
1208 |         <state />
1209 |       </provider>
1210 |     </entry>
1211 |     <entry file="jar://C:/Program Files/Java/jdk1.8.0_77/jre/lib/rt.jar!/sun/misc/Unsafe.class">
1212 |       <provider selected="true" editor-type-id="text-editor">
1213 |         <state relative-caret-position="4902">
1214 |           <caret line="303" column="32" lean-forward="false" selection-start-line="303" selection-start-column="32" selection-end-line="303" selection-end-column="32" />
1215 |           <folding />
1216 |         </state>
1217 |       </provider>
1218 |     </entry>
1219 |     <entry file="jar://C:/Program Files/Java/jdk1.8.0_77/src.zip!/java/lang/Thread.java">
1220 |       <provider selected="true" editor-type-id="text-editor">
1221 |         <state relative-caret-position="16169">
1222 |           <caret line="910" column="16" lean-forward="false" selection-start-line="910" selection-start-column="16" selection-end-line="910" selection-end-column="16" />
1223 |           <folding>
1224 |             <element signature="e#0#78741#0" expanded="false" />
1225 |             <element signature="imports" expanded="false" />
1226 |             <element signature="e#5560#5561#0" expanded="false" />
1227 |             <element signature="e#5601#5602#0" expanded="false" />
1228 |             <element signature="e#6683#6684#0" expanded="false" />
1229 |             <element signature="e#6723#6724#0" expanded="false" />
1230 |             <element signature="e#14796#14797#0" expanded="false" />
1231 |             <element signature="e#14860#14861#0" expanded="false" />
1232 |             <element signature="e#15480#15481#0" expanded="false" />
1233 |             <element signature="e#15546#15547#0" expanded="false" />
1234 |             <element signature="e#15734#15735#0" expanded="false" />
1235 |             <element signature="e#15805#15806#0" expanded="false" />
1236 |             <element signature="e#17015#17016#0" expanded="false" />
1237 |             <element signature="e#17082#17083#0" expanded="false" />
1238 |             <element signature="e#17388#17389#0" expanded="false" />
1239 |             <element signature="e#17429#17430#0" expanded="false" />
1240 |             <element signature="e#18347#18348#0" expanded="false" />
1241 |             <element signature="e#18389#18390#0" expanded="false" />
1242 |             <element signature="e#18901#18902#0" expanded="false" />
1243 |             <element signature="e#18944#18945#0" expanded="false" />
1244 |             <element signature="e#21244#21245#0" expanded="false" />
1245 |             <element signature="e#21288#21289#0" expanded="false" />
1246 |             <element signature="e#33357#33358#0" expanded="false" />
1247 |             <element signature="e#33414#33415#0" expanded="false" />
1248 |             <element signature="e#36478#36479#0" expanded="false" />
1249 |             <element signature="e#36536#36537#0" expanded="false" />
1250 |             <element signature="e#37073#37074#0" expanded="false" />
1251 |             <element signature="e#37116#37117#0" expanded="false" />
1252 |             <element signature="e#38390#38391#0" expanded="false" />
1253 |             <element signature="e#38435#38436#0" expanded="false" />
1254 |             <element signature="e#42725#42726#0" expanded="false" />
1255 |             <element signature="e#42756#42757#0" expanded="false" />
1256 |             <element signature="e#43646#43647#0" expanded="false" />
1257 |             <element signature="e#43691#43692#0" expanded="false" />
1258 |             <element signature="e#43948#43949#0" expanded="false" />
1259 |             <element signature="e#43976#43977#0" expanded="false" />
1260 |             <element signature="e#44834#44835#0" expanded="false" />
1261 |             <element signature="e#44903#44904#0" expanded="false" />
1262 |             <element signature="e#46236#46237#0" expanded="false" />
1263 |             <element signature="e#46309#46310#0" expanded="false" />
1264 |             <element signature="e#50771#50772#0" expanded="false" />
1265 |             <element signature="e#50833#50834#0" expanded="false" />
1266 |             <element signature="e#51927#51928#0" expanded="false" />
1267 |             <element signature="e#51956#51957#0" expanded="false" />
1268 |             <element signature="e#64233#65140#0" expanded="false" />
1269 |             <element signature="e#65139#65140#0" expanded="false" />
1270 |             <element signature="e#65707#65708#0" expanded="false" />
1271 |             <element signature="e#65733#65734#0" expanded="false" />
1272 |             <element signature="e#75713#75714#0" expanded="false" />
1273 |             <element signature="e#75785#75786#0" expanded="false" />
1274 |             <element signature="e#76971#76972#0" expanded="false" />
1275 |             <element signature="e#77006#77007#0" expanded="false" />
1276 |           </folding>
1277 |         </state>
1278 |       </provider>
1279 |     </entry>
1280 |     <entry file="jar://C:/Program Files/Java/jdk1.8.0_77/src.zip!/java/util/concurrent/locks/AbstractQueuedSynchronizer.java">
1281 |       <provider selected="true" editor-type-id="text-editor">
1282 |         <state relative-caret-position="21736">
1283 |           <caret line="1199" column="20" lean-forward="false" selection-start-line="1199" selection-start-column="20" selection-end-line="1199" selection-end-column="20" />
1284 |           <folding>
1285 |             <element signature="e#0#90972#0" expanded="false" />
1286 |             <element signature="imports" expanded="false" />
1287 |             <element signature="e#20991#20992#0" expanded="false" />
1288 |             <element signature="e#21042#21043#0" expanded="false" />
1289 |             <element signature="e#22675#22676#0" expanded="false" />
1290 |             <element signature="e#22703#22704#0" expanded="false" />
1291 |             <element signature="e#22933#22934#0" expanded="false" />
1292 |             <element signature="e#22965#22966#0" expanded="false" />
1293 |             <element signature="e#44444#44445#0" expanded="false" />
1294 |             <element signature="e#44501#44502#0" expanded="false" />
1295 |             <element signature="e#45599#45600#0" expanded="false" />
1296 |             <element signature="e#45656#45657#0" expanded="false" />
1297 |             <element signature="e#46422#46423#0" expanded="false" />
1298 |             <element signature="e#46479#46480#0" expanded="false" />
1299 |             <element signature="e#53988#53989#0" expanded="false" />
1300 |             <element signature="e#54023#54024#0" expanded="false" />
1301 |             <element signature="e#54379#54380#0" expanded="false" />
1302 |             <element signature="e#54414#54415#0" expanded="false" />
1303 |             <element signature="e#61323#61331#0" expanded="false" />
1304 |             <element signature="e#61946#61954#0" expanded="false" />
1305 |             <element signature="e#62618#62626#0" expanded="false" />
1306 |             <element signature="e#67632#67633#0" expanded="false" />
1307 |             <element signature="e#67680#67681#0" expanded="false" />
1308 |             <element signature="e#85889#85890#0" expanded="false" />
1309 |             <element signature="e#85959#85960#0" expanded="false" />
1310 |             <element signature="e#88061#88069#0" expanded="false" />
1311 |           </folding>
1312 |         </state>
1313 |       </provider>
1314 |     </entry>
1315 |     <entry file="file://$PROJECT_DIR$/../Java_concurrent/src/chapter5/TwinsLock.java">
1316 |       <provider selected="true" editor-type-id="text-editor">
1317 |         <state relative-caret-position="1292">
1318 |           <caret line="74" column="14" lean-forward="false" selection-start-line="74" selection-start-column="14" selection-end-line="74" selection-end-column="14" />
1319 |           <folding />
1320 |         </state>
1321 |       </provider>
1322 |     </entry>
1323 |     <entry file="file://$PROJECT_DIR$/../Java_concurrent/src/chapter5/TwinsLockTest.java">
1324 |       <provider selected="true" editor-type-id="text-editor">
1325 |         <state relative-caret-position="703">
1326 |           <caret line="39" column="33" lean-forward="false" selection-start-line="39" selection-start-column="33" selection-end-line="39" selection-end-column="33" />
1327 |           <folding />
1328 |         </state>
1329 |       </provider>
1330 |     </entry>
1331 |     <entry file="file://$PROJECT_DIR$/../Java_concurrent/src/chapter5/FairAndUnfairTest.java">
1332 |       <provider selected="true" editor-type-id="text-editor">
1333 |         <state relative-caret-position="399">
1334 |           <caret line="23" column="61" lean-forward="false" selection-start-line="23" selection-start-column="61" selection-end-line="23" selection-end-column="61" />
1335 |           <folding />
1336 |         </state>
1337 |       </provider>
1338 |     </entry>
1339 |     <entry file="jar://C:/Program Files/Java/jdk1.8.0_77/src.zip!/java/util/Map.java">
1340 |       <provider selected="true" editor-type-id="text-editor">
1341 |         <state relative-caret-position="277">
1342 |           <caret line="239" column="6" lean-forward="false" selection-start-line="239" selection-start-column="6" selection-end-line="239" selection-end-column="6" />
1343 |           <folding />
1344 |         </state>
1345 |       </provider>
1346 |     </entry>
1347 |     <entry file="file://$PROJECT_DIR$/../Java_concurrent/src/chapter5/Cache.java">
1348 |       <provider selected="true" editor-type-id="text-editor">
1349 |         <state relative-caret-position="760">
1350 |           <caret line="40" column="23" lean-forward="false" selection-start-line="40" selection-start-column="23" selection-end-line="40" selection-end-column="23" />
1351 |           <folding>
1352 |             <element signature="imports" expanded="false" />
1353 |             <element signature="e#275#290#0" expanded="false" />
1354 |           </folding>
1355 |         </state>
1356 |       </provider>
1357 |     </entry>
1358 |     <entry file="file://$PROJECT_DIR$/../Java_concurrent/src/chapter5/chapter5.md">
1359 |       <provider selected="true" editor-type-id="split-provider[text-editor;markdown-preview-editor]">
1360 |         <state split_layout="SPLIT">
1361 |           <first_editor relative-caret-position="0">
1362 |             <caret line="0" column="0" lean-forward="false" selection-start-line="0" selection-start-column="0" selection-end-line="144" selection-end-column="15" />
1363 |             <folding />
1364 |           </first_editor>
1365 |           <second_editor />
1366 |         </state>
1367 |       </provider>
1368 |     </entry>
1369 |     <entry file="file://$PROJECT_DIR$/../Java_concurrent/src/chapter4/chapter4.md">
1370 |       <provider selected="true" editor-type-id="split-provider[text-editor;markdown-preview-editor]">
1371 |         <state split_layout="SPLIT">
1372 |           <first_editor relative-caret-position="266">
1373 |             <caret line="14" column="9" lean-forward="true" selection-start-line="14" selection-start-column="9" selection-end-line="14" selection-end-column="9" />
1374 |             <folding />
1375 |           </first_editor>
1376 |           <second_editor />
1377 |         </state>
1378 |       </provider>
1379 |     </entry>
1380 |     <entry file="jar://C:/Program Files/Java/jdk1.8.0_77/src.zip!/java/util/concurrent/ConcurrentHashMap.java">
1381 |       <provider selected="true" editor-type-id="text-editor">
1382 |         <state relative-caret-position="-6764">
1383 |           <caret line="336" column="65" lean-forward="false" selection-start-line="336" selection-start-column="65" selection-end-line="336" selection-end-column="65" />
1384 |           <folding />
1385 |         </state>
1386 |       </provider>
1387 |     </entry>
1388 |     <entry file="file://$PROJECT_DIR$/../Java_concurrent/src/chapter6/CountTask.java">
1389 |       <provider selected="true" editor-type-id="text-editor">
1390 |         <state relative-caret-position="791">
1391 |           <caret line="51" column="0" lean-forward="false" selection-start-line="51" selection-start-column="0" selection-end-line="51" selection-end-column="0" />
1392 |           <folding>
1393 |             <element signature="imports" expanded="true" />
1394 |           </folding>
1395 |         </state>
1396 |       </provider>
1397 |     </entry>
1398 |     <entry file="file://$PROJECT_DIR$/../Java_concurrent/src/chapter6/chapter6.md">
1399 |       <provider selected="true" editor-type-id="split-provider[text-editor;markdown-preview-editor]">
1400 |         <state split_layout="SPLIT">
1401 |           <first_editor relative-caret-position="556">
1402 |             <caret line="142" column="10" lean-forward="true" selection-start-line="0" selection-start-column="0" selection-end-line="142" selection-end-column="10" />
1403 |             <folding />
1404 |           </first_editor>
1405 |           <second_editor />
1406 |         </state>
1407 |       </provider>
1408 |     </entry>
1409 |     <entry file="file://$PROJECT_DIR$/../Java_concurrent/src/chapter7/chapter7.md">
1410 |       <provider selected="true" editor-type-id="split-provider[text-editor;markdown-preview-editor]">
1411 |         <state split_layout="SPLIT">
1412 |           <first_editor relative-caret-position="285">
1413 |             <caret line="15" column="0" lean-forward="true" selection-start-line="15" selection-start-column="0" selection-end-line="15" selection-end-column="0" />
1414 |             <folding />
1415 |           </first_editor>
1416 |           <second_editor />
1417 |         </state>
1418 |       </provider>
1419 |     </entry>
1420 |     <entry file="file://$PROJECT_DIR$/../Java_concurrent/src/chapter9/chapter9.md">
1421 |       <provider selected="true" editor-type-id="split-provider[text-editor;markdown-preview-editor]">
1422 |         <state split_layout="SPLIT">
1423 |           <first_editor relative-caret-position="646">
1424 |             <caret line="37" column="0" lean-forward="true" selection-start-line="37" selection-start-column="0" selection-end-line="37" selection-end-column="0" />
1425 |             <folding />
1426 |           </first_editor>
1427 |           <second_editor />
1428 |         </state>
1429 |       </provider>
1430 |     </entry>
1431 |   </component>
1432 | </project>


--------------------------------------------------------------------------------