目录
前言
多线程开发中，同步控制是必不可少的手段。而同步的实现需要用到锁，Java中提供了两种基本的锁，分别是synchronized 和 Lock。两种锁都非常常用，但也各有利弊，下面开始学习。
synchronized用法
synchronized 是Java的关键字，是应用最为广泛的同步工具之一。当它用来修饰一个方法或者一个代码块的时候，能够保证在同一时刻最多只有一个线程执行该段代码，同时，值得说明的是，它是在软件层面依赖JVM实现同步的。
synchronized 的用法很简单，直接用其修饰代码块即可，一般可将其用于修饰方法和代码块，根据修饰地方的不同还有不同的作用域，下面一一介绍。
修饰方法
synchronized 修饰方法分为两种情况：
- 修饰实例方法，作用于当前实例加锁，进入同步代码前要获得当前实例的锁。
- 修饰静态方法，作用于当前类对象加锁，进入同步代码前要获得当前类对象的锁。
修饰实例方法
顾名思义就是修饰类中的实例方法，并且默认是当前对象作为锁的对象，而一个对象只有一把锁，所以同一时刻只能有一个线程执行被同步的方法，等到线程执行完方法后，其他线程才能继续执行被同步的方法。实例代码如下：
public class SyncTest implements Runnable{
//静态变量
public static int TEST_INT = 0;
//被同步的实例方法
public synchronized void increase(){
TEST_INT++;
}
@Override
public void run() {
for(int i=1;i<=100000;i++){
increase();
}
}
public static void main(String[] args) throws InterruptedException {
//实例化对象
SyncTest instance = new SyncTest();
Thread t1=new Thread(instance);
Thread t2=new Thread(instance);
t1.start();
t2.start();
t1.join();
t2.join();
System.out.println(TEST_INT);
}
}运行上方的程序，结果会是200000，因为main函数中只实例化一个SyncTest对象，所以，两个线程运行的时候只能有一个线程获取到对象的锁，当一个线程获取了该对象的锁之后，其他线程无法获取该对象的锁，所以无法访问该对象的其他synchronized实例方法，当然其他线程还是可以访问该对象的非synchronized方法的。
不过，上面的情况只是针对一个对象实例进行操作，如果有多个对象实例的话，修饰实例方法是无法保证线程安全的，我们可以把main函数的程序修改下：
public static void main(String[] args) throws InterruptedException {
//每个线程实例化一个SyncTest对象
Thread t1=new Thread(new SyncTest());
Thread t2=new Thread(new SyncTest());
t1.start();
t2.start();
t1.join();
t2.join();
System.out.println(TEST_INT);
}运行程序后，会发现结果永远小于200000，说明synchronized没有起到同步的作用了，说明修饰实例方法只能作用实例对象，不能作用到类对象。
修饰静态方法
要想synchronized同步到类对象本身，可以用它修饰类中的静态方法。修改下上述代码中的increase方法为静态方法，并在main函数中新建两条线程：
//被同步的静态方法
public synchronized static void increase(){
TEST_INT++;
}
public static void main(String[] args) throws InterruptedException {
//每个线程实例化一个SyncTest对象
Thread t1=new Thread(new SyncTest());
Thread t2=new Thread(new SyncTest());
t1.start();
t2.start();
t1.join();
t2.join();
System.out.println(TEST_INT);
}运行程序，结果是200000，说明synchronized是作用到类对象本身的，其锁对象是当前类的class对象，所以，不管实例化多个对象实例时，被同步的方法同一时刻只能被一个线程执行。
同步代码块
除了同步实例方法和静态方法外，还可以使用synchronized 同步代码块，某些情况下，我们可能只需要同步一小块代码，假设代码所在的方法体量太大的话，直接同步整个方法会影响程序的运行效率，这种情况下同步代码块就非常的合适，实例代码如下：
public class SyncTest implements Runnable{
public static SyncTest instance = new SyncTest();
//静态变量
public static int TEST_INT = 0;
@Override
public void run() {
synchronized (instance) {
for (int i = 1; i <= 100000; i++) {
TEST_INT++;
}
}
}
public static void main(String[] args) throws InterruptedException {
//每个线程实例化一个SyncTest对象
Thread t1=new Thread(new SyncTest());
Thread t2=new Thread(new SyncTest());
t1.start();
t2.start();
t1.join();
t2.join();
System.out.println(TEST_INT);
}
}上面的代码中，在run()方法中对实例对象instance做了同步处理，运行程序后输出的结果为200000。之所以能达到同步的效果，是因为每次当线程进入synchronized包裹的代码块时就会要求当前线程持有instance这个实例对象锁，其他的线程就必须等待，这样也就保证了每次只有一个线程执行被同步的代码块。
引出Lock
synchronized的用法还是比较简单的，同步的效果也比较明显，尽管如此，synchronized本身还是存在着不少缺陷，比如对锁的释放。
当线程执行到synchronized同步的程序后会获取对应的锁，其他的线程要一直等待，等到该线程释放对应的锁，而该线程释放锁的情况无非是这两种：
- 线程执行完了该代码块，然后释放对锁的占有；
- 线程执行过程发生异常，此时JVM会让线程自动释放锁。
因为synchronized是由JDK实现的，不需要程序员编写代码去控制加锁和释放。这种释放机制有很大的弊端，举个例子，如果获取到该锁的线程有非常耗时的程序，例如等待IO或者被阻塞了，然后没有及时释放锁，那么其他的线程就必须一直等待，白白浪费了不少时间，这样的结果显然不是我们想看到的，那么有什么办法能解决呢？
针对这样的情况，Lock就派上用场了。Lock是Java并发工具包下提供的一个接口，同样可以实现同步访问。
与synchronized不同的是，Lock要求程序员手动控制加锁和释放，它不会自动释放锁，如果没有手动释放锁，线程会一直占用锁，可能造成死锁现象。
Lock用法
Lock是一个接口，点开源码，可以发现其代码中定义这几个方法：
public interface Lock {
void lock();
void lockInterruptibly() throws InterruptedException;
boolean tryLock();
boolean tryLock(long var1, TimeUnit var3) throws InterruptedException;
void unlock();
Condition newCondition();
}其中，lock()、lockInterruptibly()、tryLock()、unlock()都是对锁的获取操作，unLock()是释放锁的方法，newCondition()是返回一个Condition接口，Condition接口可以代替Object监视器方法的使用，相当于充当了Object.wait() 和Object.notify() 的作用，起到线程等待和通知的作用。
前面说到了Lock必须手动释放锁的操作，所以，当调用Lock的获取锁方法后，在执行完程序时还需要调用释放锁的方法，用法大致如下：
Lock lock = new ReentrantLock();
lock.lock();
try {
//.............执行程序..........
} finally {
lock.unlock();
}通过捕获异常的方式来调用Lock释放锁的方法，这样就能保证即使程序发生异常也能成功释放锁。
值得说明的是，Lock只是一个接口，在作为同步工具使用时，必须先实例化它的子类，而代码中的ReentrantLock就是Lock的子类。
子类：ReentrantLock
ReentrantLock是Lock一个非常强大的子类，意思是 “可重入锁”，那么可重入锁是什么意思呢？后面会细说，先展示ReentrantLock的具体用法。
public class LockTest implements Runnable {
public Lock lock = new ReentrantLock();
public static int i = 0;
@Override
public void run() {
for (int j = 0;j<100000;j++){
lock.lock();
try {
i++;
} finally {
lock.unlock();
}
}
}
public static void main(String[] args) throws InterruptedException {
LockTest lt = new LockTest();
Thread t1 = new Thread(lt);
Thread t2 = new Thread(lt);
t1.start();
t2.start();
t1.join();
t2.join();
System.out.println(i);
}
}我们在 LockTest 的 run() 里加了ReentrantLock保护临界区资源 i，确保多线程对临界区资源操作的安全性，执行main方法，可以看到结果成功输出 200000。说明ReentrantLock 确实起到了同步 的作用。
接着说回可重入锁的话题，之所以这么叫，是因为这种锁是可以重复进入的，例如，改造一下run()方法中的代码：
@Override
public void run() {
for (int j = 0;j<100000;j++){
lock.lock();
lock.lock();
try {
i++;
} finally {
lock.unlock();
lock.unlock();
}
}
}运行main方法，代码正常输出200000。说明锁可以被连续使用，因为如果不能被连续使用的话，那么当第二次获取锁时，将会因为第一个锁没释放而一直在等待，同时第二个锁的释放又必须等第二个锁获取并执行 i++ 的程序后才能实现，这样就相当于线程与自己产生了死锁。当然，还需要注意一点，那就是线程获取锁的次数和释放次数必须是相同的，否则就会抛出异常。
读写分离锁：ReadWriteLock
除了Lock接口外，Java的API还提供了另一种读写分离锁，那就是ReadWriteLock。ReadWriteLock是JDK1.5后才引入的，作为读写分离锁，可以有效的帮助减少锁的竞争，提升系统性能。
用锁分离的机制来提升性能比较好理解。举个例子，有三个线程A1、A2、A3进行写操作，三个线程B1、B2、B3进行读的操作。如果使用重入锁或者synchronized(内部锁)，理论上所有的读之间、读与写之间、写与写之间都是串行操作。当B1进行读取时，B2、B3则必须进行等待。由于读操作并不对数据的完整性进行破坏，所以这种等待是不合理的。因此，读写分离锁就派上了用场，它能支持多个读的操作并行执行。
需要注意的是，读写分离锁只是针对读读之间能够并行，在读写和写写之间依然会互斥，总结起来就是这三种情况：
- 读-读不互斥：读读之间不阻塞；
- 读-写互斥：读阻塞写，写也会阻塞读；
- 写-写互斥：写写阻塞；
概念上就大概是这样了，下面就是如何使用了。先看一下ReadWriteLock的源码：
public interface ReadWriteLock {
Lock readLock();
Lock writeLock();
}可以看出，ReadWriteLock是一个接口，并且只提供了两个方法，从字面上很容易就可以理解，分别是写入锁的方法 readLock 和 读取锁的方法 writeLock ，返回的都是Lock接口。
值得说明的是，ReadWriteLock是一个接口，其使用的方式和Lock类似，都是需要先实例化接口的实现类，而其子类只有一个，那就是 ReentrantReadWriteLock，下面用一段代码来测验一下读写锁的性能：
public class ReadWriteLockDemo {
private static ReentrantReadWriteLock readWriteLock = new ReentrantReadWriteLock();
private static Lock writeLock = readWriteLock.readLock();
private static Lock readLock = readWriteLock.readLock();
private int i;
//读的方法
public int ReadValue(Lock lock) throws Exception {
try {
lock.lock();
Thread.sleep(1000);
return i;
} finally {
lock.unlock();
}
}
//写的方法
public void setValue(Lock lock, int value) throws Exception {
try {
lock.lock();
Thread.sleep(1000);
i = value;
} finally {
lock.unlock();
}
}
public static void main(String[] args) {
final ReadWriteLockDemo demo = new ReadWriteLockDemo();
Runnable readRunnable = new Runnable() {
@Override
public void run() {
try {
demo.ReadValue(readLock);
} catch (Exception e) {
e.printStackTrace();
}
}
};
Runnable writeRunnable = new Runnable() {
@Override
public void run() {
try {
demo.setValue(writeLock, new Random().nextInt());
} catch (Exception e) {
e.printStackTrace();
}
}
};
for (int i = 0; i < 20; i++) {
new Thread(readRunnable).start();
}
for (int j = 0; j < 2; j++) {
new Thread(writeRunnable).start();
}
}
}先说明一下这段代码，在ReadWriteLockDemo类中定义了一个ReentrantReadWriteLock实例，并创建它的读写对象，分别是 writeLock 和 readLock，同时，在类中还定义了一个读的方法和写的方法，用Thread.sleep模拟了耗时操作，分别对应读耗时和写耗时。main函数里定义读的线程和写的线程，同时用for循环开启了20个读线程和2个写的线程。
以上的代码采用的就是简单的读写分离操作，正常运行后，程序两秒多钟就结束了 ，这说明，读的线程之间是并行的，而写的线程之间会相互阻塞，这也印证了之前的结论。
读写分离锁就讲到这吧，关于ReentrantReadWriteLock本身还有很多妙用，这里就不展开了。
Lock和synchronized比较
最后，说一下老生常谈的话题吧，就是对Lock和synchronized做个对比总结。
1、Lock是一个接口，而synchronized是Java中的关键字，synchronized是内置的语言实现；
2、synchronized由程序自动释放锁，而Lock需要程序员手动释放，避免死锁；
3、Lock可以让等待锁的线程响应中断，而synchronized却不行，使用synchronized时，等待的线程会一直等待下去，不能够响应中断；
4、Lock可以知道是否成功获得锁，但synchronized不行；
5、Lock支持可重入锁，但synchronized不行；
6、synchronized锁的范围是整个方法或代码块；而Lock是方法调用的方式，灵活性更大；
7、ReadWriteLock可以提升多个线程进行读操作的效率，而synchronized做不到；
再说明一点，从JDK1.6开始，synchronized的性能已经做到了很大的优化，如果是竞争资源不激烈也就是线程不多的情况下，synchronized和Lock的性能是差不多的，而如果资源竞争比较激烈，使用Lock的性能要远远优于synchronized的。
所以，还是那句话，根据不同的场景选择适合的技术才是最好的。