对并发熟悉吗？说一下synchronized与Lock的区别与使用
知识回顾
线程与进程
一个程序最少需要一个进程，而一个进程最少需要一个线程。关系是线程–>进程–>程序的大致组成结构。所以线程是程序执行流的最小单位，而进程是系统进行资源分配和调度的一个独立单位。
线程类Thread的几个重要方法
- start()方法，调用该方法开始执行该线程；
- join方法，调用该方法等待该线程结束。
- sleep()方法，调用该方法该线程进入等待。
- run()方法，调用该方法直接执行线程的run()方法，但是线程调用start()方法时也会运行run()方法，区别就是一个是由线程调度运行run()方法，一个是直接调用了线程中的run()方法！
看到这里，可能有些人就会问啦，那wait()和notify()呢？要注意，其实wait()与notify()方法是Object的方法，不是Thread的方法！！同时，wait()与notify()会配合使用，分别表示线程挂起和线程恢复。
这里还有一个很常见的问题，顺带提一下：wait()与sleep()的区别，简单来说wait()会释放对象锁而sleep()不会释放对象锁。
线程状态
线程总共有5大状态
- 新建状态：新建线程对象，并没有调用start()方法之前
- 就绪状态：调用start()方法之后线程就进入就绪状态，但是并不是说只要调用start()方法线程就马上变为当前线程，在变为当前线程之前都是为就绪状态。值得一提的是，线程在睡眠和挂起中恢复的时候也会进入就绪状态哦。
- 运行状态：线程被设置为当前线程，开始执行run()方法。就是线程进入运行状态
- 阻塞状态：线程被暂停，比如说调用sleep()方法后线程就进入阻塞状态
- 死亡状态：线程执行结束
锁类型
- 可重入锁：在执行对象中所有同步方法不用再次获得锁
- 可中断锁：在等待获取锁过程中可中断
- 公平锁：按等待获取锁的线程的等待时间进行获取，等待时间长的具有优先获取锁权利
- 读写锁：对资源读取和写入的时候拆分为2部分处理，读的时候可以多线程一起读，写的时候必须同步地写
synchronized与Lock的区别
我把两者的区别分类到了一个表中，方便大家对比：
Lock详细介绍与Demo
Lock接口中我们可以看到主要有个方法，这些方法的功能从注释中可以看出：
- lock()：获取锁，如果锁被占用则一直等待
- unlock()：释放锁
- tryLock()：注意返回类型是boolean，如果获取锁的时候锁被占用就返回false，否则返回true
- tryLock(long time, TimeUnit unit)：比起tryLock()就是给了一个时间期限，保证等待参数时间
- lockInterruptibly()：用该锁的获得方式，如果线程在获取锁的阶段进入了等待，那么可以中断此线程，先去做别的事
下面是Lock一般使用的例子，注意ReentrantLock是Lock接口的实现。
lock()
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()
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释放了锁两种锁的底层实现方式
synchronized
synchronized修饰的代码块是用字节码指令来控制程序（这里不包括热点代码编译成机器码）。两个指令是monitorenter和monitorexit。当一条线程执行时遇到monitorenter指令的时候，它会去尝试获得锁，如果获得锁那么锁计数+1（为什么会加一呢，因为它是一个可重入锁，所以需要用这个锁计数判断锁的情况），如果没有获得锁，那么阻塞。当它遇到monitorexit的时候，锁计数器-1，当计数器为0，那么就释放锁。
使用synchronized关键词修饰的方法，并没有通过指令monitorenter和monitorexit来完成，而通过方法中的ACC_SYNCHRONIZED标示符来实现的。
两者本质上没有区别，只是方法的同步是一种隐式的方式来实现，无需通过字节码来完成。
Lock
Lock实现和synchronized不一样，后者是一种悲观锁，底层主要靠volatile和CAS操作实现的。
我要说的是：尽可能去使用synchronized而不要去使用LOCK。
jdk1.6以后对synchronized锁做了哪些优化
为了提升性能，在JDK 1.6引入偏向锁、轻量级锁、重量级锁，用来减少锁竞争带来的上下文切换。
主要是借助JDK 1.6新增的Java对象头，实现了锁升级功能。
- 在JDK 1.6的JVM中，对象实例在堆内存中被分为三部分：对象头、实例数据、对齐填充
- 对象头的组成部分：对象标记（Mark Word）、指向类的指针、数组长度（可选，数组类型时才有）
- Mark Word记录了对象和锁有关的信息，在64位的JVM中，Mark Word为64 bit
- 锁升级功能主要依赖于Mark Word中锁标志位和是否偏向锁标志位
- synchronized同步锁的升级优化路径：偏向锁 -> 轻量级锁 -> 重量级锁
线程自旋和适应性自旋
java线程其实是映射在内核之上的，线程的挂起和恢复会极大的影响开销。很多线程在等待锁的时候，大多数情况下很短的一段时间就获得了锁，所以它们在线程等待的时候，并不需要把线程挂起，而是让他无目的的循环，一般设置10次。这样就避免了线程切换的开销，极大的提升了性能。
而适应性自旋，是赋予了自旋一种学习能力，它并不固定自旋10次。它可以根据它前面线程的自旋情况，从而调整它的自旋，甚至是不经过自旋而直接挂起。
锁消除
什么叫锁消除呢？就是把不必要的同步在编译阶段进行移除。
那么有的小伙伴又迷糊了，我自己写的代码我会不知道这里要不要加锁？我加了锁就是表示这边会有同步呀？
并不是这样，这里所说的锁消除并不一定指代是你写的代码的锁消除，我打一个比方：
在jdk1.5以前，我们的String字符串拼接操作其实底层是StringBuffer来实现的，而在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方法都会同步，通过指针逃逸分析（就是变量不会外泄），我们发现在这段代码并不存在线程安全问题，这个时候就会把这个同步锁消除。
锁粗化
在用synchronized的时候，我们都讲究为了避免大开销，尽量同步代码块要小。那么为什么还要加粗呢？
我们继续以上面的字符串拼接为例，我们知道在这一段代码中，每一个append都需要同步一次，那么我可以把锁粗化到第一个append和最后一个append，即将连续的加锁精简到只加一次锁。
轻量级锁
无竞争条件下，通过CAS消除同步互斥。
偏向锁
无竞争条件下，消除整个同步互斥，连CAS都不操作。
|
参考： |
