前面我们介绍了很多关于多线程的内容，在多线程中有一个很重要的课题需要我们攻克，那就是线程安全问题。线程安全问题指的是在多线程中，各线程之间因为同时操作所产生的数据污染或其他非预期的程序运行结果。
比如 A 和 B 同时给 C 转账的问题，假设 C 原本余额有 100 元，A 给 C 转账 100 元，正在转的途中，此时 B 也给 C 转了 100 元，这个时候 A 先给 C 转账成功，余额变成了 200 元，但 B 事先查询 C 的余额是 100 元，转账成功之后也是 200 元。当 A 和 B 都给 C 转账完成之后，余额还是 200 元，而非预期的 300 元，这就是典型的线程安全的问题。
上面的内容没看明白没关系，下面来看非线程安全的具体代码：
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 class ThreadSafeTest static int number = 0 ; public static void main (String[] args) throws InterruptedException Thread thread1 = new Thread(() -> addNumber()); Thread thread2 = new Thread(() -> addNumber()); thread1.start(); thread2.start(); thread1.join(); thread2.join(); System.out.println("number：" + number); } public static void addNumber () for (int i = 0 ; i < 10000 ; i++) { ++number; } } } 复制
以上程序执行结果如下：
number：12085
每次执行的结果可能略有差异，不过几乎不会等于（正确的）累计之和 20000。
线程安全的解决方案有以下几个维度：
数据不共享，单线程可见，比如 ThreadLocal 就是单线程可见的；
使用线程安全类，比如 StringBuffer 和 JUC（java.util.concurrent）下的安全类（后面文章会专门介绍）；
使用同步代码或者锁。
① synchronized 介绍 synchronized 是 Java 提供的同步机制，当一个线程正在操作同步代码块（synchronized 修饰的代码）时，其他线程只能阻塞等待原有线程执行完再执行。
② synchronized 使用 synchronized 可以修饰代码块或者方法，示例代码如下：
1 2 3 4 5 6 7 8 9 10 synchronized (this ) { } synchronized void method () } 复制
使用 synchronized 完善本文开头的非线程安全的代码。
方法一：使用 synchronized 修饰代码块 ，代码如下：
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 class ThreadSafeTest static int number = 0 ; public static void main (String[] args) throws InterruptedException Thread sThread = new Thread(() -> { synchronized (ThreadSafeTest.class) { addNumber(); } }); Thread sThread2 = new Thread(() -> { synchronized (ThreadSafeTest.class) { addNumber(); } }); sThread.start(); sThread2.start(); sThread.join(); sThread2.join(); System.out.println("number：" + number); } public static void addNumber () for (int i = 0 ; i < 10000 ; i++) { ++number; } } } 复制
以上程序执行结果如下：
number：20000
方法二：使用 synchronized 修饰方法 ，代码如下：
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 class ThreadSafeTest static int number = 0 ; public static void main (String[] args) throws InterruptedException Thread sThread = new Thread(() -> addNumber()); Thread sThread2 = new Thread(() -> addNumber()); sThread.start(); sThread2.start(); sThread.join(); sThread2.join(); System.out.println("number：" + number); } public synchronized static void addNumber () for (int i = 0 ; i < 10000 ; i++) { ++number; } } } 复制
以上程序执行结果如下：
number：20000
③ synchronized 实现原理 synchronized 本质是通过进入和退出的 Monitor 对象来实现线程安全的。
1 2 3 4 5 6 7 8 9 public class SynchronizedTest public static void main (String[] args) synchronized (SynchronizedTest.class) { System.out.println("Java" ); } } } 复制
当我们使用 javap 编译之后，生成的字节码如下：
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 Compiled from "SynchronizedTest.java" public class com .interview .other .SynchronizedTest public com.interview.other.SynchronizedTest(); Code: 0 : aload_0 1: invokespecial #1 // Method java/lang/Object."<init>":()V 4 : return public static void main (java.lang.String[]) Code: 0: ldc #2 // class com/interview/other/SynchronizedTest 2 : dup 3 : astore_1 4 : monitorenter 5: getstatic #3 // Field java/lang/System.out:Ljava/io/PrintStream; 8: ldc #4 // String Java 10: invokevirtual #5 // Method java/io/PrintStream.println:(Ljava/lang/String;)V 13 : aload_1 14 : monitorexit 15 : goto 23 18 : astore_2 19 : aload_1 20 : monitorexit 21 : aload_2 22 : athrow 23 : return Exception table: from to target type 5 15 18 any 18 21 18 any } 复制
可以看出 JVM（Java 虚拟机）是采用 monitorenter 和 monitorexit 两个指令来实现同步的，monitorenter 指令相当于加锁，monitorexit 相当于释放锁。而 monitorenter 和 monitorexit 就是基于 Monitor 实现的。
① ReentrantLock 介绍 ReentrantLock（再入锁）是 Java 5 提供的锁实现，它的功能和 synchronized 基本相同。再入锁通过调用 lock() 方法来获取锁，通过调用 unlock() 来释放锁。
② ReentrantLock 使用 ReentrantLock 基础使用 ，代码如下：
1 2 3 4 5 6 Lock lock = new ReentrantLock(); lock.lock(); lock.unlock(); 复制
使用 ReentrantLock 完善本文开头的非线程安全代码，请参考以下代码：
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 public class LockTest static int number = 0 ; public static void main (String[] args) throws InterruptedException Lock lock = new ReentrantLock(); Thread thread1 = new Thread(() -> { try { lock.lock(); addNumber(); } finally { lock.unlock(); } }); Thread thread2 = new Thread(() -> { try { lock.lock(); addNumber(); } finally { lock.unlock(); } }); thread1.start(); thread2.start(); thread1.join(); thread2.join(); System.out.println("number：" + number); } public static void addNumber () for (int i = 0 ; i < 10000 ; i++) { ++number; } } } 复制
尝试获取锁
ReentrantLock 可以无阻塞尝试访问锁，使用 tryLock() 方法，具体使用如下：
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 Lock reentrantLock = new ReentrantLock(); new Thread(() -> { try { reentrantLock.lock(); Thread.sleep(2 * 1000 ); } catch (InterruptedException e) { e.printStackTrace(); } finally { reentrantLock.unlock(); } }).start(); new Thread(() -> { try { Thread.sleep(1 * 1000 ); System.out.println(reentrantLock.tryLock()); Thread.sleep(2 * 1000 ); System.out.println(reentrantLock.tryLock()); } catch (InterruptedException e) { e.printStackTrace(); } }).start(); 复制
以上代码执行结果如下：
false
true
尝试一段时间内获取锁
tryLock() 有一个扩展方法 tryLock(long timeout, TimeUnit unit) 用于尝试一段时间内获取锁，具体实现代码如下：
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 Lock reentrantLock = new ReentrantLock(); new Thread(() -> { try { reentrantLock.lock(); System.out.println(LocalDateTime.now()); Thread.sleep(2 * 1000 ); } catch (InterruptedException e) { e.printStackTrace(); } finally { reentrantLock.unlock(); } }).start(); new Thread(() -> { try { Thread.sleep(1 * 1000 ); System.out.println(reentrantLock.tryLock(3 , TimeUnit.SECONDS)); System.out.println(LocalDateTime.now()); } catch (InterruptedException e) { e.printStackTrace(); } }).start(); 复制
以上代码执行结果如下：
2019-07-05 19:53:51
true
2019-07-05 19:53:53
可以看出锁在休眠了 2 秒之后，就被线程二直接获取到了，所以说 tryLock(long timeout, TimeUnit unit) 方法内的 timeout 参数指的是获取锁的最大等待时间。
使用 ReentrantLock 一定要记得释放锁，否则该锁会被永久占用。
答：ReentrantLock 常见方法如下：
lock()：用于获取锁
unlock()：用于释放锁
tryLock()：尝试获取锁
getHoldCount()：查询当前线程执行 lock() 方法的次数
getQueueLength()：返回正在排队等待获取此锁的线程数
isFair()：该锁是否为公平锁
答：ReentrantLock 具备非阻塞方式获取锁的特性，使用 tryLock() 方法。ReentrantLock 可以中断获得的锁，使用 lockInterruptibly() 方法当获取锁之后，如果所在的线程被中断，则会抛出异常并释放当前获得的锁。ReentrantLock 可以在指定时间范围内获取锁，使用 tryLock(long timeout,TimeUnit unit) 方法。
答：new ReentrantLock() 默认创建的为非公平锁，如果要创建公平锁可以使用 new ReentrantLock(true)。
答：公平锁指的是线程获取锁的顺序是按照加锁顺序来的，而非公平锁指的是抢锁机制，先 lock() 的线程不一定先获得锁。
答：lock() 和 lockInterruptibly() 的区别在于获取线程的途中如果所在的线程中断，lock() 会忽略异常继续等待获取线程，而 lockInterruptibly() 则会抛出 InterruptedException 异常。
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 Lock interruptLock = new ReentrantLock(); interruptLock.lock(); Thread thread = new Thread(new Runnable() { @Override public void run () try { interruptLock.lock(); } catch (Exception e) { e.printStackTrace(); } } }); thread.start(); TimeUnit.SECONDS.sleep(1 ); thread.interrupt(); TimeUnit.SECONDS.sleep(3 ); System.out.println("Over" ); System.exit(0 ); 复制
执行以下代码会发现使用 lock() 时程序不会报错，运行完成直接退出；而使用 lockInterruptibly() 则会抛出异常 java.lang.InterruptedException，这就说明：在获取线程的途中如果所在的线程中断，lock() 会忽略异常继续等待获取线程，而 lockInterruptibly() 则会抛出 InterruptedException 异常。
答：synchronized 和 ReentrantLock 都是保证线程安全的，它们的区别如下：
ReentrantLock 使用起来比较灵活，但是必须有释放锁的配合动作；
ReentrantLock 必须手动获取与释放锁，而 synchronized 不需要手动释放和开启锁；
ReentrantLock 只适用于代码块锁，而 synchronized 可用于修饰方法、代码块等；
ReentrantLock 性能略高于 synchronized。
答：不对，tryLock(3, TimeUnit.SECONDS) 表示获取锁的最大等待时间为 3 秒，期间会一直尝试获取，而不是等待 3 秒之后再去获取锁。
答：在锁对象的对象头里面有一个 threadid 字段，在第一次访问的时候 threadid 为空，JVM（Java 虚拟机）让其持有偏向锁，并将 threadid 设置为其线程 id，再次进入的时候会先判断 threadid 是否尤其线程 id 一致，如果一致则可以直接使用，如果不一致，则升级偏向锁为轻量级锁，通过自旋循环一定次数来获取锁，不会阻塞，执行一定次数之后就会升级为重量级锁，进入阻塞，整个过程就是锁升级的过程。
本文介绍了线程同步的两种方式 synchronized 和 ReentrantLock，其中 ReentrantLock 使用更加灵活，效率也率高，不过 ReentrantLock 只能修饰代码块，使用 ReentrantLock 需要开发者手动释放锁，如果忘记释放则该锁会一直被占用。synchronized 使用场景更广，可以修饰普通方法、静态方法和代码块等。
