锁是什么
synchronize
- vt ：使同步；使同时发生.
- vi ：与…同时发生；与…一起发生,
多线程共享一个内存资源，每个线程都从主内存copy资源到自己的工作内存中，大家都各改各的资源，再写入到主内存中，线程并发执行下，就可能会导致主内存数据失帧，产生的数据与我们预期的不一致。synchronize就是使线程的工作内存与主内存的数据进行同步。
公平锁、非公平锁
就是线程是否按时间有序的获取锁，还是无序的获取锁。Object的notify()和notifyAll()方法都是唤醒正在阻塞获取锁的线程，前者随机唤醒一个线程获取锁，后者唤醒全部线程去争抢锁。都是随机的获取锁，可知synchronized同步是非公平锁。
公平锁的实现靠Lock对象，我们再他的构造方法中可以设置是否是公平锁。
public ReentrantLock(boolean var1) {
this.sync = (ReentrantLock.Sync)(var1 ? new ReentrantLock.FairSync() : new ReentrantLock.NonfairSync());
}重入锁（递归锁）
线程可以进入任何一个它己经拥有的锁所同步着的代码块，递归比较好理解，就是最外层获取到锁，那么子方法的锁都一并获取到，下面是代码演示。其实锁都是重入锁，这个概念理解一下即可，如果不是则非常容易照成死锁。
public class Test {
public static void main(String[] args) throws Exception {
Test test = new Test();
new Thread(() -> {
test.test1();
}, "t1").start();
new Thread(() -> {
test.test2();
}, "t2").start();
new Thread(() -> {
test.test3();
}, "t3").start();
}
private synchronized void test1() {
System.out.println(Thread.currentThread().getName() + " sync. invoke test1()");
test2();
}
private synchronized void test2() {
System.out.println(Thread.currentThread().getName() + " sync. invoke test2()");
test3();
}
private synchronized void test3() {
System.out.println(Thread.currentThread().getName() + " sync. invoke test3()");
}
}自旋锁
自：线程自己
旋：循环
锁：同步
相对于互斥锁，如果资源已经被占用，资源申请者只能进入阻塞状态。但是自旋锁不会引起调用者阻塞，如果自旋锁已经被别的执行单元保持，调用者就一直循环在那里看是否该自旋锁的保持者已经释放了锁。自旋锁的效率远高于互斥锁。我们可以拿一个JUC中原子引用包的AtomicInteger源码来演示。（这个没有加synchronized、lock，主要靠判断当前主内存的值是否符合我们的预期值，如果是则修改，这个同步是靠我们的预期值来维护的）
public final int getAndUpdate(IntUnaryOperator var1) {
int var2;
int var3;
do {
var2 = this.get();
var3 = var1.applyAsInt(var2);
} while(!this.compareAndSet(var2, var3));
return var2;
}读写锁
读写锁把对共享资源的访问者划分成读者和写者，读者只对共享资源进行读访问，写者则需要对共享资源进行写操作。它允许同时有多个读者来访问共享资源，能提高并发性。而写者是排他性的。
只要理解：读读可以共享锁（多线程并发读取），读写不能共存（多线程阻塞，单线程运行），写写不能共存（多线程阻塞，单线程运行）。
代码演示：并发执行，写不能共存，只能顺序执行。完毕后，读取时可以并发读取。
public class Test {
public static void main(String[] args) throws Exception {
Cache cache = new Cache();
for (int i = 0; i < 5; i++) {
int finalI = i;
new Thread(() -> {
cache.put(finalI, Thread.currentThread().getName());
}, "put" + String.valueOf(i)).start();
}
for (int i = 0; i < 5; i++) {
int finalI = i;
new Thread(() -> {
cache.get(finalI);
}, "get" + String.valueOf(i)).start();
}
}
}
//资源类
class Cache {
//共享数据
private volatile Map<Integer, String> map = new HashMap<>();
//读写锁
private ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
void put(Integer key, String value) {
//写锁定
lock.writeLock().lock();
try {
System.out.println(Thread.currentThread().getName() + "\t 正在写入 = " + key);
//模拟 暂停一会
try {
TimeUnit.MILLISECONDS.sleep(300);
} catch (InterruptedException e) {
e.printStackTrace();
}
//写数据
map.put(key, value);
System.out.println(Thread.currentThread().getName() + "\t 写入完成 = ");
} catch (Exception e) {
e.printStackTrace();
} finally {
lock.writeLock().unlock();
}
}
void get(Integer key) {
//读锁
lock.readLock().lock();
try {
System.out.println(Thread.currentThread().getName() + "\t 正在读取 = ");
//模拟 暂停一会
try {
TimeUnit.MILLISECONDS.sleep(300);
} catch (InterruptedException e) {
e.printStackTrace();
}
//读数据
Object o = map.get(key);
System.out.println(Thread.currentThread().getName() + "\t 读取完成 = " + o);
} catch (Exception e) {
e.printStackTrace();
} finally {
lock.readLock().unlock();
}
}
}死锁
多线程的编程过程中，我们首先要保证线程安全性，对共享变量进行加锁。但是加太多锁，并发性又加降低。为了保证并发性能，所以加锁的同时也要注意锁的粒度，尽可能让锁的粒度变细（就像synchronized尽量不要放到方法上，要放到具体的同步代码块上）。但是锁的粒度变细，就会碰到死锁的问题。
代码演示：单线程请求下没有问题，但是多线程情况下就会又线程安全问题（假设from同时向多个帐号转账，可能会出现余额少减的情况，因为amount并没有同步，多线程都可以读写）。所以我们要加锁，保证from不会少减，to不会少增。
public class Test {
//模拟 转账
void transfer(Account from, Account to, int amount) {
synchronized (from) {
synchronized (to) {
//转出 扣减
from.setAmount(from.getAmount() - amount);
//转入 增加
to.setAmount(to.getAmount() + amount);
}
}
}
}
class Account {
void setAmount(int amount) {
}
int getAmount() {
return 0;
}
}进一步分析：线程在运行方法时，是可以在任何地方进行线程切换的，甚至是在一条语句中间。如果设想用户AB同时相互转账，恰好两个线程都获取到的第一行的锁，然后又在等待获取第二行的锁。这样子就发生死锁了。
总结：死锁的条件
- 互斥等待
- hold and wait 拿到锁 等待另外的锁
- 循环等待
- 无法剥夺的等待 没有超时时间
满足上面4条就会发生死锁，我们只要破除其中一个就可以避免死锁。
- 破除互斥等待，一般无法破除，要保证同步。
- 破除hold and wait，只要一次性获取所有锁资源，设置一个全局锁。
- 破除循环等待，按顺序获取资源，可以用主键排序获取锁。
- 破除无法剥夺的等待，设置超时时间。一般不推荐，耗时浪费资源。
上述几种破除都可以，但是都有各自的利弊，开发就是解决一个问题又会引出另外一个问题，再去解决，螺旋向上。
万一发生了死锁，我们在项目中又怎么去排查呢？我们先写个正真的死锁代码。
public class DeadLockDemo {
public static void main(String[] args) {
//俩锁 让其相互等待
String lockA = "A";
String lockB = "B";
new Thread(() -> {
//获取A锁
synchronized (lockA) {
System.out.println(Thread.currentThread().getName() + "\t 拿到lockA锁，等待lockB锁释放");
//等待其他线程获取B锁
try {
TimeUnit.SECONDS.sleep(3);
} catch (InterruptedException e) {
e.printStackTrace();
}
//再去获取B锁
synchronized (lockB) {
System.out.println(Thread.currentThread().getName() + "\t 计算");
}
System.out.println(Thread.currentThread().getName() + "\t 完成");
}
}, "AAA").start();
new Thread(() -> {
//获取B锁
synchronized (lockB) {
System.out.println(Thread.currentThread().getName() + "\t 拿到lockB锁，等待lockA锁释放");
//等待其他线程获取A锁
try {
TimeUnit.SECONDS.sleep(3);
} catch (InterruptedException e) {
e.printStackTrace();
}
//获取A锁
synchronized (lockA) {
System.out.println(Thread.currentThread().getName() + "\t 计算");
}
System.out.println(Thread.currentThread().getName() + "\t 完成");
}
}, "BBB").start();
}
}执行结果
AAA 拿到lockA锁，等待lockB锁释放
BBB 拿到lockB锁，等待lockA锁释放分析死锁：
jps -l #查看java进程信息，查询PID
jstack PID #查看具体的堆栈信息下面是打印出来的，结论发现一个死锁（）
Java stack information for the threads listed above:
===================================================
"BBB":
at 死锁.DeadLockDemo.lambda$main$1(DeadLockDemo.java:45)
- waiting to lock <0x00000000d5ce8bd0> (a java.lang.String)
- locked <0x00000000d5ce8c00> (a java.lang.String)
at 死锁.DeadLockDemo$$Lambda$2/1769597131.run(Unknown Source)
at java.lang.Thread.run(Thread.java:748)
"AAA":
at 死锁.DeadLockDemo.lambda$main$0(DeadLockDemo.java:30)
- waiting to lock <0x00000000d5ce8c00> (a java.lang.String)
- locked <0x00000000d5ce8bd0> (a java.lang.String)
at 死锁.DeadLockDemo$$Lambda$1/97730845.run(Unknown Source)
at java.lang.Thread.run(Thread.java:748)
Found 1 deadlock.也可以用jconsole.exe，选择进程，点击线程，检测死锁。
