一、进程与线程

进程是资源分配的最小单位，线程是cpu调度的最小单位。线程也被称为轻量级进程。

所有与进程相关的资源，都被记录在PCB中

进程是抢占处理及的调度单位；线程属于某个进程，共享其资源

一个 Java 程序的运行是 main 线程和多个其他线程同时运行。

二、Thread中的start和run方法的区别

调用start()方法会创建一个新的子线程并启动

run()方法只是Thread的一个普通方法的调用，还是在主线程里执行。

三、Thread和Runnable是什么关系？

Thread是实现了Runnable接口的类，是的run支持多线程。

因java类的单一继承原则，推荐多使用Runnable接口

四、如何给run()方法传参？

构造函数传参

成员变量传参

回调函数传参

五、如何实现处理线程的返回值？

实现的方式主要有三种：

主线程等待法

/*private Stringvalue;public void run() {    try {        Thread.currentThread().sleep(5000);    } catch (InterruptedException e) {        e.printStackTrace();    }    value ="we have data now";}*/CycleWait cw = new CycleWait();Thread t = new Thread(cw);t.start();while(cw.value== null){          Thread.currentThread().sleep(100);//如果value一直为空，则线程一直sleep        }

使用Thread类的join()阻塞当前线程，以等待子线程处理完毕

t.join();

通过Callable接口实现：通过FutureTask Or 线程池获取

六、线程的状态？

新建（NEW） ：创建后尚未启动的线程的状态

运行（Runnable） ：包含Running和Ready

无限期等待（Waiting） ：不会被分配CPU执行时间，需要显式被唤醒

没有设置Timeout参数的Object.wait()方法。

没有设置Timeout参数的Thread.join()方法。

LockSupport.park()方法。

限期等待（Timed Waiting） ：在一定时间后会由系统自动唤醒

Thread.sleep()方法。

设置了Timeout参数的Object.wait()方法。

设置了Timeout参数的Thread.join()方法。

LockSupport.parkNanos()方法。

LockSupport.parkUntil()方法。

阻塞（blocked） ：等待获取排它锁

结束 ：已终止线程的状态，线程已经结束执行

七、sleep和wait

sleep是Thread类的方法，wait是Object类中定义的方法

sleep方法可以在任何地方使用

wait方法只能在synchronized方法或者synchronized块中使用

最本质的区别

Thread.sleep只会让出CPU，不会导致锁行为的改变（不会释放锁）

Object.wait不仅让出CPU，还会释放已经占有的同步资源锁

八、notify和notifyAll的区别

notifyAll会让所有处于等待池的线程全部进入锁池去竞争获取锁的机会

notify会随机选取一个处于等待池中的线程进入锁池去竞争获取锁的机会。

九、yield函数

当调用Thread.yield()函数时，会给线程调度器一个当前线程愿意让出CPU使用的暗示，但是线程调度器可能会忽略这个暗示

十、中断函数interrupt()

已经被抛弃的方法

通过调用stop()方法停止线程

目前使用的方法

调用interrupt()，通知线程应该中断了

如果线程处于被阻塞状态，那么线程将立即退出被阻塞状态，并抛出一个InterruptedException异常

如果线程处于正常活动状态，那么会将该线程的中断标志设置为true。被设置中断标志的线程将继续正常运行，不受影响

需要被调用的线程配合中断

在正常运行任务时，经常检查本线程的中断标志位，如果被设置了中断标志就自行停止线程。

如果线程处于正常活动状态，那么会将该线程的中断标志设置为true。被设置中断标志的线程将继续正常运行，不受影响

十一、synchronized

线程安全问题的主要诱因：

存在共享数据（也称临界资源）

存在多条线程共同操作这些共享数据

解决问题的根本办法：同一时刻有且只有一个线程在操作共享数据，其他线程必须等到该线程处理完数据后再对贡献数据进行操作。

互斥锁的特性：

互斥性 ：即在同一时间只允许一个线程持有某个对象锁，通过这种特性来实现多线程的协调机制，这样同一时间只有一个线程对需要同步的代码块（复合操作）进行访问。互斥性也称为操作的原子性。

可见性 ：必须确保在锁被释放之前，对共享变量所做的修改，对于随后获得该锁的另一个线程是可见的（即在获得锁时应该获得最新共享变量的值），否则另一个线程可能是在本地缓存的某个副本上继续操作，从而引起不一致。（一致性？？？paxos？？？raft？？？）

根据获取锁的分类：获取对象锁和获取类锁

获取对象锁的两种用法

同步代码块（synchronized(this)，synchronized(类实例对象)），锁是小括号()中的实例对象。

同步非静态方法（synchronized method），锁是当前对象的实例对象。

获取类锁的两种用法

同步代码块（synchronized(类.class)），锁是小括号()中的类对象（Class对象）。

同步静态方法（synchronized static method）,锁是当前对象的类对象（Class对象）

对象锁和类锁的总结：

有线程访问对象的同步代码块时，另外的线程可以访问该对象的非同步代码块；

若锁住的是同一个对象，一个线程在访问对象的同步代码块时，另一个访问对象的同步代码块的线程会被阻塞；

若锁住的是同一个对象，一个线程在访问对象的同步方法时，另一个访问对象的同步方法的线程会被阻塞；

若锁住的是同一个对象，一个线程在访问对象的同步代码块时，另一个访问对象的同步方法的线程会被阻塞；，反之亦然；

同一个类的不同对象的对象锁互不干扰；

类锁由于也是一种特殊的对象锁，因此表现和上述1、2、3、4一致，而由于一个类只有一把对象锁，所以同一个类的不同对象使用类锁将会是同步的；

类锁和对象锁互不干扰。

十二、synchronized的底层实现原理

1. 实现synchronized的基础

java对象头

Monitor

2. 对象在内存中的布局

对象头

实例数据

对齐填充

对象头的结构：

java的对象头由以下三部分组成：

Mark Word

指向类的指针

数组长度（只有数组对象才有）

Mark Word Mark Word记录了对象和锁有关的信息，当这个对象被synchronized关键字当成同步锁时，围绕这个锁的一系列操作都和Mark Word有关。

Mark Word在32位JVM中的长度是32bit，在64位JVM中长度是64bit。

Mark Word在不同的锁状态下存储的内容不同，在32位JVM中是这么存的：

JVM一般是这样使用锁和Mark Word的：

当没有被当成锁时，这就是一个普通的对象，Mark Word记录对象的HashCode，锁标志位是01，是否偏向锁那一位是0。

当对象被当做同步锁并有一个线程A抢到了锁时，锁标志位还是01，但是否偏向锁那一位改成1，前23bit记录抢到锁的线程id，表示进入偏向锁状态。

当线程A再次试图来获得锁时，JVM发现同步锁对象的标志位是01，是否偏向锁是1，也就是偏向状态，Mark Word中记录的线程id就是线程A自己的id，表示线程A已经获得了这个偏向锁，可以执行同步锁的代码。

当线程B试图获得这个锁时，JVM发现同步锁处于偏向状态，但是Mark Word中的线程id记录的不是B，那么线程B会先用CAS操作试图获得锁，这里的获得锁操作是有可能成功的，因为线程A一般不会自动释放偏向锁。如果抢锁成功，就把Mark Word里的线程id改为线程B的id，代表线程B获得了这个偏向锁，可以执行同步锁代码。如果抢锁失败，则继续执行步骤5。

偏向锁状态抢锁失败，代表当前锁有一定的竞争，偏向锁将升级为轻量级锁。JVM会在当前线程的线程栈中开辟一块单独的空间，里面保存指向对象锁Mark Word的指针，同时在对象锁Mark Word中保存指向这片空间的指针。上述两个保存操作都是CAS操作，如果保存成功，代表线程抢到了同步锁，就把Mark Word中的锁标志位改成00，可以执行同步锁代码。如果保存失败，表示抢锁失败，竞争太激烈，继续执行步骤6。

轻量级锁抢锁失败，JVM会使用自旋锁，自旋锁不是一个锁状态，只是代表不断的重试，尝试抢锁。从JDK1.7开始，自旋锁默认启用，自旋次数由JVM决定。如果抢锁成功则执行同步锁代码，如果失败则继续执行步骤7。

自旋锁重试之后如果抢锁依然失败，同步锁会升级至重量级锁，锁标志位改为10。在这个状态下，未抢到锁的线程都会被阻塞。

Monitor（管程）：每个java对象天生自带了一把看不见的锁

Monitor锁的竞争、获取与释放

十三、自旋锁

许多情况下，共享数据的所状态持续时间较短，切换线程不值得。

通过让线程执行忙循环等待锁的释放，不让出cpu。

缺点：若锁被其他线程长时间占用，会带来许多性能上的开销·

十四、自适应自旋锁

自旋的次数不再固定

由前一次在同一个锁上的自旋时间及锁的拥有者的状态来决定

十五、锁消除

JIT编译时，对运行上下文进行扫描，去除不可能存在竞争的锁。

十六、锁粗化

通过扩大锁的范围，避免反复的加锁解锁

十七、synchronized的四种状态

无锁、偏向锁、轻量级锁、重量级锁

锁膨胀方向：无锁 -> 偏向锁 -> 轻量级锁 -> 重量级锁

偏向锁：减少同一线程获取锁的代价

大多数情况下，锁不存在多线程竞争，总是由同一线程多次获得

核心思想：

如果一个线程获得了锁，那么锁就进入了偏向模式，此时Mark Word的结构也变为偏向锁结构，当该线程再次请求锁时，无需再做任何同步操作，即获取锁的过程只需要检查Mark Word的所标记位为偏向锁以及当前线程ID等于Mark Word的ThreadID即可，这样就省去了大量有关锁申请的操作。

十八、轻量级锁

轻量级锁是由偏向锁升级来的，偏向锁运行在一个线程进入同步块的情况下，当第二个线程加入锁争用的时候，偏向锁就会升级为轻量级锁。

 适用场景： 线程交替执行同步块

若存在同一时间访问同一锁的情况，就会导致轻量级锁膨胀为重量级锁

十九、锁的内存语义

当线程释放锁时，JMM会把该线程对应的本地内存中的共享变量刷新到主内存中。

当线程获取锁时，JMM会把该线程对应的本地内存置为无效。从而使得被监视器保护的临界区代码必须要从主内存中去读取共享变量。

二十、ReenTrantLock

ReentrantLock 是 java.util.concurrent（J.U.C）包中的锁。

publicclassLockExample{privateLocklock=newReentrantLock();publicvoidfunc(){lock.lock();try{for(inti =0; i <10; i++) {                System.out.print(i +" ");            }        }finally{lock.unlock();// 确保释放锁，从而避免发生死锁。}    }}

public staticvoidmain(String[] args) {    LockExample lockExample =newLockExample();    ExecutorService executorService = Executors.newCachedThreadPool();    executorService.execute(() -> lockExample.func());executorService.execute(() -> lockExample.func());}

1. 锁的实现

synchronized 是 JVM 实现的，而 ReentrantLock 是 JDK 实现的。

2. 性能

新版本 Java 对 synchronized 进行了很多优化，例如自旋锁等，synchronized 与 ReentrantLock 大致相同。

3. 等待可中断

当持有锁的线程长期不释放锁的时候，正在等待的线程可以选择放弃等待，改为处理其他事情。

ReentrantLock 可中断，而 synchronized 不行。

4. 公平锁

公平锁是指多个线程在等待同一个锁时，必须按照申请锁的时间顺序来依次获得锁。

synchronized 中的锁是非公平的，ReentrantLock 默认情况下也是非公平的，但是也可以是公平的。

5. 锁绑定多个条件

一个 ReentrantLock 可以同时绑定多个 Condition 对象。

二十一、线程池

1. 为什么要用线程池？

线程池提供了一种限制和管理资源（包括执行一个任务）。 每个线程池还维护一些基本统计信息，例如已完成任务的数量。

这里借用《Java并发编程的艺术》提到的来说一下使用线程池的好处：

降低资源消耗 。 通过重复利用已创建的线程降低线程创建和销毁造成的消耗。

提高响应速度 。 当任务到达时，任务可以不需要的等到线程创建就能立即执行。

提高线程的可管理性 。 线程是稀缺资源，如果无限制的创建，不仅会消耗系统资源，还会降低系统的稳定性，使用线程池可以进行统一的分配，调优和监控。

2. 实现Runnable接口和Callable接口的区别

如果想让线程池执行任务的话需要实现的Runnable接口或Callable接口。 Runnable接口或Callable接口实现类都可以被ThreadPoolExecutor或ScheduledThreadPoolExecutor执行。两者的区别在于 Runnable 接口不会返回结果但是 Callable 接口可以返回结果。

备注： 工具类Executors可以实现Runnable对象和Callable对象之间的相互转换。（Executors.callable（Runnable task）或Executors.callable（Runnable task，Object resule））。

3. 执行execute()方法和submit()方法的区别是什么呢？

execute() 方法用于提交不需要返回值的任务，所以无法判断任务是否被线程池执行成功与否；

submit() 方法用于提交需要返回值的任务。线程池会返回一个Future类型的对象，通过这个Future对象可以判断任务是否执行成功，并且可以通过future的get()方法来获取返回值，get()方法会阻塞当前线程直到任务完成，而使用 get（long timeout，TimeUnit unit）方法则会阻塞当前线程一段时间后立即返回，这时候有可能任务没有执行完。

4. 如何创建线程池

《阿里巴巴Java开发手册》中强制线程池不允许使用 Executors 去创建，而是通过 ThreadPoolExecutor 的方式，这样的处理方式让写的同学更加明确线程池的运行规则，规避资源耗尽的风险。

Executors 返回线程池对象的弊端如下：

FixedThreadPool 和 SingleThreadExecutor ： 允许请求的队列长度为 Integer.MAX_VALUE ，可能堆积大量的请求，从而导致OOM。

CachedThreadPool 和 ScheduledThreadPool ： 允许创建的线程数量为 Integer.MAX_VALUE ，可能会创建大量线程，从而导致OOM。

方式一：通过Executor 框架的工具类Executors来实现 我们可以创建三种类型的ThreadPoolExecutor：

FixedThreadPool ： 该方法返回一个固定线程数量的线程池。该线程池中的线程数量始终不变。当有一个新的任务提交时，线程池中若有空闲线程，则立即执行。若没有，则新的任务会被暂存在一个任务队列中，待有线程空闲时，便处理在任务队列中的任务。

SingleThreadExecutor ： 方法返回一个只有一个线程的线程池。若多余一个任务被提交到该线程池，任务会被保存在一个任务队列中，待线程空闲，按先入先出的顺序执行队列中的任务。

CachedThreadPool ： 该方法返回一个可根据实际情况调整线程数量的线程池。线程池的线程数量不确定，但若有空闲线程可以复用，则会优先使用可复用的线程。若所有线程均在工作，又有新的任务提交，则会创建新的线程处理任务。所有线程在当前任务执行完毕后，将返回线程池进行复用。

二十二、volatile关键字

在 JDK1.2 之前，Java的内存模型实现总是从主存（即共享内存）读取变量，是不需要进行特别的注意的。而在当前的 Java 内存模型下，线程可以把变量保存本地内存比如机器的寄存器）中，而不是直接在主存中进行读写。这就可能造成一个线程在主存中修改了一个变量的值，而另外一个线程还继续使用它在寄存器中的变量值的拷贝，造成数据的不一致。

要解决这个问题，就需要把变量声明为volatile，这就指示 JVM，这个变量是不稳定的，每次使用它都到主存中进行读取。

说白了， volatile 关键字的主要作用就是保证变量的可见性然后还有一个作用是防止指令重排序。

二十三、synchronized 关键字和 volatile 关键字的区别

synchronized关键字和volatile关键字比较

volatile关键字是线程同步的轻量级实现，所以volatile性能肯定比synchronized关键字要好。但是volatile关键字只能用于变量而synchronized关键字可以修饰方法以及代码块。synchronized关键字在JavaSE1.6之后进行了主要包括为了减少获得锁和释放锁带来的性能消耗而引入的偏向锁和轻量级锁以及其它各种优化之后执行效率有了显著提升，实际开发中使用 synchronized 关键字的场景还是更多一些。

多线程访问volatile关键字不会发生阻塞，而synchronized关键字可能会发生阻塞

volatile关键字能保证数据的可见性，但不能保证数据的原子性。synchronized关键字两者都能保证。

volatile关键字主要用于解决变量在多个线程之间的可见性，而 synchronized关键字解决的是多个线程之间访问资源的同步性。

二十四、ThreadLocal

通常情况下，我们创建的变量是可以被任何一个线程访问并修改的。如果想实现每一个线程都有自己的专属本地变量该如何解决呢？ JDK中提供的ThreadLocal类正是为了解决这样的问题。 ThreadLocal类主要解决的就是让每个线程绑定自己的值，可以将ThreadLocal类形象的比喻成存放数据的盒子，盒子中可以存储每个线程的私有数据。

如果你创建了一个ThreadLocal变量，那么访问这个变量的每个线程都会有这个变量的本地副本，这也是ThreadLocal变量名的由来。他们可以使用 get（） 和 set（） 方法来获取默认值或将其值更改为当前线程所存的副本的值，从而避免了线程安全问题。

importjava.text.SimpleDateFormat;importjava.util.Random;publicclassThreadLocalExampleimplementsRunnable{// SimpleDateFormat 不是线程安全的，所以每个线程都要有自己独立的副本privatestaticfinalThreadLocal formatter = ThreadLocal.withInitial(() ->newSimpleDateFormat("yyyyMMdd HHmm"));publicstaticvoidmain(String[] args)throwsInterruptedException{        ThreadLocalExample obj =newThreadLocalExample();for(inti=0; i<10; i++){            Thread t =newThread(obj,""+i);            Thread.sleep(newRandom().nextInt(1000));            t.start();        }    }@Overridepublicvoidrun(){        System.out.println("Thread Name= "+Thread.currentThread().getName()+" default Formatter = "+formatter.get().toPattern());try{            Thread.sleep(newRandom().nextInt(1000));        }catch(InterruptedException e) {            e.printStackTrace();        }//formatter pattern is changed here by thread, but it won't reflect to other threadsformatter.set(newSimpleDateFormat());        System.out.println("Thread Name= "+Thread.currentThread().getName()+" formatter = "+formatter.get().toPattern());    }}

Output:

ThreadName=0defaultFormatter = yyyyMMdd HHmmThreadName=0formatter = yy-M-d ah:mmThreadName=1defaultFormatter = yyyyMMdd HHmmThreadName=2defaultFormatter = yyyyMMdd HHmmThreadName=1formatter = yy-M-d ah:mmThreadName=3defaultFormatter = yyyyMMdd HHmmThreadName=2formatter = yy-M-d ah:mmThreadName=4defaultFormatter = yyyyMMdd HHmmThreadName=3formatter = yy-M-d ah:mmThreadName=4formatter = yy-M-d ah:mmThreadName=5defaultFormatter = yyyyMMdd HHmmThreadName=5formatter = yy-M-d ah:mmThreadName=6defaultFormatter = yyyyMMdd HHmmThreadName=6formatter = yy-M-d ah:mmThreadName=7defaultFormatter = yyyyMMdd HHmmThreadName=7formatter = yy-M-d ah:mmThreadName=8defaultFormatter = yyyyMMdd HHmmThreadName=9defaultFormatter = yyyyMMdd HHmmThreadName=8formatter = yy-M-d ah:mmThreadName=9formatter = yy-M-d ah:mm

原理：

从 Thread类源代码入手。

publicclassThreadimplementsRunnable{ ......//与此线程有关的ThreadLocal值。由ThreadLocal类维护ThreadLocal.ThreadLocalMap threadLocals =null;//与此线程有关的InheritableThreadLocal值。由InheritableThreadLocal类维护ThreadLocal.ThreadLocalMap inheritableThreadLocals =null; ......}

从上面Thread类 源代码可以看出Thread 类中有一个 threadLocals 和 一个 inheritableThreadLocals 变量，它们都是 ThreadLocalMap 类型的变量,我们可以把 ThreadLocalMap 理解为ThreadLocal 类实现的定制化的 HashMap。默认情况下这两个变量都是null，只有当前线程调用 ThreadLocal 类的 set或get方法时才创建它们，实际上调用这两个方法的时候，我们调用的是ThreadLocalMap类对应的 get()、set() 方法。

ThreadLocal类的set()方法

publicvoidset(Tvalue){        Thread t = Thread.currentThread();        ThreadLocalMap map = getMap(t);if(map !=null)            map.set(this,value);elsecreateMap(t,value);    }ThreadLocalMapgetMap(Thread t){returnt.threadLocals;    }

通过上面这些内容，我们足以通过猜测得出结论：最终的变量是放在了当前线程的 ThreadLocalMap 中，并不是存在 ThreadLocal 上，ThreadLocal 可以理解为只是ThreadLocalMap的封装，传递了变量值。 ThrealLocal 类中可以通过Thread.currentThread()获取到当前线程对象后，直接通过getMap(Thread t)可以访问到该线程的ThreadLocalMap对象。

每个Thread中都具备一个ThreadLocalMap，而ThreadLocalMap可以存储以ThreadLocal为key的键值对。 比如我们在同一个线程中声明了两个 ThreadLocal 对象的话，会使用 Thread内部都是使用仅有那个ThreadLocalMap 存放数据的，ThreadLocalMap的 key 就是 ThreadLocal对象，value 就是 ThreadLocal 对象调用set方法设置的值。 ThreadLocal 是 map结构是为了让每个线程可以关联多个 ThreadLocal变量。这也就解释了 ThreadLocal 声明的变量为什么在每一个线程都有自己的专属本地变量。

ThreadLocalMap是ThreadLocal的静态内部类。

二十五、ThreadLocal 内存泄露问题

ThreadLocalMap 中使用的 key 为 ThreadLocal 的弱引用,而 value 是强引用。所以，如果 ThreadLocal 没有被外部强引用的情况下，在垃圾回收的时候会 key 会被清理掉，而 value 不会被清理掉。这样一来，ThreadLocalMap 中就会出现key为null的Entry。假如我们不做任何措施的话，value 永远无法被GC 回收，这个时候就可能会产生内存泄露。ThreadLocalMap实现中已经考虑了这种情况，在调用 set()、get()、remove() 方法的时候，会清理掉 key 为 null 的记录。使用完 ThreadLocal方法后 最好手动调用remove()方法。

staticclassEntryextendsWeakReference<ThreadLocal<?>>{/** The value associated with this ThreadLocal. */Objectvalue;Entry(ThreadLocal k,Objectv) {super(k);                value = v;            }        }

弱引用介绍：

如果一个对象只具有弱引用，那么就类似于可有可无的生活用品。弱引用与软引用的区别在于：只具有弱引用的对象拥有更短暂的生命周期。在垃圾回收器线程扫描它所管辖的内存区域的过程中，一旦发现了只具有弱引用的对象，不管当前内存空间足够与否，都会回收它的内存。不过，由于垃圾回收器是一个优先级很低的线程， 因此不一定会很快发现那些只具有弱引用的对象。

弱引用可以和一个引用队列（ReferenceQueue）联合使用，如果弱引用所引用的对象被垃圾回收，Java虚拟机就会把这个弱引用加入到与之关联的引用队列中去。

二十六、java 线程方法join的简单总结

1. 作用

Thread类中的join方法的主要作用就是同步，它可以使得线程之间的并行执行变为串行执行。具体看代码：

publicclassJoinTest{publicstaticvoidmain(String [] args)throwsInterruptedException{        ThreadJoinTest t1 =newThreadJoinTest("小明");        ThreadJoinTest t2 =newThreadJoinTest("小东");        t1.start();/**join的意思是使得放弃当前线程的执行，并返回对应的线程，例如下面代码的意思就是：

        程序在main线程中调用t1线程的join方法，则main线程放弃cpu控制权，并返回t1线程继续执行直到线程t1执行完毕

        所以结果是t1线程执行完后，才到主线程执行，相当于在main线程中同步t1线程，t1执行完了，main线程才有执行的机会

        */t1.join();        t2.start();    }}classThreadJoinTestextendsThread{publicThreadJoinTest(String name){super(name);    }@Overridepublicvoidrun(){for(inti=0;i<1000;i++){            System.out.println(this.getName() +":"+ i);        }    }}

上面程序结果是先打印完小明线程，在打印小东线程；

上面注释也大概说明了join方法的作用：在A线程中调用了B线程的join()方法时，表示只有当B线程执行完毕时，A线程才能继续执行。注意，这里调用的join方法是没有传参的，join方法其实也可以传递一个参数给它的，具体看下面的简单例子：

publicclassJoinTest{publicstaticvoidmain(String [] args)throwsInterruptedException{        ThreadJoinTest t1 =newThreadJoinTest("小明");        ThreadJoinTest t2 =newThreadJoinTest("小东");        t1.start();/**join方法可以传递参数，join(10)表示main线程会等待t1线程10毫秒，10毫秒过去后，

        * main线程和t1线程之间执行顺序由串行执行变为普通的并行执行

        */t1.join(10);        t2.start();    }}classThreadJoinTestextendsThread{publicThreadJoinTest(String name){super(name);    }@Overridepublicvoidrun(){for(inti=0;i<1000;i++){            System.out.println(this.getName() +":"+ i);        }    }}

上面代码结果是：程序执行前面10毫秒内打印的都是小明线程，10毫秒后，小明和小东程序交替打印。

所以，join方法中如果传入参数，则表示这样的意思：如果A线程中掉用B线程的join(10)，则表示A线程会等待B线程执行10毫秒，10毫秒过后，A、B线程并行执行。需要注意的是，jdk规定，join(0)的意思不是A线程等待B线程0秒，而是A线程等待B线程无限时间，直到B线程执行完毕，即join(0)等价于join()。

2. join与start调用顺序问题

上面的讨论大概知道了join的作用了，那么，如果 join在start前调用，会出现什么后果呢？先看下面的测试结果

publicclassJoinTest{publicstaticvoidmain(String [] args)throwsInterruptedException{        ThreadJoinTest t1 =newThreadJoinTest("小明");        ThreadJoinTest t2 =newThreadJoinTest("小东");/**join方法可以在start方法前调用时，并不能起到同步的作用

        */t1.join();        t1.start();//Thread.yield();t2.start();    }}classThreadJoinTestextendsThread{publicThreadJoinTest(String name){super(name);    }@Overridepublicvoidrun(){for(inti=0;i<1000;i++){            System.out.println(this.getName() +":"+ i);        }    }}

上面代码执行结果是：小明和小东线程交替打印。

所以得到以下结论：join方法必须在线程start方法调用之后调用才有意义。这个也很容易理解：如果一个线程都没有start，那它也就无法同步了。

3. join方法实现原理

有了上面的例子，我们大概知道join方法的作用了，那么，join方法实现的原理是什么呢？

其实，join方法是通过调用线程的wait方法来达到同步的目的的。例如，A线程中调用了B线程的join方法，则相当于A线程调用了B线程的wait方法，在调用了B线程的wait方法后，A线程就会进入阻塞状态，具体看下面的源码：

publicfinalsynchronizedvoidjoin(longmillis)throwsInterruptedException{longbase = System.currentTimeMillis();longnow =0;if(millis <0) {thrownewIllegalArgumentException("timeout value is negative");        }if(millis ==0) {while(isAlive()) {                wait(0);            }        }else{while(isAlive()) {longdelay = millis - now;if(delay <=0) {break;                }                wait(delay);                now = System.currentTimeMillis() - base;            }        }    }

从源码中可以看到：join方法的原理就是调用相应线程的wait方法进行等待操作的，例如A线程中调用了B线程的join方法，则相当于在A线程中调用了B线程的wait方法，当B线程执行完（或者到达等待时间），B线程会自动调用自身的notifyAll方法唤醒A线程，从而达到同步的目的。

二十七、线程安全

多个线程不管以何种方式访问某个类，并且在主调代码中不需要进行同步，都能表现正确的行为。

线程安全有以下几种实现方式：

1. 不可变

不可变（Immutable）的对象一定是线程安全的，不需要再采取任何的线程安全保障措施。只要一个不可变的对象被正确地构建出来，永远也不会看到它在多个线程之中处于不一致的状态。多线程环境下，应当尽量使对象成为不可变，来满足线程安全。

不可变的类型：

final 关键字修饰的基本数据类型

String

枚举类型

Number 部分子类，如 Long 和 Double 等数值包装类型，BigInteger 和 BigDecimal 等大数据类型。但同为 Number 的原子类 AtomicInteger 和 AtomicLong 则是可变的。

对于集合类型，可以使用 Collections.unmodifiableXXX() 方法来获取一个不可变的集合。

publicclassImmutableExample{    publicstaticvoidmain(String[] args) {Map map =newHashMap<>();Map unmodifiableMap = Collections.unmodifiableMap(map);        unmodifiableMap.put("a",1);    }}Exceptioninthread"main"java.lang.UnsupportedOperationException    at java.util.Collections$UnmodifiableMap.put(Collections.java:1457)    at ImmutableExample.main(ImmutableExample.java:9)

Collections.unmodifiableXXX() 先对原始的集合进行拷贝，需要对集合进行修改的方法都直接抛出异常。

publicVput(K key, Vvalue){thrownewUnsupportedOperationException();}

2. 互斥同步

synchronized 和 ReentrantLock。

3. 非阻塞同步

互斥同步最主要的问题就是线程阻塞和唤醒所带来的性能问题，因此这种同步也称为阻塞同步。

互斥同步属于一种悲观的并发策略，总是认为只要不去做正确的同步措施，那就肯定会出现问题。无论共享数据是否真的会出现竞争，它都要进行加锁（这里讨论的是概念模型，实际上虚拟机会优化掉很大一部分不必要的加锁）、用户态核心态转换、维护锁计数器和检查是否有被阻塞的线程需要唤醒等操作。

①. CAS

随着硬件指令集的发展，我们可以使用基于冲突检测的乐观并发策略：先进行操作，如果没有其它线程争用共享数据，那操作就成功了，否则采取补偿措施（不断地重试，直到成功为止）。这种乐观的并发策略的许多实现都不需要将线程阻塞，因此这种同步操作称为非阻塞同步。

乐观锁需要操作和冲突检测这两个步骤具备原子性，这里就不能再使用互斥同步来保证了，只能靠硬件来完成。硬件支持的原子性操作最典型的是：比较并交换（Compare-and-Swap，CAS）。CAS 指令需要有 3 个操作数，分别是内存地址 V、旧的预期值 A 和新值 B。当执行操作时，只有当 V 的值等于 A，才将 V 的值更新为 B。

②. AtomicInteger

J.U.C 包里面的整数原子类 AtomicInteger 的方法调用了 Unsafe 类的 CAS 操作。

以下代码使用了 AtomicInteger 执行了自增的操作。

privateAtomicInteger cnt =newAtomicInteger();publicvoidadd(){    cnt.incrementAndGet();}

以下代码是 incrementAndGet() 的源码，它调用了 Unsafe 的 getAndAddInt() 。

publicfinalint incrementAndGet() {returnunsafe.getAndAddInt(this, valueOffset,1) +1;}

以下代码是 getAndAddInt() 源码，var1 指示对象内存地址，var2 指示该字段相对对象内存地址的偏移，var4 指示操作需要加的数值，这里为 1。通过 getIntVolatile(var1, var2) 得到旧的预期值，通过调用 compareAndSwapInt() 来进行 CAS 比较，如果该字段内存地址中的值等于 var5，那么就更新内存地址为 var1+var2 的变量为 var5+var4。

可以看到 getAndAddInt() 在一个循环中进行，发生冲突的做法是不断的进行重试。

publicfinalintgetAndAddInt(Object var1,longvar2,intvar4){intvar5;do{        var5 =this.getIntVolatile(var1, var2);    }while(!this.compareAndSwapInt(var1, var2, var5, var5 + var4));returnvar5;}

③. ABA

如果一个变量初次读取的时候是 A 值，它的值被改成了 B，后来又被改回为 A，那 CAS 操作就会误认为它从来没有被改变过。

J.U.C 包提供了一个带有标记的原子引用类 AtomicStampedReference 来解决这个问题，它可以通过控制变量值的版本来保证 CAS 的正确性。大部分情况下 ABA 问题不会影响程序并发的正确性，如果需要解决 ABA 问题，改用传统的互斥同步可能会比原子类更高效。

4. 无同步方案

要保证线程安全，并不是一定就要进行同步。如果一个方法本来就不涉及共享数据，那它自然就无须任何同步措施去保证正确性。

①. 栈封闭

多个线程访问同一个方法的局部变量时，不会出现线程安全问题，因为局部变量存储在虚拟机栈中，属于线程私有的。

publicclassStackClosedExample{publicvoidadd100() {        int cnt =0;for(int i =0; i <100; i++) {            cnt++;        }        System.out.println(cnt);    }}public staticvoidmain(String[] args) {    StackClosedExample example =newStackClosedExample();    ExecutorService executorService = Executors.newCachedThreadPool();    executorService.execute(() -> example.add100());executorService.execute(() -> example.add100());executorService.shutdown();}

②. 线程本地存储（Thread Local Storage）

如果一段代码中所需要的数据必须与其他代码共享，那就看看这些共享数据的代码是否能保证在同一个线程中执行。如果能保证，我们就可以把共享数据的可见范围限制在同一个线程之内，这样，无须同步也能保证线程之间不出现数据争用的问题。

符合这种特点的应用并不少见，大部分使用消费队列的架构模式（如“生产者-消费者”模式）都会将产品的消费过程尽量在一个线程中消费完。其中最重要的一个应用实例就是经典 Web 交互模型中的“一个请求对应一个服务器线程”（Thread-per-Request）的处理方式，这种处理方式的广泛应用使得很多 Web 服务端应用都可以使用线程本地存储来解决线程安全问题。

可以使用 java.lang.ThreadLocal 类来实现线程本地存储功能。

对于以下代码，thread1 中设置 threadLocal 为 1，而 thread2 设置 threadLocal 为 2。过了一段时间之后，thread1 读取 threadLocal 依然是 1，不受 thread2 的影响。

publicclassThreadLocalExample{public staticvoidmain(String[] args) {        ThreadLocal threadLocal =newThreadLocal();        Thread thread1 =newThread(() -> {            threadLocal.set(1);try{                Thread.sleep(1000);            }catch(InterruptedException e) {                e.printStackTrace();            }            System.out.println(threadLocal.get());            threadLocal.remove();        });Threadthread2=newThread(() -> {            threadLocal.set(2);            threadLocal.remove();        });thread1.start();thread2.start();    }}

为了理解 ThreadLocal，先看以下代码：

publicclassThreadLocalExample1{public staticvoidmain(String[] args) {        ThreadLocal threadLocal1 =newThreadLocal();        ThreadLocal threadLocal2 =newThreadLocal();        Thread thread1 =newThread(() -> {            threadLocal1.set(1);            threadLocal2.set(1);        });Threadthread2=newThread(() -> {            threadLocal1.set(2);            threadLocal2.set(2);        });thread1.start();thread2.start();    }}

每个 Thread 都有一个 ThreadLocal.ThreadLocalMap 对象。

/* ThreadLocal values pertainingtothis thread. This mapismaintained * by the ThreadLocalclass. */ThreadLocal.ThreadLocalMap threadLocals =null;

当调用一个 ThreadLocal 的 set(T value) 方法时，先得到当前线程的 ThreadLocalMap 对象，然后将 ThreadLocal->value 键值对插入到该 Map 中。

publicvoidset(Tvalue){    Thread t = Thread.currentThread();    ThreadLocalMap map = getMap(t);if(map !=null)        map.set(this,value);elsecreateMap(t,value);}

get() 方法类似。

publicTget() {    Thread t = Thread.currentThread();    ThreadLocalMap map = getMap(t);if(map !=null) {        ThreadLocalMap.Entry e = map.getEntry(this);if(e !=null) {@SuppressWarnings("unchecked")T result = (T)e.value;returnresult;        }    }returnsetInitialValue();}

ThreadLocal 从理论上讲并不是用来解决多线程并发问题的，因为根本不存在多线程竞争。

在一些场景 (尤其是使用线程池) 下，由于 ThreadLocal.ThreadLocalMap 的底层数据结构导致 ThreadLocal 有内存泄漏的情况，应该尽可能在每次使用 ThreadLocal 后手动调用 remove()，以避免出现 ThreadLocal 经典的内存泄漏甚至是造成自身业务混乱的风险。

③. 可重入代码（Reentrant Code）

这种代码也叫做纯代码（Pure Code），可以在代码执行的任何时刻中断它，转而去执行另外一段代码（包括递归调用它本身），而在控制权返回后，原来的程序不会出现任何错误。

可重入代码有一些共同的特征，例如不依赖于存储在堆上的数据和公用的系统资源、用到的状态量都由参数中传入、不调用非可重入的方法等。

二十八、多线程开发良好的实践

给线程起个有意义的名字，这样可以方便找 Bug。

缩小同步范围，从而减少锁争用。例如对于 synchronized，应该尽量使用同步块而不是同步方法。

多用同步工具少用 wait() 和 notify()。首先，CountDownLatch, CyclicBarrier, Semaphore 和 Exchanger 这些同步类简化了编码操作，而用 wait() 和 notify() 很难实现复杂控制流；其次，这些同步类是由最好的企业编写和维护，在后续的 JDK 中还会不断优化和完善。

使用 BlockingQueue 实现生产者消费者问题。

多用并发集合少用同步集合，例如应该使用 ConcurrentHashMap 而不是 Hashtable。

使用本地变量和不可变类来保证线程安全。

使用线程池而不是直接创建线程，这是因为创建线程代价很高，线程池可以有效地利用有限的线程来启动任务。