面试加分项：精通Java高并发下的锁优化策略

1. 问题背景与挑战

1.1 并发编程中的挑战

在现代软件开发中，高并发已成为衡量系统质量的一项关键因素，特别是对于那些需要同时处理数以万计甚至百万级用户请求的服务。并发编程的挑战在于如何有效地同步多个线程，确保数据的一致性和系统的稳定性。当多个线程试图同时访问和修改共享资源时，如果没有适当的同步机制，就会导致数据的不一致性甚至系统崩溃。

1.2 高并发场景对加锁机制的要求

在高并发场景下的加锁机制需要满足几个基本要求：首先必须确保加锁的效率，减少线程获取锁的等待时间；其次要减少锁的竞争，避免线程长时间占用锁；最后锁的实现需要足够灵活，以适应不同的应用场景。这些要求指向了高效加锁策略的需要，进而引出锁的升级和优化问题。

2. 锁的基础知识概述

2.1 同步机制简介

在多线程程序中，同步机制是用来控制不同线程间执行顺序的机制，它帮助我们解决并发执行时可能会出现的竞争条件问题。Java提供了多种同步机制，包括synchronized关键字、锁（Locks）、信号量（Semaphores）、倒计数器（CountDownLatch）等，来帮助程序员解决线程安全问题。

2.2 Java中的锁机制

锁是用来控制多个线程对共享资源访问的工具。在Java中，最基本的锁就是synchronized关键字，它可以用来修饰方法或代码块。此外，Java从JDK 5开始引入了java.util.concurrent.locks包，提供了更加精细的锁机制，例如ReentrantLock、ReadWriteLock等。
以下是一个简单使用synchronized关键字的Java代码示例：

public class Counter {
    private int count = 0;

    public synchronized void increment() {
        count++;
    }

    public synchronized void decrement() {
        count--;
    }

    public synchronized int getCount() {
        return count;
    }
}

3. Java中等待与通知机制的实现

3.1 实现方式

在Java中，对象的等待/通知机制是基于内部的监视器锁（monitor lock）实现的，它涉及到三个关键方法：wait()、notify()和notifyAll()，这些方法都属于Object类的一部分。每个对象都有一个监视器，用来控制对这个对象同步部分的访问。
下面是一个简单的例子，展示了如何使用wait()和notify()方法来实现线程间的协作：

public class Message {
    private String content;
    private boolean empty = true;

    public synchronized String take() {
        // 等待content变得可用
        while (empty) {
            try {
                wait();
            } catch (InterruptedException e) {}
        }
        empty = true;
        // 通知生产者生成内容
        notifyAll();
        return content;
    }

    public synchronized void put(String newContent) {
        // 等待content被消费
        while (!empty) {
            try {
                wait();
            } catch (InterruptedException e) {}
        }
        empty = false;
        content = newContent;
        // 通知消费者内容可用
        notifyAll();
    }
}

3.2 实现原理

当一个线程调用对象的wait()方法时，它会释放当前的锁，并让出CPU资源进入等待状态，直到其他线程在同一个对象上调用notify()或notifyAll()方法。调用notify()会随机唤醒一个在该对象上等待的线程，而notifyAll()会唤醒所有等待的线程。
file

4. 高效加锁策略

4.1 乐观锁与悲观锁

在面对高并发的场景时，传统的悲观锁（如synchronized关键字或者ReentrantLock）经常会成为性能瓶颈。这是因为悲观锁总是假设最坏的情况，它预防其他线程进行并发修改，无论冲突发生的概率有多低。
与之相对的是乐观锁，它通常通过版本号或CAS（Compare-and-Swap）操作来实现。它假设多个线程之间不会发生冲突，只在提交操作时检查是否有冲突发生，从而减少线程争用锁的时间。

4.2 可重入锁的重要性

可重入锁（ReentrantLock）是指同一个线程中的外层函数获得锁之后，内层函数仍然有能力获取这个锁的代码块，也就是说，线程可以进入它已经有权访问的锁同步的代码块。ReentrantLock比synchronized提供了更高的操作灵活性，它可以尝试非阻塞地获取锁，也可以在尝试获取锁时被中断。

4.3 锁粒度控制

在高并发场景下，适当地降低锁的粒度可以显著提升性能。这种技术通常被称为锁分割或锁分段。例如，在ConcurrentHashMap中，通过将数据分成不同的段，每个段拥有自己的锁，可以实现更细粒度的锁控制，从而提高并发访问性能。
下面是一个锁粒度控制的代码示例：

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

public class FineGrainedLock {
    private final Node[] nodes;
    private final int size;
    
    private static class Node {
        Object item;
        final Lock lock = new ReentrantLock();
        
        Node(Object item) {
            this.item = item;
        }
    }
    
    public FineGrainedLock(int size) {
        this.size = size;
        this.nodes = new Node[size];
        for (int i = 0; i < size; i++) {
            this.nodes[i] = new Node(null);
        }
    }
    
    public void set(int key, Object value) {
        int hash = key % size;
        Node node = nodes[hash];
        node.lock.lock();
        try {
            node.item = value;
        } finally {
            node.lock.unlock();
        }
    }
    
    public Object get(int key) {
        int hash = key % size;
        Node node = nodes[hash];
        node.lock.lock();
        try {
            return node.item;
        } finally {
            node.lock.unlock();
        }
    }
}

上述代码中，我们创建了一个简单的锁分割示例。其中FineGrainedLock类通过内部的Node数组来控制锁的粒度，每个Node对象包含一个条目和一个锁。当一个线程尝试设置或获取一个值时，它只需要锁定那个特定的Node对象，而不是整个数组。

5. 锁的升级与优化

5.1 自旋锁的引入

自旋锁是处理多线程同步的一种机制，它避免了线程在互斥锁上的阻塞。在自旋锁机制中，线程不是在无法获得锁时立刻挂起，而是在循环中尝试获取锁。这种方法适合于锁持有时间短而线程等待时间较长的场景，可以减少线程上下文切换的成本。

5.2 读写锁的应用

读写锁（ReadWriteLock）允许多个读操作同时进行，但在写操作进行时会阻塞所有读操作和其他写操作，这是一种改进的互斥机制。在读多写少的情况下，读写锁能够提供比标准互斥锁更高的并发性。Java中的ReentrantReadWriteLock类就是读写锁的一个实现。

5.3 偏向锁、轻量级锁到重量级锁的转化

在Java 6以后的HotSpot JVM中，引入了偏向锁、轻量级锁和重量级锁来优化锁机制。这三种锁会根据竞争情况动态升级：

  • 偏向锁 适用于只有一个线程访问同步块的场景。
  • 轻量级锁 用于线程交替执行同步块时。
  • 重量级锁 适用于有多个线程同时竞争同步块的情况。

以下是偏向锁、轻量级锁和重量级锁状态转换的伪代码示例：

public class LockOptimizationExample {

    private volatile Object data;

    public void processData() {
        // 尝试获取偏向锁
        if (atomic_operation_for_bias_lock()) {
            // 处理数据
            processDataWithBiasLock();
        } else if (atomic_operation_for_lightweight_lock()) {
            // 升级到轻量级锁并处理数据
            processDataWithLightweightLock();
        } else {
            // 升级到重量级锁并处理数据
            processDataWithHeavyweightLock();
        }
    }
}

6. Java中的锁优化实战案例

6.1 优化前的加锁策略

考虑到一个常见的电商平台的订单系统，系统需要处理成千上万的订单请求，而且同时保持订单数据的一致性。优化前，系统可能过分依赖于synchronized同步块或者重量级ReentrantLock，这在高并发场景下可能导致大量线程阻塞，等待锁的释放，从而导致性能瓶颈。

6.2 优化后的加锁策略

为了提高系统的吞吐量和响应速度，可以采用如下几个锁优化策略：

  1. 引入读写锁来优化读多写少的场景。
  2. 使用分段锁机制减少不同线程间的锁争用。
  3. 当线程冲突较少时，引入乐观锁减少无谓的同步开销。
  4. 对于短时间的锁占用，可以使用自旋锁替代传统锁，减少线程上下文切换。

6.3 实现代码示例

以下是优化后加锁策略的一个Java代码实例，该实例使用了ReadWriteLock来改进原有的同步机制：

import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

public class OrderSystem {
    
    private final ReadWriteLock lock = new ReentrantReadWriteLock();
    private Map<Long, Order> orderMap = new ConcurrentHashMap<>();

    public void addOrder(Order order) {
        lock.writeLock().lock();
        try {
            orderMap.put(order.getId(), order);
        } finally {
            lock.writeLock().unlock();
        }
    }

    public Order getOrder(Long orderId) {
        lock.readLock().lock();
        try {
            return orderMap.get(orderId);
        } finally {
            lock.readLock().unlock();
        }
    }
    
    // 其他方法...

    private static class Order {
       // 订单相关数据字段
       // 构造函数、getter和setter方法等
    }
}

在这个例子中，我们通过使用ReadWriteLock来分离读写操作，从而允许多个读操作同时进行而不被单个的写操作所阻塞。这可以显著地提升系统处理读操作的能力，在高并发读的电商场景中十分有用。

7. notify()和notifyAll()在高并发中的应用

7.1 方法功能及适用场景

在Java中，notify()和notifyAll()方法用于唤醒在对象监视器上等待的线程。notify()方法随机唤醒一个等待的线程，而notifyAll()方法唤醒所有等待的线程。

  • notify()适用于确信只有一个线程等待条件变化时的场景，或者在资源分配的过程不担心产生额外的竞争时。
  • notifyAll()更适合于多个线程可能等待相同条件的场景，或者每个线程等待的条件不尽相同。

7.2 方法使用注意事项

  • 确保只在同步区域内调用notify()或notifyAll()，否则会抛出IllegalMonitorStateException。
  • notify()可能导致“通知丢失”，如果没有线程在此刻等待，之后到来的线程将无法被通知。
  • 使用notifyAll()时需要注意性能的影响，因为它可能会唤醒多个线程，使它们重新竞争锁，但实际上可能只有一个线程能够继续执行。

7.3 使用示例代码

public class SharedResource {
    private volatile boolean isAvailable = false;
    private Object data;

    public synchronized void produce(Object newData) {
        while (isAvailable) {
            try {
                wait();
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }
        data = newData;
        isAvailable = true;
        notifyAll(); // 通知所有消费者资源已可用
    }

    public synchronized Object consume() {
        while (!isAvailable) {
            try {
                wait();
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }
        Object tempData = data;
        isAvailable = false;
        notifyAll(); // 通知生产者资源可再次生产
        return tempData;
    }
}

在这个例子中，生产者在生产新数据后调用notifyAll()方法来唤醒所有可能等待这个共享资源的消费者。相似地，消费者在消费数据后也调用notifyAll()来通知生产者资源已被消费，可以产生新的资源。这种模式保证了资源的有效利用和线程间的合作。

8. 避免死锁的策略

8.1 死锁产生的条件

死锁是并发编程中一个需要避免的问题，它通常发生在多个线程永久性地互相等待对方释放锁的情况下。造成死锁的四个必要条件通常被称作死锁的四元组，包括：互斥条件、请求与保持条件、不可剥夺条件和循环等待条件。

8.2 避免死锁的方法

要避免死锁，可以采用以下几种主要策略：

  1. 打破互斥条件：虽然很少可行，但可以通过改变资源的性质从而允许多个线程同时访问。
  2. 打破持有和等待条件：一次性申请所有资源，防止进入等待状态。
  3. 打破非剥夺条件：允许一定条件下锁的剥夺与转让。
  4. 打破循环等待条件：通过定义资源的线性顺序来防止循环等待。

下面是一个避免死锁的代码示例，演示了如何按顺序申请资源来避免"循环等待条件"：

public class Account {
    private int balance;
    private final int id;
    // 其他属性与方法

    public Account(int id, int initialBalance) {
        this.id = id;
        this.balance = initialBalance;
    }

    public int getId() {
        return id;
    }

    public synchronized void transfer(Account target, int amount) {
        Account first = this.id < target.id ? this : target;
        Account second = this.id < target.id ? target : this;

        synchronized (first) {
            synchronized (second) {
                if (this.balance >= amount) {
                    this.balance -= amount;
                    target.balance += amount;
                }
            }
        }
    }
}

在这个示例中，转账操作首先会按照账户ID的大小来申请锁，保证了不会出现循环等待的情况。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：/a/627292.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

【csv-parse】使用parse方法的时候来转换为csv字符串时，会导致输出有乱码

【csv-parse】使用parse方法的时候来转换为csv字符串时，会导致输出有乱码

&#x1f601; 作者简介&#xff1a;一名大四的学生&#xff0c;致力学习前端开发技术 ⭐️个人主页&#xff1a;夜宵饽饽的主页 ❔ 系列专栏&#xff1a;前端bug记录 &#x1f450;学习格言&#xff1a;成功不是终点&#xff0c;失败也并非末日&#xff0c;最重要的是继续前进…
阅读更多...
针对实拍场景的虚拟试衣模型IDM-VTON：高保真和细节保留的虚拟试穿算法，真实环境效果领先

针对实拍场景的虚拟试衣模型IDM-VTON：高保真和细节保留的虚拟试穿算法，真实环境效果领先

前言 虚拟试衣是一种将人物图像与服装图像合成&#xff0c;生成人物穿戴目标服装的图像技术。相比传统的GAN方法&#xff0c;基于扩散模型的虚拟试衣方法能够生成更加自然逼真的图像。然而&#xff0c;现有的扩散模型在保留服装细节方面仍存在局限性。 为了解决这一问题&…
阅读更多...
Nodejs 第七十一章（libuv）

Nodejs 第七十一章（libuv）

libuv 在Node.js中&#xff0c;libuv是作为其事件循环和异步I/O的核心组件而存在的。Node.js是构建在libuv之上的&#xff0c;它利用libuv来处理底层的异步操作&#xff0c;如文件I/O、网络通信和定时器等。 libuv在Node.js中扮演了以下几个重要角色&#xff1a; 事件循环&a…
阅读更多...
一个panic问题引起对percpu变量的思考

一个panic问题引起对percpu变量的思考

1 问题引入 最近在分析一个panic问题时&#xff0c;发现panic现场无法与log对应起来。 先贴log: <1>[ 180.089084] Unable to handle kernel NULL pointer dereference at virtual address 00000001 <1>[ 180.099551] pgd 8bbde651 <1>[ 180.107775] …
阅读更多...
JavaScript进阶——05-迭代器和生成器【万字长文，感谢支持】

JavaScript进阶——05-迭代器和生成器【万字长文，感谢支持】

迭代器 概念 迭代器&#xff08;Iterator&#xff09;是 JavaScript 中一种特殊的对象&#xff0c;它提供了一种统一的、通用的方式遍历个各种不同类型的数据结构。可以遍历的数据结构包括&#xff1a;数组、字符串、Set、Map 等可迭代对象。我们也可以自定义实现迭代器&…
阅读更多...
Python GUI开发- Qt Designer环境搭建

Python GUI开发- Qt Designer环境搭建

前言 Qt Designer是PyQt5 程序UI界面的实现工具&#xff0c;使用 Qt Designer 可以拖拽、点击完成GUI界面设计&#xff0c;并且设计完成的 .ui 程序可以转换成 .py 文件供 python 程序调用 环境准备 使用pip安装 pip install pyqt5-toolsQt Designer 环境搭建 在pip安装包…
阅读更多...
AI办公自动化：用kimi批量把word转换成txt文本

AI办公自动化：用kimi批量把word转换成txt文本

在Kimichat中输入提示词&#xff1a; 你是一个Python编程专家&#xff0c;要完成一个Python脚本编写的任务&#xff0c;具体步骤如下&#xff1a; 打开文件夹&#xff1a;F:\aword 读取里面docx格式的word文档&#xff0c; 提取word文档中的第一行文字作为txt文本文档的标题…
阅读更多...
(done) NLP+HMM 协作，还有维特比算法

(done) NLP+HMM 协作，还有维特比算法

参考视频&#xff1a;https://www.bilibili.com/video/BV1aP4y147gA/?p2&spm_id_frompageDriver&vd_source7a1a0bc74158c6993c7355c5490fc600 &#xff08;这实际上是 “序列标注任务”&#xff09; HMM 的训练和预测如下图 训练过程&#xff1a;我们首先先给出一个语…
阅读更多...
HSP_06章-1_Python_数据容器

HSP_06章-1_Python_数据容器

文章目录 P76 数据容器1. 概述2. 分类 P77 列表ListP77-78 列表List的注意事项和使用细节P80 列表List的常用方法一览1. 列表生成式 P80_82 元组Tuple1. 元组的使用细节和注意事项 P83 元组的常用操作 P76 数据容器 1. 概述 1、数据容器是一种数据类型&#xff0c;有些地方也…
阅读更多...
机器学习笔记 PostgresML教程：使用SQL进行机器学习

机器学习笔记 PostgresML教程：使用SQL进行机器学习

机器学习的基本做法是将数据转移到模型的环境中进行训练。由于今天的数据库比机器学习模型大好多个数量级，所以PostgresML的思路是，如果我们将模型引入数据集不是会容易得多吗？ PostgresML 是一个建立在流行的 PostgreSQL 数据库之上的综合机器学习平台。它引入了一种称为“…
阅读更多...
股指期货的交割日是哪一天？

股指期货的交割日是哪一天？

股指期货的交割日&#xff0c;就好比是期货合约的“期末考试”。每个月的第三周的周五&#xff0c;就是股指期货的交割日。在这一天&#xff0c;如果你持有的期货合约还没有卖出&#xff08;平仓&#xff09;&#xff0c;那么就会按照一个特定的价格&#xff08;结算价&#xf…
阅读更多...
学习MySQL（三）：数据类型约束条件

学习MySQL（三）：数据类型约束条件

数据类型 字符串&#xff1a;char(num) 与 varchar(num) 延申面试问题&#xff1a;char与varchar有什么区别&#xff1f; 区别1&#xff1a;定长与变长 char 固定长度&#xff0c;例如定义了char(8)&#xff0c;则这一列存储的内容长度都为8&#xff0c;不足8位则会用空格补…
阅读更多...
二分答案（区间范围）

二分答案（区间范围）

D. Jumping Through Segments 输入数据 4 5 1 5 3 4 5 6 8 10 0 1 3 0 2 0 1 0 3 3 3 8 10 18 6 11 4 10 20 0 5 15 17 2 2 输出范围 7 0 5 13#include<bits/stdc.h> #define int long long using namespace std; typedef pair<char,int>PII; const int N2e510;…
阅读更多...
Java线程生命周期：Java线程生命周期全景解读

Java线程生命周期：Java线程生命周期全景解读

1. 线程生命周期概述&#xff1a;不仅仅是状态转换 在多线程编程中&#xff0c;理解线程的生命周期对于编写有效、高效的代码至关重要。线程生命周期通常描述了线程从创建到死亡的一系列状态变化过程&#xff0c;但其实不仅仅局限于这些状态的简单转换。线程生命周期的理解应该…
阅读更多...
如何在云电脑实现虚拟应用—数据分层（应用分层）技术简介

如何在云电脑实现虚拟应用—数据分层（应用分层）技术简介

如何在云电脑实现虚拟应用—数据分层&#xff08;应用分层&#xff09;技术简介 近几年虚拟化市场实现了非常大的发展&#xff0c;桌面虚拟化在企业中应用越来越广泛&#xff0c;其拥有的如下优点得到大量企业的青睐&#xff1a; 数据安全不落地。在虚拟化环境下面数据保存在…
阅读更多...
网络安全快速入门（十）MySQL拓展操作

网络安全快速入门（十）MySQL拓展操作

10.1.0前言 前面我们已经对用户操作以及库&#xff0c;表操作有了基础的认识&#xff0c;接下来我们来在之前已经学过的一些操作进行进一步拓展&#xff0c;本章我们主要了解以下几个知识点&#xff1a; 数据库设计方法视图存储过程事务 我们开始本章的内容吧 10.2 数据库设计方…
阅读更多...
Java代理模式的实现详解

Java代理模式的实现详解

一、前言 1.1、说明 本文章是在学习mybatis框架源码的过程中&#xff0c;发现对于动态代理Mapper接口这一块的代理实现还是有些遗忘和陌生&#xff0c;因此在本文章中就Java实现代理模式的过程进行一个学习和总结。 1.2、参考文章 《设计模式》&#xff08;第2版&#xff0…
阅读更多...
阿里云服务器下，部署LNMP环境安装wordpress

阿里云服务器下，部署LNMP环境安装wordpress

目录 1 LNMP部署1、简单说明2、nginx部署3、php8 安装4、mysql8安装5、配置 nginx 实现支持 PHP 程序6、安装 php 组件7、测试 2 wordpress部署1、安装2、配置 总结 1 LNMP部署 1、简单说明 首先需要明白&#xff0c;LNMP指的是Linux、Nginx、MySQL、PHP。而如果使用阿里云服…
阅读更多...
代码随想录—— 填充每个节点的下一个右侧节点指针（Leetcode116）

代码随想录—— 填充每个节点的下一个右侧节点指针（Leetcode116）

题目链接 层序遍历 /* // Definition for a Node. class Node {public int val;public Node left;public Node right;public Node next;public Node() {}public Node(int _val) {val _val;}public Node(int _val, Node _left, Node _right, Node _next) {val _val;left _…
阅读更多...
视频提取动图怎么制作？一个方法将视频转换gif

视频提取动图怎么制作？一个方法将视频转换gif

现在这个日益发展的科技社会&#xff0c;视频作为我们广泛应用的一种媒体形式&#xff0c;在各个领域都扮演着重要的角色。视频凭着丰富生动的内容成为传递信息的媒介。但是视频的体积也是比较大的&#xff0c;在使用的过程中会受到各种各样的限制。这个时候就可以使用gif在线制…
阅读更多...
最新文章

Copyright @ 2022~2023