在多线程编程中，锁是保证线程安全的重要工具。其中，内置锁和显示锁是两种常见的锁机制。本文将介绍这两种锁的原理、应用场景以及优缺点，帮助读者更好地理解多线程编程。
一、内置锁
内置锁，也称为JVM锁或者监视器锁，是Java语言提供的一种基本锁机制。内置锁通常通过synchronized关键字实现。当代码块使用synchronized关键字进行同步时，会自动获取对象的内置锁，执行完该代码块后会自动释放锁。下面的示例代码展示了如何使用内置锁：
public class Counter {
private int count = 0;
public synchronized void increment() {
count++;
}
public synchronized void decrement() {
count--;
}
public synchronized int getCount() {
return count;
}
}上述代码中，increment、decrement和getCount方法都使用了synchronized关键字，因此它们都是同步方法。在这些方法中，this被用作锁对象，获取了内置锁。这样就可以确保在同一时间只有一个线程能够访问这些方法，从而避免了线程安全问题。
内置锁的实现原理是，每个Java对象都有一个与之相关联的监视器锁（也称为内置锁）。当线程要访问被锁定的代码块时，它必须先获得与该对象相关联的监视器锁。如果另一个线程已经持有了这个锁，则当前线程就会阻塞等待，直到该锁被释放。
内置锁的优点是实现简单，使用方便。同时，由于内置锁是JVM级别的锁，因此可以确保多个线程在同一时间只能访问一个对象的同步代码块。但是，内置锁也存在一些缺点。首先，在高并发场景下，内置锁可能会导致性能问题。其次，内置锁只能基于对象级别进行同步，无法对代码块进行细粒度控制。
二、显示锁
显示锁，也称为可重入锁，是Java语言提供的一种高级锁机制。与内置锁不同的是，显示锁需要程序员手动获取和释放锁。Java中常用的显示锁包括ReentrantLock和ReadWriteLock。
下面的示例代码展示了如何使用ReentrantLock：
import java.util.concurrent.locks.ReentrantLock;
public class Counter {
private int count = 0;
private final ReentrantLock lock = new ReentrantLock();
public void increment() {
lock.lock();
try {
count++;
} finally {
lock.unlock();
}
}
public void decrement() {
lock.lock();
try {
count--;
} finally {
lock.unlock();
}
}
public int getCount() {
lock.lock();
try {
return count;
} finally {
lock.unlock();
}
}
}与内置锁不同的是，在显示锁中需要手动获取和释放锁。在上述代码中，我们使用了ReentrantLock来实现锁机制。通过调用lock()方法获取锁，使用try-finally块确保锁能够被正确地释放。这样就可以保证同一时间只有一个线程能够访问这些方法。
显示锁的优点是，它比内置锁提供了更细粒度的控制。例如，可以使用Lock接口提供的tryLock()方法尝试获取锁，如果无法获取到锁则立即返回false，避免线程阻塞。此外，显示锁还支持公平锁和非公平锁的选择。在高并发场景下，显示锁可能比内置锁更加高效。
然而，与内置锁相比，显示锁的实现更加复杂。同时，在使用显示锁时需要注意避免死锁等问题。
三、如何选择内置锁和显示锁
当需要对对象级别进行同步时，可以选择使用内置锁。它可以提供基本的线程安全机制，适用于简单的同步需求。
如果需要对代码块或者资源进行细粒度控制，可以选择使用显示锁。它提供了更细粒度的控制，可以支持公平锁和非公平锁，并且可以避免一些性能问题。
需要注意的是，在使用显示锁时需要避免滥用。由于显示锁的实现较为复杂，过度使用可能会导致代码复杂性增加，甚至出现死锁等问题。因此，在使用显示锁时需要根据具体情况进行合理选择。
补充一些关于内置锁和显示锁的小技巧：
-
内置锁的粒度比较大，如果需要对某个方法中的代码块进行同步，可以使用synchronized代码块。例如：
public class Counter { private int count = 0; public void increment() { synchronized (this) { count++; } } public void decrement() { synchronized (this) { count--; } } public int getCount() { synchronized (this) { return count; } } } -
显示锁支持公平锁和非公平锁，通过构造函数参数控制。如果需要保证线程获取锁的顺序与其请求锁的顺序一致，可以使用公平锁。例如：
ReentrantLock lock = new ReentrantLock(true); // 创建公平锁 -
如果只需要读写分离的同步机制，可以使用ReadWriteLock接口。它提供了读锁和写锁两种模式，读锁可以被多个线程同时持有，写锁只能被单个线程持有。例如：
ReadWriteLock lock = new ReentrantReadWriteLock(); Lock readLock = lock.readLock(); // 获取读锁 Lock writeLock = lock.writeLock(); // 获取写锁
4. 内置锁和显示锁都需要手动释放锁，因此在使用锁时需要注意避免出现死锁等问题。例如，如果一个线程在持有锁的情况下又请求获取同一个锁，那么就会发生死锁。为了避免死锁，可以遵循一些通用的规则，如按照固定的顺序获得锁、尽量不要在持有锁的情况下调用外部方法等。
-
在高并发场景下，内置锁可能会导致性能问题。因此，如果需要提高系统的并发能力，可以考虑使用显示锁或其他同步机制。同时，需要注意避免过度使用锁，避免因加锁过多而导致的系统性能下降。
-
Java还提供了一些其他的同步机制，如Semaphore、CountDownLatch、CyclicBarrier等。它们各自具有不同的特点，可以根据实际需求选择适合的同步机制。
-
最后，多线程编程中需要注意线程安全问题。除了使用锁之外，还可以使用volatile关键字、原子类等机制来保证线程安全。但是，在使用这些机制时也需要注意避免出现其他问题，如ABA问题、可见性问题等。
-
内置锁和显示锁可以嵌套使用，但需要注意避免死锁问题。如果一个线程在持有外层锁的情况下请求获取内层锁，那么就会发生死锁。为了避免死锁，可以按照一定的顺序获得锁，例如从外向内依次获取锁，或者使用tryLock()方法尝试获取锁并设置超时时间等。
-
在使用锁时需要注意避免过度使用锁导致性能问题。例如，在对代码块进行同步时，应该尽量缩小锁的粒度，只对必要的代码块进行同步。同时，需要注意避免加锁过多导致的系统性能问题。
-
在Java中，还可以使用线程局部变量(ThreadLocal)来解决线程安全问题。线程局部变量是一种特殊的变量，它只能被当前线程访问。通过使用线程局部变量，可以避免使用锁而达到线程安全的目的。例如：
public class Counter { private ThreadLocal<Integer> count = new ThreadLocal<Integer>() { @Override protected Integer initialValue() { return 0; } }; public void increment() { count.set(count.get() + 1); } public void decrement() { count.set(count.get() - 1); } public int getCount() { return count.get(); } }
7.如果需要在锁中等待一段时间后自动释放锁，可以使用Lock接口提供的tryLock()方法，并指定等待时间。例如：
public void doSomething() {
if (lock.tryLock(10, TimeUnit.SECONDS)) { // 等待10秒钟获取锁
try {
// 同步代码块
} finally {
lock.unlock();
}
} else {
// 获取锁失败
}
}
`
-
内置锁和显示锁的执行效率取决于具体的实现方式和应用场景。通常情况下，内置锁的执行效率比较高，而显示锁的执行效率相对较低。但是，在高并发场景下，由于内置锁会导致大量线程等待，因此会降低系统的性能。因此，在选择锁时需要综合考虑实际应用场景和需求。
-
显示锁可以支持公平锁和非公平锁。公平锁会按照请求锁的先后顺序来获取锁，而非公平锁则不保证这一点。如果需要保证线程获取锁的顺序与其请求锁的顺序一致，可以使用公平锁。但需要注意，公平锁可能会导致线程切换的频繁，从而影响系统的性能。
-
在使用锁的过程中，需要注意避免出现死锁问题。死锁是指两个或多个线程互相持有对方所需的资源，从而导致无法继续执行的情况。为了避免死锁，可以按照固定的顺序获取锁，或者设置超时时间并检测锁的状态等。
在Java中，还可以使用Condition接口来实现线程间的通信和同步。Condition是基于锁实现的一种线程间通信机制，它提供了等待、通知等操作。例如：
Lock lock = new ReentrantLock();
Condition condition = lock.newCondition();
// 线程1等待某个条件
lock.lock();
try {
while (!conditionMet()) {
condition.await(); // 等待条件满足
}
// 执行任务
} finally {
lock.unlock();
}
// 线程2满足某个条件
lock.lock();
try {
setCondition(); // 设置条件
condition.signal(); // 通知等待的线程
} finally {
lock.unlock();
}
总结
本文介绍了Java中常见的两种锁机制：内置锁和显示锁。我们从原理、应用场景以及优缺点等方面进行了分析和比较。需要根据具体情况选择合适的锁机制，避免滥用并注意避免可能出现的问题。同时，除了内置锁和显示锁之外，Java还提供了其他的同步机制，例如volatile关键字、原子类、信号量等。在多线程编程中，需要根据实际需求选择适合的同步机制。总之，在使用任何同步机制时，都需要注意线程安全问题，并且避免出现死锁等问题。总结不到位之处，欢迎提出。
最后，推荐一些相关资源：
- 《Java并发编程实战》
- 《Java高并发程序设计》
- 《Java并发编程精讲》视频教程
- JDK官方文档：java.util.concurrent (Java Platform SE 8 )
扫一扫
2504
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
