共计 7160 个字符，预计需要花费 18 分钟才能阅读完成。
莫听穿林打叶声，何妨吟啸且徐行。
技术点：
1、线程与过程：
在开始之前先把过程与线程进行辨别一下，一个程序起码须要一个过程，而一个过程起码须要一个线程。关系是线程–> 过程–> 程序的大抵组成构造。所以线程是程序执行流的最小单位，而过程是零碎进行资源分配和调度的一个独立单位。以下咱们所有探讨的都是建设在线程根底之上。
2、Thread 的几个重要办法：
咱们先理解一下 Thread 的几个重要办法。
- start() 办法，调用该办法开始执行该线程；
- stop() 办法，调用该办法强制完结该线程执行；
- join 办法，调用该办法期待该线程完结。
- sleep() 办法，调用该办法该线程进入期待。
- run() 办法，调用该办法间接执行线程的 run() 办法，然而线程调用 start() 办法时也会运行 run() 办法，区别就是一个是由线程调度运行 run() 办法，一个是间接调用了线程中的 run() 办法！！
看到这里，可能有些人就会问啦，那 wait() 和 notify() 呢？要留神，其实 wait() 与 notify() 办法是 Object 的办法，不是 Thread 的办法！！同时，wait() 与 notify() 会配合应用，别离示意线程挂起和线程复原。
这里还有一个很常见的问题，顺带提一下：wait() 与 sleep() 的区别，简略来说 wait() 会开释对象锁而 sleep() 不会开释对象锁。这些问题有很多的材料，不再赘述。
3、线程状态：
线程总共有 5 大状态，通过下面第二个知识点的介绍，了解起来就简略了。
- 新建状态：新建线程对象，并没有调用 start() 办法之前
- 就绪状态：调用 start() 办法之后线程就进入就绪状态，然而并不是说只有调用 start() 办法线程就马上变为以后线程，在变为以后线程之前都是为就绪状态。值得一提的是，线程在睡眠和挂起中复原的时候也会进入就绪状态哦。
- 运行状态：线程被设置为以后线程，开始执行 run() 办法。就是线程进入运行状态
- 阻塞状态：线程被暂停，比如说调用 sleep() 办法后线程就进入阻塞状态
- 死亡状态：线程执行完结
4、锁类型
- 可重入锁：在执行对象中所有同步办法不必再次取得锁
- 可中断锁：在期待获取锁过程中可中断
- 偏心锁：按期待获取锁的线程的等待时间进行获取，等待时间长的具备优先获取锁权力
- 读写锁：对资源读取和写入的时候拆分为 2 局部解决，读的时候能够多线程一起读，写的时候必须同步地写
synchronized 与 Lock 的区别
1、我把两者的区别分类到了一个表中，不便大家比照：
或者，看到这里还对 LOCK 所知甚少，那么接下来，咱们进入 LOCK 的深刻学习。
Lock 具体介绍与 Demo
以下是 Lock 接口的源码，笔者修剪之后的后果：
public interface Lock {
/**
* Acquires the lock.
*/
void lock();
/**
* Acquires the lock unless the current thread is
* {@linkplain Thread#interrupt interrupted}.
*/
void lockInterruptibly() throws InterruptedException;
/**
* Acquires the lock only if it is free at the time of invocation.
*/
boolean tryLock();
/**
* Acquires the lock if it is free within the given waiting time and the
* current thread has not been {@linkplain Thread#interrupt interrupted}.
*/
boolean tryLock(long time, TimeUnit unit) throws InterruptedException;
/**
* Releases the lock.
*/
void unlock();}从 Lock 接口中咱们能够看到次要有个办法，这些办法的性能从正文中能够看出：
- lock()：获取锁，如果锁被暂用则始终期待
- unlock()：开释锁
- tryLock(): 留神返回类型是 boolean，如果获取锁的时候锁被占用就返回 false，否则返回 true
- tryLock(long time, TimeUnit unit)：比起 tryLock() 就是给了一个工夫期限，保障期待参数工夫
- lockInterruptibly()：用该锁的取得形式，如果线程在获取锁的阶段进入了期待，那么能够中断此线程，先去做别的事
通过 以上的解释，大抵能够解释在上个局部中“锁类型 (lockInterruptibly())”，“锁状态 (tryLock())”等问题，还有就是后面子所获取的过程我所写的“大抵就是能够尝试取得锁，线程能够不会始终期待”用了“能够”的起因。
上面是 Lock 个别应用的例子，留神 ReentrantLock 是 Lock 接口的实现。
lock()：
package com.malf;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class LockTest {private Lock lock = new ReentrantLock();
// 须要参加同步的办法
private void method(Thread thread) {lock.lock();
try {System.out.println("线程名" + thread.getName() + "取得了锁");
} catch (Exception e) {e.printStackTrace();
} finally {System.out.println("线程名" + thread.getName() + "开释了锁");
lock.unlock();}
}
public static void main(String[] args) {LockTest lockTest = new LockTest();
// 线程 1
Thread t1 = new Thread(new Runnable() {
@Override
public void run() {lockTest.method(Thread.currentThread());
}
}, "t1");
Thread t2 = new Thread(new Runnable() {
@Override
public void run() {lockTest.method(Thread.currentThread());
}
}, "t2");
t1.start();
t2.start();}
}
// 执行状况：线程名 t1 取得了锁
// 线程名 t1 开释了锁
// 线程名 t2 取得了锁
// 线程名 t2 开释了锁 tryLock():
package com.malf;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class LockTest {private Lock lock = new ReentrantLock();
// 须要参加同步的办法
private void method(Thread thread) {/*lock.lock();
try {System.out.println("线程名"+thread.getName() + "取得了锁");
}catch(Exception e){e.printStackTrace();
} finally {System.out.println("线程名"+thread.getName() + "开释了锁");
lock.unlock();}*/
if (lock.tryLock()) {
try {System.out.println("线程名" + thread.getName() + "取得了锁");
} catch (Exception e) {e.printStackTrace();
} finally {System.out.println("线程名" + thread.getName() + "开释了锁");
lock.unlock();}
} else {System.out.println("我是" + Thread.currentThread().getName() + "有人占着锁，我就不要啦");
}
}
public static void main(String[] args) {LockTest lockTest = new LockTest();
// 线程 1
Thread t1 = new Thread(new Runnable() {
@Override
public void run() {lockTest.method(Thread.currentThread());
}
}, "t1");
Thread t2 = new Thread(new Runnable() {
@Override
public void run() {lockTest.method(Thread.currentThread());
}
}, "t2");
t1.start();
t2.start();}
}
// 执行后果：线程名 t2 取得了锁
// 我是 t1 有人占着锁，我就不要啦
// 线程名 t2 开释了锁 看到这里置信大家也都会应用如何应用 Lock 了吧，对于 tryLock(long time, TimeUnit unit) 和 lockInterruptibly() 不再赘述。前者次要存在一个等待时间，在测试代码中写入一个等待时间，后者次要是期待中断，会抛出一个中断异样，罕用度不高，喜爱探索能够本人深入研究。
后面比拟重提到“偏心锁”，在这里能够提一下 ReentrantLock 对于均衡锁的定义，在源码中有这么两段：
/**
* Sync object for non-fair locks
*/
static final class NonfairSync extends Sync {
private static final long serialVersionUID = 7316153563782823691L;
/**
* Performs lock. Try immediate barge, backing up to normal
* acquire on failure.
*/
final void lock() {if (compareAndSetState(0, 1))
setExclusiveOwnerThread(Thread.currentThread());
else
acquire(1);
}
protected final boolean tryAcquire(int acquires) {return nonfairTryAcquire(acquires);
}
}
/**
* Sync object for fair locks
*/
static final class FairSync extends Sync {
private static final long serialVersionUID = -3000897897090466540L;
final void lock() {acquire(1);
}
/**
* Fair version of tryAcquire. Don't grant access unless
* recursive call or no waiters or is first.
*/
protected final boolean tryAcquire(int acquires) {final Thread current = Thread.currentThread();
int c = getState();
if (c == 0) {if (!hasQueuedPredecessors() &&
compareAndSetState(0, acquires)) {setExclusiveOwnerThread(current);
return true;
}
} else if (current == getExclusiveOwnerThread()) {
int nextc = c + acquires;
if (nextc < 0)
throw new Error("Maximum lock count exceeded");
setState(nextc);
return true;
}
return false;
}
}从以上源码能够看出在 Lock 中能够本人管制锁是否偏心，而且，默认的是非偏心锁，以下是 ReentrantLock 的构造函数：
public ReentrantLock() {sync = new NonfairSync();// 默认非偏心锁
}补充
1、两种锁的底层实现形式：
synchronized：咱们晓得 java 是用字节码指令来控制程序（这里不包含热点代码编译成机器码）。在字节指令中，存在有 synchronized 所蕴含的代码块，那么会造成 2 段流程的执行。
咱们点击查看 SyncDemo.java 的源码 SyncDemo.class，能够看到如下：
如上就是这段代码段字节码指令，没你想的那么难吧。言归正传，咱们能够清晰段看到，其实 synchronized 映射成字节码指令就是减少来两个指令：monitorenter 和 monitorexit。当一条线程进行执行的遇到 monitorenter 指令的时候，它会去尝试取得锁，如果取得锁那么锁计数 +1（为什么会加一呢，因为它是一个可重入锁，所以须要用这个锁计数判断锁的状况），如果没有取得锁，那么阻塞。当它遇到 monitorexit 的时候，锁计数器 -1，当计数器为 0，那么就开释锁。
那么有的敌人看到这里就纳闷了，那图上有 2 个 monitorexit 呀？马上答复这个问题：下面我以前写的文章也有表述过，synchronized 锁开释有两种机制，一种就是执行完开释；另外一种就是发送异样，虚拟机开释。图中第二个 monitorexit 就是产生异样时执行的流程，这就是我结尾说的“会有 2 个流程存在“。而且，从图中咱们也能够看到在第 13 行，有一个 goto 指令，也就是说如果失常运行完结会跳转到 19 行执行。
这下，你对 synchronized 是不是理解的很清晰了呢。接下来咱们再聊一聊 Lock。
Lock：Lock 实现和 synchronized 不一样，后者是一种乐观锁，它胆子很小，它很怕有人和它抢吃的，所以它每次吃货色前都把本人关起来。而 Lock 呢底层其实是 CAS 乐观锁的体现，它无所谓，他人抢了它吃的，它从新去拿吃的就好啦，所以它很乐观。具体底层怎么实现，博主不在细述，有机会的话，我会对 concurrent 包上面的机制好好和大家说说，如果面试问起，你就说底层次要靠 volatile 和 CAS 操作实现的。
当初，才是我真正想在这篇博文前面加的，我要说的是：尽可能去应用 synchronized 而不要去应用 LOCK
什么概念呢？我和大家打个比方：你叫 jdk，你生了一个孩子叫 synchronized，起初呢，你领养了一个孩子叫 LOCK。起初，LOCK 刚来到新家的时候，它很乖，很懂事，各个方面都体现的比 synchronized 好。你很开心，然而你内心深处又有一点淡淡的难过，你不心愿你本人亲生的孩子居然还不如一个领养的孩子灵巧。这个时候，你对亲生的孩子教育更加粗浅了，你想证实，你的亲生孩子 synchronized 并不会比领养的孩子 LOCK 差。（博主只是打个比方）
那如何教育呢？
在 jdk1.6~jdk1.7 的时候，也就是 synchronized16、7 岁的时候，你作为爸爸，你给他优化了，具体优化在哪里呢：
1、线程自旋和适应性自旋
咱们晓得，java’线程其实是映射在内核之上的，线程的挂起和复原会极大的影响开销。并且 jdk 官网人员发现，很多线程在期待锁的时候，在很短的一段时间就取得了锁，所以它们在线程期待的时候，并不需要把线程挂起，而是让他无目标的循环，个别设置 10 次。这样就防止了线程切换的开销，极大的晋升了性能。
而适应性自旋，是赋予了自旋一种学习能力，它并不固定自旋 10 次一下。他能够依据它后面线程的自旋状况，从而调整它的自旋，甚至是不通过自旋而间接挂起。
2、锁打消
什么叫锁打消呢？就是把不必要的同步在编译阶段进行移除。
那么有的小伙伴又迷糊了，我本人写的代码我会不晓得这里要不要加锁？我加了锁就是示意这边会有同步呀？
并不是这样，这里所说的锁打消并不一定指代是你写的代码的锁打消，我打一个比如：
在 jdk1.5 以前，咱们的 String 字符串拼接操作其实底层是 StringBuffer 来实现的（这个大家能够用我后面介绍的办法，写一个简略的 demo，而后查看 class 文件中的字节码指令就分明了），而在 jdk1.5 之后，那么是用 StringBuilder 来拼接的。咱们思考后面的状况，比方如下代码：
String str1="qwe";
String str2="asd";
String str3=str1+str2;底层实现会变成这样：
StringBuffer sb = new StringBuffer();
sb.append("qwe");
sb.append("asd");咱们晓得，StringBuffer 是一个线程平安的类，也就是说两个 append 办法都会同步，通过指针逃逸剖析（就是变量不会外泄），咱们发现在这段代码并不存在线程平安问题，这个时候就会把这个同步锁打消。
3、锁粗化
在用 synchronized 的时候，咱们都考究为了防止大开销，尽量同步代码块要小。那么为什么还要加粗呢？
咱们持续以下面的字符串拼接为例，咱们晓得在这一段代码中，每一个 append 都须要同步一次，那么我能够把锁粗化到第一个 append 和最初一个 append（这里不要去纠结后面的锁打消，我只是打个比方）