共计 5229 个字符，预计需要花费 14 分钟才能阅读完成。
咱们都晓得，当多个线程并发地操作同一共享资源的时候，容易产生线程平安问题，解决这个问题的一个方法是加锁，那么问题来了： 加锁就肯定线程平安了吗？
各位小伙伴，你们的答案是什么？是，还是不是？
其实这种面试问题，面试官可能会心愿你能依据不同的场景开展论述，而不是简略的答复是或不是，这既可体现出你对多线程中的线程平安问题的了解到位，同时也体现了你剖析问题的能力比别的候选人强，思考问题周到。
1. 加同一个内置锁或者显式独占锁，肯定线程平安
这种形式实际上是将并行变成了串行，所有须要进入同步区的线程，都须要先获取到这把锁，一旦某个线程获取到了锁，其余线程就须要期待，即同工夫在同步区范畴内，只能容许一个线程进行共享资源的拜访，因而会升高性能！
1) 加同一个内置锁
import java.util.concurrent.CountDownLatch;
public class ThreadSafeDemo {
private int anInt = 0;
public synchronized void incr() {anInt++;}
public void decr() {synchronized (this) {anInt--;}
}
public static void main(String[] args) {CountDownLatch latch = new CountDownLatch(5);
ThreadSafeDemo demo = new ThreadSafeDemo();
for (int threadIdx = 0; threadIdx < 5; threadIdx++) {if (threadIdx % 2 == 0) { // threadIdx 等于 0、2、4 时
new Thread(() -> {for (int i = 0; i < 10000; i++) {demo.incr();
}
latch.countDown();}).start();} else { // threadIdx 等于 1、3 时
new Thread(() -> {for (int i = 10000; i > 0; i--) {demo.decr();
}
latch.countDown();}).start();}
}
try {latch.await();
} catch (InterruptedException e) {Thread.currentThread().interrupt();}
// 期望值：10000
System.out.println("以后 anInt 的值为：" + demo.anInt);
}
}如以上代码，开启 5 个并发线程，其中 3 个线程别离自增 10000，2 个线程别离自减 10000，所以最终冀望正确的值应该是 30000 – 20000 = 10000，执行后果如下：
后果正确，线程平安。
2) 加同一个显式独占锁
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.locks.ReentrantLock;
public class ThreadSafeDemo {
private int anInt = 0;
public void incr() {anInt++;}
public void decr() {anInt--;}
public static void main(String[] args) {CountDownLatch latch = new CountDownLatch(5);
ReentrantLock lock = new ReentrantLock();
ThreadSafeDemo demo = new ThreadSafeDemo();
for (int threadIdx = 0; threadIdx < 5; threadIdx++) {if (threadIdx % 2 == 0) { // threadIdx 等于 0、2、4 时
new Thread(() -> {for (int i = 0; i < 10000; i++) {
// 显式独占锁加锁
lock.lock();
demo.incr();
// 显式独占锁解锁
lock.unlock();}
latch.countDown();}).start();} else { // threadIdx 等于 1、3 时
new Thread(() -> {for (int i = 10000; i > 0; i--) {
// 显式独占锁加锁
lock.lock();
demo.decr();
// 显式独占锁解锁
lock.unlock();}
latch.countDown();}).start();}
}
try {latch.await();
} catch (InterruptedException e) {Thread.currentThread().interrupt();}
// 期望值：10000
System.out.println("以后 anInt 的值为：" + demo.anInt);
}
} 同 1) 一样，只不过这里换成了显式的独占锁（ReentrantLock），所以执行后果是一样的！
2. 加不同的锁，肯定线程不平安
咱们对 1 中的内置锁局部代码做一些批改，留神 incr() 和 decr() 办法：
import java.util.concurrent.CountDownLatch;
public class ThreadSafeDemo {
private static int anInt = 0;
public synchronized void incr() {anInt++;}
public static synchronized void decr() {anInt--;}
public static void main(String[] args) {CountDownLatch latch = new CountDownLatch(5);
ThreadSafeDemo demo = new ThreadSafeDemo();
for (int threadIdx = 0; threadIdx < 5; threadIdx++) {if (threadIdx % 2 == 0) { // threadIdx 等于 0、2、4 时
new Thread(() -> {for (int i = 0; i < 10000; i++) {demo.incr();
}
latch.countDown();}).start();} else { // threadIdx 等于 1、3 时
new Thread(() -> {for (int i = 10000; i > 0; i--) {ThreadSafeDemo.decr();
}
latch.countDown();}).start();}
}
try {latch.await();
} catch (InterruptedException e) {Thread.currentThread().interrupt();}
// 期望值：10000
System.out.println("以后 anInt 的值为：" + anInt);
}
}执行后果如下：
能够看到，后果并不正确，线程不平安。
那这是为什么呢？其实就是因为这里有两把锁，不同的锁，也就不能保障多线程对同一共享资源的并发操作是线程平安的。也就是说 0、2、4 线程获取的锁跟 1、3 线程获取的锁不是同一个锁，0、2、4 线程获取的锁作用的对象是调用 incr() 这个办法的对象，也就是 demo，而 1、3 线程获取的锁作用的对象是 ThreadSafeDemo 这个类的 Class 对象，跟 synchronized (ThreadSafeDemo.class) {...} 的作用是相似的。
3. 加同一读写锁，不肯定线程平安
1 中应用的是独占锁，会升高性能。实际上在一些场景下，多线程也能够同时访问共享资源，而不会产生线程平安的问题。例如多线程的“读”操作与“读”操作之间。
上面以 Java 8 的 ReentrantReadWriteLock 例子作示例阐明，该示例参考了 Oracle 官网的 API 文档中的例子，>> 传送门：
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.ReentrantReadWriteLock;
public class ThreadSafeDemo {
/**
* 数据
*/
private String data = null;
/**
* 缓存是否无效
*/
private volatile boolean cache = false;
public String getDataFromDb() {
// 模仿从数据库中获取数据，耗时 0.5 秒
String data = null;
try {TimeUnit.MILLISECONDS.sleep(500L);
data = String.valueOf(System.currentTimeMillis());
System.out.println("[" + Thread.currentThread().getName()
+ "] 缓存有效，从数据库中获取数据：" + data);
} catch (InterruptedException e) {Thread.currentThread().interrupt();}
return data;
}
public void use() {System.out.println("[" + Thread.currentThread().getName()
+ "] 以后 data 的值为：" + data);
}
public static void main(String[] args) {CountDownLatch latch = new CountDownLatch(5);
ReentrantReadWriteLock rwLock = new ReentrantReadWriteLock();
ThreadSafeDemo demo = new ThreadSafeDemo();
for (int threadIdx = 0; threadIdx < 5; threadIdx++) {new Thread(() -> {
// 获取读锁：⑴
rwLock.readLock().lock();
// 如果缓存有效
if (!demo.cache) {
// 开释读锁（读锁不能降级为写锁）：⑴ 处获取的
rwLock.readLock().unlock();
// 获取写锁
rwLock.writeLock().lock();
try {
// 再次查看缓存是否无效，因为其余线程有可能先于以后线程获取到写锁并批改了它的值
if (!demo.cache) {demo.data = demo.getDataFromDb();
// 缓存设为无效
demo.cache = true;
}
// 获取读锁（在开释写锁之前，再获取读锁，进行锁降级）：⑵
rwLock.readLock().lock();
} finally {
// 开释写锁，此时线程仍持有读锁（⑵ 处获取的）rwLock.writeLock().unlock();
}
}
try {
// 模仿 1 秒的解决工夫，并打印出以后值
TimeUnit.SECONDS.sleep(1);
demo.use();} catch (InterruptedException e) {Thread.currentThread().interrupt();} finally {
// 开释读锁：⑴ 或 ⑵ 处获取的
rwLock.readLock().unlock();
}
latch.countDown();}).start();}
try {latch.await();
} catch (InterruptedException e) {Thread.currentThread().interrupt();}
}
}执行后果：
乍一看，这不是正确的吗？别急，咱们再来加点货色看看：
new Thread(() -> {
// 获取读锁：⑴
rwLock.readLock().lock();
// 如果缓存有效
if (!demo.cache) {
// 谬误示范，在读锁外面批改了数据
demo.cache = true;
demo.data = demo.getDataFromDb();
demo.cache = false;
// 开释读锁（读锁不能降级为写锁）：⑴ 处获取的
rwLock.readLock().unlock();
// Omit code...
}
// Omit code...
}).start();如以上代码，在后面的代码根底上，⑴ 处第一次获取到读锁后，在开释读锁之前，对共享资源进行了批改，执行后果如下：
能够看到，因为在读锁区域内对共享资源进行了批改，导致呈现了线程平安问题，而这种问题是因为不正确地应用了读写锁导致的。也就是说，在应用读写锁时，不能在读锁范畴内对共享资源进行“写”操作，须要了解读写锁的实用场景并且正确地应用它。
总结
这次通过一个面试题，简略地梳理了一下多线程的线程平安问题与锁的关系，心愿对各位能有帮忙！因为集体能力所限，如果各位小伙伴在阅读文章时发现有谬误的中央，欢送反馈给我勘正，万分感激。
