Java 并发编程详解:Lock 接口及其实现 ReentrantLock

简介: Java 并发编程详解:Lock 接口及其实现 ReentrantLock

Java 并发编程详解:Lock 接口及其实现 ReentrantLock

在 Java 并发编程中,锁机制是确保多线程环境下数据一致性和安全性的关键。Java 提供了 Lock 接口及其实现类 ReentrantLock,相比于传统的 synchronized 关键字,提供了更多的控制和灵活性。本文将详细介绍 Lock 接口及其实现 ReentrantLock,包括其特性、使用方法和实际应用示例。


一、Lock 接口

Lock 接口是 Java 并发包中定义的一个接口,用于实现锁的机制。与 synchronized 相比,Lock 接口提供了更多的锁控制方式和更加灵活的操作。

1. 主要方法

  • void lock(): 获取锁。如果锁已经被另一个线程持有,则当前线程会被阻塞,直到获得锁。
  • void lockInterruptibly() throws InterruptedException: 获取锁,但在等待时可以响应中断。
  • boolean tryLock(): 尝试获取锁。如果成功获取到锁,返回 true,否则返回 false。不会阻塞线程。
  • boolean tryLock(long time, TimeUnit unit) throws InterruptedException: 在指定的时间内尝试获取锁。
  • void unlock(): 释放锁。
  • Condition newCondition(): 返回一个绑定到此 Lock 实例的新 Condition 实例,用于实现等待/通知机制。


二、ReentrantLock 类

ReentrantLock 是 Lock 接口的一个具体实现类,是一个可重入锁。可重入锁的特点是,持有锁的线程可以多次获取该锁而不会被阻塞。

1. 特性

  • 可重入性: 持有锁的线程可以再次获取该锁,不会被阻塞。
  • 公平锁和非公平锁: ReentrantLock 支持公平锁和非公平锁。公平锁按照线程请求的顺序分配锁,而非公平锁则无序分配,可能会使某些线程长期得不到锁。
  • Condition 支持: 提供 Condition 对象,实现线程间的协调,类似于 Object 类中的 wait、notify 和 notifyAll 方法。

2. 构造方法

  • ReentrantLock(): 创建一个默认的非公平锁。
  • ReentrantLock(boolean fair): 创建一个公平或非公平锁,取决于参数 fair 的值。


三、ReentrantLock 的使用

1. 基本使用

使用 ReentrantLock 进行锁操作,通常需要配合 try-finally 语句,确保锁在不再需要时被释放。

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

public class ReentrantLockExample {
    private final Lock lock = new ReentrantLock();
    private int counter = 0;

    public void increment() {
        lock.lock(); // 获取锁
        try {
            counter++;
        } finally {
            lock.unlock(); // 确保在最后释放锁
        }
    }

    public int getCounter() {
        lock.lock();
        try {
            return counter;
        } finally {
            lock.unlock();
        }
    }

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

        // 创建多个线程来测试 ReentrantLock
        Runnable task = () -> {
            for (int i = 0; i < 1000; i++) {
                example.increment();
            }
        };

        Thread thread1 = new Thread(task);
        Thread thread2 = new Thread(task);

        thread1.start();
        thread2.start();

        try {
            thread1.join();
            thread2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("Final Counter: " + example.getCounter());
    }
}

2. 使用 Condition 实现生产者-消费者模型

ReentrantLock 提供的 Condition 可以更灵活地实现线程间的协调,类似于传统的 wait 和 notify。

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

public class ProducerConsumerExample {
    private final Lock lock = new ReentrantLock();
    private final Condition notFull = lock.newCondition();
    private final Condition notEmpty = lock.newCondition();
    private final int[] buffer = new int[10];
    private int count, putptr, takeptr;

    public void put(int value) throws InterruptedException {
        lock.lock();
        try {
            while (count == buffer.length) { // 缓冲区已满
                notFull.await();
            }
            buffer[putptr] = value;
            if (++putptr == buffer.length) putptr = 0;
            count++;
            notEmpty.signal();
        } finally {
            lock.unlock();
        }
    }

    public int take() throws InterruptedException {
        lock.lock();
        try {
            while (count == 0) { // 缓冲区为空
                notEmpty.await();
            }
            int value = buffer[takeptr];
            if (++takeptr == buffer.length) takeptr = 0;
            count--;
            notFull.signal();
            return value;
        } finally {
            lock.unlock();
        }
    }

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

        Runnable producer = () -> {
            for (int i = 0; i < 100; i++) {
                try {
                    example.put(i);
                    System.out.println("Produced: " + i);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        };

        Runnable consumer = () -> {
            for (int i = 0; i < 100; i++) {
                try {
                    int value = example.take();
                    System.out.println("Consumed: " + value);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        };

        Thread producerThread = new Thread(producer);
        Thread consumerThread = new Thread(consumer);

        producerThread.start();
        consumerThread.start();

        try {
            producerThread.join();
            consumerThread.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}


四、总结

  • Lock 接口 提供了比 synchronized 关键字更灵活和丰富的锁机制。
  • ReentrantLock 是 Lock 接口的一个实现,支持可重入、可选择的公平锁以及提供 Condition 对象来实现复杂的线程间协调。
  • 使用 ReentrantLock 可以提高多线程环境下程序的并发性能和可控性,适用于需要复杂锁控制的场景。


通过合理使用 Lock 接口及其实现 ReentrantLock,可以更有效地管理并发,确保线程安全,提高程序的可靠性和性能。

目录
相关文章
|
10天前
|
SQL Java 数据库
2025 年 Java 从零基础小白到编程高手的详细学习路线攻略
2025年Java学习路线涵盖基础语法、面向对象、数据库、JavaWeb、Spring全家桶、分布式、云原生与高并发技术,结合实战项目与源码分析,助力零基础学员系统掌握Java开发技能,从入门到精通,全面提升竞争力,顺利进阶编程高手。
178 1
|
10天前
|
Java 开发者
Java并发编程:CountDownLatch实战解析
Java并发编程:CountDownLatch实战解析
279 100
|
21天前
|
NoSQL Java 关系型数据库
超全 Java 学习路线,帮你系统掌握编程的超详细 Java 学习路线
本文为超全Java学习路线,涵盖基础语法、面向对象编程、数据结构与算法、多线程、JVM原理、主流框架(如Spring Boot)、数据库(MySQL、Redis)及项目实战等内容,助力从零基础到企业级开发高手的进阶之路。
120 1
|
27天前
|
算法 Java
Java多线程编程:实现线程间数据共享机制
以上就是Java中几种主要处理多线程序列化资源以及协调各自独立运行但需相互配合以完成任务threads 的技术手段与策略。正确应用上述技术将大大增强你程序稳定性与效率同时也降低bug出现率因此深刻理解每项技术背后理论至关重要.
61 16
|
2月前
|
安全 Java Shell
Java模块化编程(JPMS)简介与实践
本文全面解析Java 9模块化系统(JPMS),帮助开发者解决JAR地狱、类路径冲突等常见问题,提升代码的封装性、性能与可维护性。内容涵盖模块化核心概念、module-info语法、模块声明、实战迁移、多模块项目构建、高级特性及最佳实践,同时提供常见问题和面试高频题解析,助你掌握Java模块化编程精髓,打造更健壮的应用。
|
2月前
|
安全 算法 Java
Java泛型编程:类型安全与擦除机制
Java泛型详解:从基础语法到类型擦除机制,深入解析通配符与PECS原则,探讨运行时类型获取技巧及最佳实践,助你掌握泛型精髓,写出更安全、灵活的代码。
|
2月前
|
存储 缓存 安全
Java集合框架(二):Set接口与哈希表原理
本文深入解析Java中Set集合的工作原理及其实现机制,涵盖HashSet、LinkedHashSet和TreeSet三大实现类。从Set接口的特性出发,对比List理解去重机制,并详解哈希表原理、hashCode与equals方法的作用。进一步剖析HashSet的底层HashMap实现、LinkedHashSet的双向链表维护顺序特性,以及TreeSet基于红黑树的排序功能。文章还包含性能对比、自定义对象去重、集合运算实战和线程安全方案,帮助读者全面掌握Set的应用与选择策略。
147 23
|
Java
Java多线程之Lock的使用(转)
package thread.lock; import java.util.concurrent.ExecutorService; import java.util.concurrent.
868 0
|
Java
Java多线程之Lock的使用
import java.util.concurrent.ExecutorService;   import java.util.concurrent.
958 0
|
15天前
|
数据采集 存储 弹性计算
高并发Java爬虫的瓶颈分析与动态线程优化方案
高并发Java爬虫的瓶颈分析与动态线程优化方案