Java中各种锁的介绍

野性酷女 2023-08-17 17:16 136阅读 0赞

Java中各种锁的介绍

### **前言** ###

Java提供了各种各样的锁，每种锁都有适合的使用的场景，我们了解了各种锁的特点后，就能在平时的开发中灵活运用。

#### 1.乐观锁和悲观锁 ####

**悲观锁**总是假设最坏的情况，每次去拿数据的时候都认为别人会修改，所以每次在拿数据的时候都会上锁，这样别人想拿这个数据就会阻塞直到它拿到锁。`Java`中`synchronized`和`ReentrantLock`等独占锁就是悲观锁思想的实现。

**乐观锁**认为自己在使用数据时不会有别的线程修改数据，所以不会添加锁，只是在更新数据的时候去判断之前有没有别的线程更新了这个数据。如果没有被更新过，则将自己的数据写入，否则不写入。Java中主要是通过CAS算法来实现悲观锁的。

悲观锁适合写操作多的场景，而乐观锁适合读操作多的场景。

#### 2.公平锁和非公平锁 ####

**公平锁**是指多个线程按照申请锁的顺序来获取锁。

**非公平锁**是指多个线程获取锁的顺序并不是按照申请锁的顺序，有可能后申请的线程比先申请的线程优先获取锁。

非公平锁的性能和吞吐量更好，但是有可能会造成饥饿现象。

#### **3.可重入锁和非可重入锁** ####

**可重入锁**指的是可重复可递归调用的锁，在外层使用锁之后，在内层仍然可以使用，并且不发生死锁（前提得是同一个对象或者class），这样的锁就叫做可重入锁。`ReentrantLock`和`synchronized`都是可重入锁。

**非可重入锁**与可重入锁相反，不可递归调用，递归调用就发生死锁

public synchronized void getA() {
        getB();
    }
    public synchronized void getB() {
    
    }

上面代码中getA中调用getB方法，可以直接进入，不会发生死锁。

#### 4.独享锁和共享锁 ####

**独享锁**：该锁每一次只能被一个线程所持有。

**共享锁**：该锁可被多个线程共有，典型的就是ReentrantReadWriteLock里的读锁，它的读锁是可以被共享的，但是它的写锁却每次只能被独占。

public class LockTest {
    
        private static ReentrantReadWriteLock readWriteLock = new ReentrantReadWriteLock();
    
        public static void main(String[] args) {
    
            ExecutorService executorService = Executors.newFixedThreadPool(2);
    
            executorService.execute(() -> {
                ReentrantReadWriteLock.ReadLock readLock = readWriteLock.readLock();
                readLock.lock();
    
                System.out.println("lock thread 1"   Thread.class.getName());
            });
    
            executorService.execute(() -> {
                ReentrantReadWriteLock.ReadLock readLock = readWriteLock.readLock();
                readLock.lock();
                System.out.println("lock thread 2"   Thread.class.getName());
            });
    
            System.out.println("over");
        }
    }

如果是独享锁lock thread只会打印一次，共享锁则都会打印

#### 5.偏向锁、轻量级锁和重量级锁 ####

**偏向锁**是指一段同步代码一直被一个线程所访问，那么该线程会自动获取锁。降低获取锁的代价。

**轻量级锁**是指当锁是偏向锁的时候，被另一个线程所访问，偏向锁就会升级为轻量级锁，其他线程会通过自旋的形式尝试获取锁，不会阻塞，提高性能。

**重量级锁**是指当锁为轻量级锁的时候，另一个线程虽然是自旋，但自旋不会一直持续下去，当自旋一定次数的时候，还没有获取到锁，就会进入阻塞，该锁膨胀为重量级锁。重量级锁会让其他申请的线程进入阻塞，性能降低。

<table> 
 <tbody> 
  <tr> 
   <th>锁<br></th> 
   <th>优点<br></th> 
   <th>缺点<br></th> 
   <th>使用场景<br></th> 
  </tr> 
  <tr> 
   <td>偏向锁<br></td> 
   <td>加锁和解锁不需要额外的消耗，和执行非同步方法比仅存在纳秒级的差距。</td> 
   <td>如果线程间存在锁竞争，会带来额外的锁撤销的消耗。</td> 
   <td>适用于只有一个线程访问同步块场景。<br></td> 
  </tr> 
  <tr> 
   <td>轻量级锁</td> 
   <td>竞争的线程不会阻塞，提高了程序的响应速度。<br></td> 
   <td>如果始终得不到锁竞争的线程使用自旋会消耗CPU。<br></td> 
   <td>追求响应时间。同步块执行的速度非常快</td> 
  </tr> 
  <tr> 
   <td>重量级锁</td> 
   <td>线程竞争不使用自旋，不会消耗CPU。<br></td> 
   <td>线程阻塞，响应时间缓慢。<br></td> 
   <td>追求吞吐量。<br></td> 
  </tr> 
 </tbody> 
</table>

### 参考 ###

关注公众号：**蜜蜂技术巢**了解更多知识