简单了解下Java中锁的概念和原理

简介: Java的锁通过java代码实现,go语言的锁通过go实现,python语言的锁通过python实现。它们都实现的什么呢?这部分就是锁的定义和设计模式、算法、原理等一些理论上的东西。

你好,这里是codetrend专栏“高并发编程基础”。

Java提供了很多种锁的接口和实现,通过对各种锁的使用发现理解锁的概念是很重要的。

Java的锁通过java代码实现,go语言的锁通过go实现,python语言的锁通过python实现。它们都实现的什么呢?这部分就是锁的定义和设计模式、算法、原理等一些理论上的东西。

下文基于此说明Java常见的锁分类和原理。

乐观锁&悲观锁

乐观锁和悲观锁是在并发编程中保证数据一致性的两种常见的锁机制。

乐观锁:乐观锁假设在大多数情况下,不会出现并发冲突,因此在读取数据时并不加锁,只有在提交更新时才会检查是否有其他并发操作修改了数据。如果检测到了冲突,就放弃当前的操作并返回错误信息。通常采用版本号或时间戳等机制来实现乐观锁。乐观锁机制适用于读操作频繁、写操作较少的场景。

悲观锁:悲观锁则假设并发冲突随时都可能发生,因此在读取数据时就会加锁,直到操作完成后才会释放锁。一般可以使用数据库中的行级锁、表级锁或者使用 synchronized 等语言提供的锁机制来实现悲观锁。悲观锁机制适用于写操作频繁、读操作较少的场景。

选择何种锁机制应根据具体的应用场景进行选择。在读写比例不明显的情况下,可以考虑使用乐观锁机制,这样可以减少锁竞争带来的性能损失。如果读写比例明显,考虑使用悲观锁机制可以更好地确保数据的一致性。

需要注意的是,在实际应用中,乐观锁和悲观锁并不是严格的对立关系,而是可以结合使用的。例如,在高并发场景中,可以使用乐观锁机制来减少对数据库的压力,但在必要的时候也可以使用悲观锁机制来确保数据的一致性。

下面是使用 Java 实现一个简单的乐观锁和悲观锁的示例:

乐观锁示例

import java.util.concurrent.atomic.AtomicInteger;

public class OptimisticLock {
   
    private AtomicInteger value = new AtomicInteger(0);

    public void increment() {
   
        int oldValue, newValue;
        while (!value.compareAndSet(oldValue, newValue)){
   
            // CAS操作,如果值没有被修改,则更新为新值
            // 读取当前值
            oldValue = value.get();
            // 计算新值
            newValue = oldValue + 1;
        } 
    }

    public int getValue() {
   
        return value.get();
    }
}

悲观锁示例

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class PessimisticLock {
   
    private int value = 0;
    private Lock lock = new ReentrantLock();

    public void increment() {
   
        lock.lock(); // 加锁
        try {
   
            value++; // 更新数据
        } finally {
   
            lock.unlock(); // 解锁
        }
    }

    public int getValue() {
   
        return value;
    }
}

公平锁&非公平锁

公平锁:公平锁保证线程获取锁的顺序与其请求锁的顺序相同,即先到先得。当多个线程同时竞争同一个公平锁时,这些线程会按照先后顺序排队等待获取锁。公平锁可以避免饥饿现象,但是由于需要维护一个有序队列,因此性能较低。

非公平锁:非公平锁则不保证线程获取锁的顺序,即先到不一定先得。当一个线程释放锁时,如果有多个线程正在等待获取锁,那么当前持有锁的线程有可能会再次获取到锁,而不是让等待时间最长的线程获取锁。非公平锁具有更高的吞吐量和更低的竞争开销,但是容易导致某些线程长时间等待,出现饥饿现象。

在 Java 中,可以使用 ReentrantLock 类来实现公平锁和非公平锁。默认情况下,ReentrantLock 类使用非公平锁,可以通过构造函数传入 true 来创建公平锁,例如:

// 创建公平锁
Lock fairLock = new ReentrantLock(true);

// 创建非公平锁
Lock unfairLock = new ReentrantLock(false);

自旋锁&适应性自旋锁

自旋锁和适应性自旋锁都是基于忙等待的锁机制,它们在获取锁时不会立即阻塞线程,而是反复检查锁的状态,直到获取到锁为止。下面对每种锁做一些说明,并提供Java中的实现示例。

自旋锁:自旋锁适合用于锁持有时间非常短暂的情况,可以避免线程切换带来的开销。自旋锁的基本思想是,当线程发现共享资源已经被其他线程占用时,就进行自旋等待,直到占用共享资源的线程释放锁为止。Java中的ReentrantLock就支持自旋锁,可以通过构造函数的参数来设置自旋次数,例如:

ReentrantLock lock = new ReentrantLock(true); // 使用公平锁
lock.lock(); // 获取锁
// 共享资源的访问操作
lock.unlock(); // 释放锁

适应性自旋锁:适应性自旋锁是一种优化过的自旋锁,它会根据前一次在同一个锁上的自旋时间和锁的拥有者情况来确定自旋次数。如果在同一个锁上,前一次自旋的时间较长,那么下一次就会更倾向于阻塞线程而不是自旋等待。这样可以避免长时间的自旋等待,减少资源的浪费。Java中的StampedLock就是支持适应性自旋锁的一种锁机制,例如:

StampedLock lock = new StampedLock();
long stamp = lock.readLock(); // 获取悲观读锁
// 共享资源的访问操作
lock.unlockRead(stamp); // 释放悲观读锁

无锁 & 偏向锁 & 轻量级锁 & 重量级锁

无锁、偏向锁、轻量级锁和重量级锁都是Java中不同的锁状态,用于实现线程同步的机制。

无锁:无锁是指在多线程环境下,对共享资源的访问没有任何同步控制,所有线程可以同时访问共享资源,不会发生争用。无锁适用于只读操作或者线程冲突非常少的情况。例如:

int value = sharedValue; // 读取共享资源

偏向锁:偏向锁是一种针对加锁操作进行优化的机制,它适用于只有一个线程反复获取锁的情况。当一个线程首次获取锁时,会将锁的标记设置为该线程,下次该线程再次获取锁时无需竞争,直接进入临界区。偏向锁的目标是提高单线程下的性能。例如:

// 线程1首次获取锁
synchronized (lock) {
   
    // 临界区代码
}

// 线程1再次获取锁
synchronized (lock) {
   
    // 临界区代码
}

轻量级锁:轻量级锁是一种基于CAS(Compare and Swap)操作的锁机制,它适用于多个线程交替执行同一段临界区代码的情况。当一个线程获取锁时,会尝试使用CAS操作将对象头部的锁记录替换为指向自己的线程ID,如果成功,则表示获取锁成功;否则,表示有其他线程竞争锁,可能发生锁膨胀。例如:

Lock lock = new ReentrantLock();
lock.lock(); // 获取锁
try {
   
    // 临界区代码
} finally {
   
    lock.unlock(); // 释放锁
}

重量级锁:重量级锁是一种基于操作系统互斥量(Mutex)的锁机制,它适用于多个线程频繁竞争同一把锁的情况。当一个线程获取锁时,会进入阻塞状态,直到锁被释放,然后唤醒其他线程进行竞争。重量级锁适用于线程冲突比较频繁的情况。例如:

synchronized (obj) {
   
    // 临界区代码
}

可重入锁 & 非可重入锁

可重入锁:可重入锁是指允许同一线程多次获取同一把锁,而不会发生死锁或者其他异常情况。当一个线程获取锁后,再次尝试获取锁时会自动成功,并且需要释放相同次数的锁才能真正释放锁。Java中的ReentrantLock和synchronized都支持可重入锁,例如:

// ReentrantLock示例
ReentrantLock lock = new ReentrantLock();
lock.lock(); // 获取锁
try {
   
    // 临界区代码
    lock.lock(); // 再次获取锁
    try {
   
        // 嵌套临界区代码
    } finally {
   
        lock.unlock(); // 释放嵌套锁
    }
} finally {
   
    lock.unlock(); // 释放锁
}

非可重入锁:非可重入锁是指同一线程不能多次获取同一把锁,否则会导致死锁或者其他异常情况。Java中的普通对象锁就是一种非可重入锁,例如:

package engineer.concurrent.battle.glock;

public class LockEnterNoRepeat {
   
    private static Object lock = new Object();

    public static void main(String[] args) {
   
        synchronized (lock) {
   
            // 临界区代码
            synchronized (lock) {
    // 再次获取锁会导致死锁
                // 嵌套临界区代码
                System.out.println("thread end");
            }
        }
    }
}

需要注意的是,可重入锁虽然提供了更大的灵活性和便利性,但也要注意避免死锁和其他问题的发生。在设计和使用多线程代码时,应该根据具体情况选择合适的锁机制。

独享锁 & 共享锁

独享锁Exclusive Lock是指在某个时间点只允许一个线程持有锁,其他线程不能同时持有该锁。独享锁也被称为排它锁或写锁,用于保护临界资源的独占访问。

共享锁Shared Lock是指在某个时间点允许多个线程同时持有锁,这些线程可以同时访问被保护的资源,但是不能进行写操作。共享锁也被称为读锁,用于实现读多写少的并发模式。

在Java中,ReentrantReadWriteLock是一种同时支持独享锁和共享锁的锁机制。通过使用ReentrantReadWriteLock,可以在不同的线程之间实现对共享资源的读写操作控制。

下面是使用ReentrantReadWriteLock实现独享锁和共享锁的示例代码:

import java.util.concurrent.locks.ReentrantReadWriteLock;

public class ReadWriteLockExample {
   
    private ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
    private String data = "Hello, World!";

    public void readData() {
   
        lock.readLock().lock();
        try {
   
            System.out.println("Reading data: " + data);
        } finally {
   
            lock.readLock().unlock();
        }
    }

    public void writeData(String newData) {
   
        lock.writeLock().lock();
        try {
   
            System.out.println("Writing data: " + newData);
            data = newData;
        } finally {
   
            lock.writeLock().unlock();
        }
    }

    public static void main(String[] args) {
   
        ReadWriteLockExample example = new ReadWriteLockExample();

        // 创建多个读线程
        for (int i = 0; i < 3; i++) {
   
            Thread readerThread = new Thread(() -> {
   
                example.readData();
            });
            readerThread.start();
        }

        // 创建一个写线程
        Thread writerThread = new Thread(() -> {
   
            example.writeData("New data");
        });
        writerThread.start();
    }
}

运行该程序会输出以下结果:

Reading data: Hello, World!
Reading data: Hello, World!
Reading data: Hello, World!
Writing data: New data

可以看到,有三个读线程同时获取了共享锁,并读取了数据。而在写线程中,只有该线程获取了独享锁,并成功修改了数据。

通过ReentrantReadWriteLock,我们可以实现对共享资源的读操作并发执行,提高读操作的效率;而写操作会独占锁,保证在写操作时只有一个线程能够访问临界资源,确保数据一致性。

关于作者

来自全栈程序员nine的探索与实践,持续迭代中。

欢迎关注和点赞~

目录
相关文章
|
18天前
|
存储 Java 关系型数据库
高效连接之道:Java连接池原理与最佳实践
在Java开发中,数据库连接是应用与数据交互的关键环节。频繁创建和关闭连接会消耗大量资源,导致性能瓶颈。为此,Java连接池技术通过复用连接,实现高效、稳定的数据库连接管理。本文通过案例分析,深入探讨Java连接池的原理与最佳实践,包括连接池的基本操作、配置和使用方法,以及在电商应用中的具体应用示例。
37 5
|
7天前
|
存储 算法 Java
大厂面试高频:什么是自旋锁?Java 实现自旋锁的原理?
本文详解自旋锁的概念、优缺点、使用场景及Java实现。关注【mikechen的互联网架构】,10年+BAT架构经验倾囊相授。
大厂面试高频:什么是自旋锁?Java 实现自旋锁的原理?
|
8天前
|
Java
Java之CountDownLatch原理浅析
本文介绍了Java并发工具类`CountDownLatch`的使用方法、原理及其与`Thread.join()`的区别。`CountDownLatch`通过构造函数接收一个整数参数作为计数器,调用`countDown`方法减少计数,`await`方法会阻塞当前线程,直到计数为零。文章还详细解析了其内部机制,包括初始化、`countDown`和`await`方法的工作原理,并给出了一个游戏加载场景的示例代码。
Java之CountDownLatch原理浅析
|
10天前
|
Java 索引 容器
Java ArrayList扩容的原理
Java 的 `ArrayList` 是基于数组实现的动态集合。初始时,`ArrayList` 底层创建一个空数组 `elementData`,并设置 `size` 为 0。当首次添加元素时,会调用 `grow` 方法将数组扩容至默认容量 10。之后每次添加元素时,如果当前数组已满,则会再次调用 `grow` 方法进行扩容。扩容规则为:首次扩容至 10,后续扩容至原数组长度的 1.5 倍或根据实际需求扩容。例如,当需要一次性添加 100 个元素时,会直接扩容至 110 而不是 15。
Java ArrayList扩容的原理
|
10天前
|
缓存 Java
java中的公平锁、非公平锁、可重入锁、递归锁、自旋锁、独占锁和共享锁
本文介绍了几种常见的锁机制,包括公平锁与非公平锁、可重入锁与不可重入锁、自旋锁以及读写锁和互斥锁。公平锁按申请顺序分配锁,而非公平锁允许插队。可重入锁允许线程多次获取同一锁,避免死锁。自旋锁通过循环尝试获取锁,减少上下文切换开销。读写锁区分读锁和写锁,提高并发性能。文章还提供了相关代码示例,帮助理解这些锁的实现和使用场景。
java中的公平锁、非公平锁、可重入锁、递归锁、自旋锁、独占锁和共享锁
|
16天前
|
存储 Java 关系型数据库
在Java开发中,数据库连接是应用与数据交互的关键环节。本文通过案例分析,深入探讨Java连接池的原理与最佳实践
在Java开发中,数据库连接是应用与数据交互的关键环节。本文通过案例分析,深入探讨Java连接池的原理与最佳实践,包括连接创建、分配、复用和释放等操作,并通过电商应用实例展示了如何选择合适的连接池库(如HikariCP)和配置参数,实现高效、稳定的数据库连接管理。
33 2
|
16天前
|
算法 Java 数据库连接
Java连接池技术,从基础概念出发,解析了连接池的工作原理及其重要性
本文详细介绍了Java连接池技术,从基础概念出发,解析了连接池的工作原理及其重要性。连接池通过复用数据库连接,显著提升了应用的性能和稳定性。文章还展示了使用HikariCP连接池的示例代码,帮助读者更好地理解和应用这一技术。
31 1
|
8天前
|
安全 Java 测试技术
Java并行流陷阱:为什么指定线程池可能是个坏主意
本文探讨了Java并行流的使用陷阱,尤其是指定线程池的问题。文章分析了并行流的设计思想,指出了指定线程池的弊端,并提供了使用CompletableFuture等替代方案。同时,介绍了Parallel Collector库在处理阻塞任务时的优势和特点。
|
4天前
|
安全 Java 开发者
深入解读JAVA多线程:wait()、notify()、notifyAll()的奥秘
在Java多线程编程中,`wait()`、`notify()`和`notifyAll()`方法是实现线程间通信和同步的关键机制。这些方法定义在`java.lang.Object`类中,每个Java对象都可以作为线程间通信的媒介。本文将详细解析这三个方法的使用方法和最佳实践,帮助开发者更高效地进行多线程编程。 示例代码展示了如何在同步方法中使用这些方法,确保线程安全和高效的通信。
22 9
|
7天前
|
存储 安全 Java
Java多线程编程的艺术:从基础到实践####
本文深入探讨了Java多线程编程的核心概念、应用场景及其实现方式,旨在帮助开发者理解并掌握多线程编程的基本技能。文章首先概述了多线程的重要性和常见挑战,随后详细介绍了Java中创建和管理线程的两种主要方式:继承Thread类与实现Runnable接口。通过实例代码,本文展示了如何正确启动、运行及同步线程,以及如何处理线程间的通信与协作问题。最后,文章总结了多线程编程的最佳实践,为读者在实际项目中应用多线程技术提供了宝贵的参考。 ####