1.并发领域核心问题互斥
同一时刻只能一个线程访问共享资源。
Lock解决互斥问题
2.并发领取核心问题同步
线程之间如何通信，协作
Condition解决同步问题
3.为什么要重复造轮子
synchronized已经实现管程，为什么要再实现一遍管程
synchronized性能不好
synchronized在死锁方面，无法破坏不可抢占条件，synchronized申请不到，线程直接阻塞状态了，就是线程的BLOCK状态，线程没有cpu执行权限，而且也不会释放占用的资源
4.重复造的轮子优势是啥
1.响应中断。可以接受中断信号，唤醒线程，就会释放锁，破坏了不可抢占条件。（自己获取的锁，别人抢不到）
2.支持超时。在一段时间内没有获取锁，不进入阻塞状态，而是返回错误，线程也会释放持有的锁，可以破坏不可抢占条件。
3.非阻塞获取锁。获取锁失败，不进入阻塞状态，而直接返回。这个线程有机会会释放曾经的锁
就可以弥补synchronized问题。
对应到Lock接口上的三个方法
// 支持中断的API
void lockInterruptibly()
throws InterruptedException;
// 支持超时的API
boolean tryLock(long time, TimeUnit unit)
throws InterruptedException;
// 支持非阻塞获取锁的API
boolean tryLock();
5.Lock如何保证可见性
synchronized中的可见性，是因为happens-before规则，
synchronized的解锁happens-before的加锁操作
那么Lock呢？
class X {
private final Lock rtl =
new ReentrantLock();
int value;
public void addOne() {
// 获取锁
rtl.lock();
try {
value+=1;
} finally {
// 保证锁能释放
rtl.unlock();
}
}
}
利用了volatile相关的happens-before规则，
ReentrantLock里内嵌了一个volatile的成员变量state，获取锁的时候回读写state的值，解锁的时候也会读写state值。
class SampleLock {
volatile int state;
// 加锁
lock() {
// 省略代码无数
state = 1;
}
// 解锁
unlock() {
// 省略代码无数
state = 0;
}
}
1.顺序性原则，线程T1，value += 1 Happens-before 释放锁的操作unlock()
2.volatile变量规则，由于state = 1会先读取state，所以线程T1的unlock()操作happens-before与线程T2的lock()操作
3.传递性原则，先T1的value += 1 Happens-before 与T2的lock()操作
6.可重入锁
线程可重复获取同一把锁
class X {
private final Lock rtl =
new ReentrantLock();
int value;
public int get() {
// 获取锁
rtl.lock(); ②
try {
return value;
} finally {
// 保证锁能释放
rtl.unlock();
}
}
public void addOne() {
// 获取锁
rtl.lock();
try {
value = 1 + get(); ①
} finally {
// 保证锁能释放
rtl.unlock();
}
}
}
线程T1执行到（1）处，已经获取到锁rtl，在（1）调用get方法，会在（2）再次对rtl进行加锁操作，可以再次加锁成功，非重入锁，那么线程T1就会被阻塞。
7.公平锁与非公平锁
ReentrantLock,两个构造函数,一个无参,一个传fair参数的构造函数
fair参数代表的是锁的公平策略
true就是公平锁,false就是非公平锁
公平与不公平,看的是,锁释放的时候的策略
公平锁,锁释锁,从等待队列中唤醒一个等待的线程,谁等待的时间长,就唤醒谁
非公平锁,释放锁的时候,不提供这个公平保证,可能等待的时间短的反而先被唤醒.
8.用锁的最佳实践
1.永远只在更新对象的成员变量时加锁
2.永远只在访问可变的成员变量时加锁
3.永远不再调用其他对象的方法时加锁