分布式系统中的防抖策略一致性与性能优化

news2024/12/24 15:04:48

目录

  1. 引言
  2. 分布式系统的挑战
  3. 防抖策略简介
  4. 确保多实例间一致性的方法
    • 幂等操作
    • TTL缓存 + 分布式一致性
    • 事件总线或消息队列
    • 异步任务调度器
    • 客户端或API网关层面的防抖
    • 一致性哈希与分区
    • 限流和熔断机制
  5. 避免锁竞争导致的性能瓶颈
  6. Java示例代码
  7. 结论

引言

在现代软件架构中，分布式系统已经成为处理高并发请求和服务可用性的主流方案。然而，在这样的环境中实现高效的防抖（Debouncing）策略并非易事。本文将探讨如何在保证多实例间一致性的前提下，有效地避免因锁竞争导致的性能瓶颈，并给出具体的实现方案。

分布式系统的挑战

多实例间的协调

在一个典型的分布式系统中，多个服务实例可能同时接收到相同的请求。这给确保这些请求只被处理一次带来了挑战。传统的单机解决方案不再适用，我们需要寻找新的方法来保证防抖逻辑的一致性和效率。

性能考量

引入防抖逻辑不应显著增加系统的延迟或资源消耗。任何额外的检查或同步操作都可能成为性能瓶颈，特别是在高并发场景下。

防抖策略简介

防抖是一种编程技术，用于确保某个动作不会过于频繁地触发。例如，用户快速连续点击按钮时，我们可能只希望最后一次点击生效。在单机环境下，这可以通过简单的计时器来实现；但在分布式系统中，情况变得更加复杂，因为多个服务实例可能会同时接收到相同的请求。

确保多实例间一致性的方法

幂等操作

幂等操作指的是多次执行该操作产生的效果与一次执行相同。通过设计幂等接口，我们可以减少对锁的需求，因为每个实例都可以独立判断是否应该处理某个请求。

示例代码：
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

public class IdempotentOperation {
    private static final Map<String, Boolean> operationCache = new ConcurrentHashMap<>();

    public void execute(String operationId, Runnable action) {
        if (!operationCache.containsKey(operationId)) {
            synchronized (operationCache) {
                if (!operationCache.containsKey(operationId)) {
                    operationCache.put(operationId, true);
                    action.run();
                }
            }
        } else {
            System.out.println("Operation already processed: " + operationId);
        }
    }

    // 测试用例
    public static void main(String[] args) {
        IdempotentOperation idempotentOperation = new IdempotentOperation();
        String operationId = "operation_001";

        idempotentOperation.execute(operationId, () -> {
            System.out.println("Executing operation: " + operationId);
        });

        idempotentOperation.execute(operationId, () -> {
            System.out.println("This should not print.");
        });
    }
}

TTL缓存 + 分布式一致性

利用带有TTL的时间戳存储在Redis或其他分布式缓存中，可以有效地防止短时间内重复执行相同的请求。这种方式不仅减少了锁的竞争，还提高了系统的响应速度。

Maven依赖
<dependency>
    <groupId>redis.clients</groupId>
    <artifactId>jedis</artifactId>
    <version>4.0.1</version>
</dependency>
示例代码
import redis.clients.jedis.Jedis;

public class DebounceWithRedis {
    private static final int DEBOUNCE_WINDOW = 5; // 防抖窗口时间，单位秒
    private Jedis jedis;

    public DebounceWithRedis(String host, int port) {
        this.jedis = new Jedis(host, port);
    }

    /**
     * 检查是否需要执行某个操作。
     * 如果该操作在过去DEBOUNCE_WINDOW秒内已经执行过，则返回false；否则，设置一个TTL并返回true。
     */
    public boolean shouldExecute(String operationId) {
        String key = "debounce:" + operationId;
        if (jedis.exists(key)) {
            System.out.println("Operation is within debounce period.");
            return false;
        } else {
            // 设置键值对，有效期为DEBOUNCE_WINDOW秒
            jedis.setex(key, DEBOUNCE_WINDOW, "true");
            return true;
        }
    }

    // 关闭资源
    public void close() {
        if (jedis != null) {
            jedis.close();
        }
    }

    public static void main(String[] args) {
        try (DebounceWithRedis debounce = new DebounceWithRedis("localhost", 6379)) {
            // 测试用例
            String operationId = "operation_001";
            if (debounce.shouldExecute(operationId)) {
                System.out.println("Executing operation: " + operationId);
                // 执行实际的操作...
            }
            // 等待一段时间后再次尝试
            Thread.sleep(6000);
            if (debounce.shouldExecute(operationId)) {
                System.out.println("Executing operation again after debounce period: " + operationId);
                // 再次执行实际的操作...
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

事件总线或消息队列

使用Kafka、RabbitMQ等消息中间件，可以集中管理防抖逻辑。所有的实例都将待防抖的操作发送到消息队列，由专门的消费者负责处理这些操作。

使用Kafka作为事件总线实现防抖

Kafka是一个高效的分布式消息队列，非常适合用来处理防抖逻辑。下面是如何配置Kafka生产者和消费者来实现防抖功能的例子。

Maven依赖
<dependency>
    <groupId>org.apache.kafka</groupId>
    <artifactId>kafka-clients</artifactId>
    <version>3.0.0</version>
</dependency>
生产者代码
import org.apache.kafka.clients.producer.KafkaProducer;
import org.apache.kafka.clients.producer.ProducerRecord;

import java.util.Properties;

public class DebounceProducer {
    private static final String TOPIC_NAME = "debounce-topic";
    private KafkaProducer<String, String> producer;

    public DebounceProducer() {
        Properties props = new Properties();
        props.put("bootstrap.servers", "localhost:9092");
        props.put("key.serializer", "org.apache.kafka.common.serialization.StringSerializer");
        props.put("value.serializer", "org.apache.kafka.common.serialization.StringSerializer");
        producer = new KafkaProducer<>(props);
    }

    public void sendDebounceEvent(String operationId) {
        ProducerRecord<String, String> record = new ProducerRecord<>(TOPIC_NAME, operationId, operationId);
        producer.send(record);
    }

    public void close() {
        if (producer != null) {
            producer.close();
        }
    }

    // 测试用例
    public static void main(String[] args) {
        try (DebounceProducer producer = new DebounceProducer()) {
            String operationId = "operation_001";
            producer.sendDebounceEvent(operationId);
        }
    }
}
消费者代码
import org.apache.kafka.clients.consumer.ConsumerRecord;
import org.apache.kafka.clients.consumer.ConsumerRecords;
import org.apache.kafka.clients.consumer.KafkaConsumer;

import java.time.Duration;
import java.util.Collections;
import java.util.Properties;

public class DebounceConsumer {
    private static final String TOPIC_NAME = "debounce-topic";
    private KafkaConsumer<String, String> consumer;

    public DebounceConsumer() {
        Properties props = new Properties();
        props.put("bootstrap.servers", "localhost:9092");
        props.put("group.id", "debounce-group");
        props.put("enable.auto.commit", "true");
        props.put("key.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");
        props.put("value.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");
        consumer = new KafkaConsumer<>(props);
        consumer.subscribe(Collections.singletonList(TOPIC_NAME));
    }

    public void consumeEvents() {
        while (true) {
            ConsumerRecords<String, String> records = consumer.poll(Duration.ofMillis(100));
            for (ConsumerRecord<String, String> record : records) {
                System.out.printf("Consumed event from topic %s: key = %s value = %s%n", record.topic(), record.key(), record.value());
                // 执行实际的操作...
            }
        }
    }

    public void close() {
        if (consumer != null) {
            consumer.close();
        }
    }

    // 测试用例
    public static void main(String[] args) {
        DebounceConsumer consumer = new DebounceConsumer();
        consumer.consumeEvents();
    }
}

异步任务调度器

Celery等异步任务调度器通常具有内置的任务去重和延时执行功能，可以在一定程度上实现防抖效果。

客户端或API网关层面的防抖

如果应用环境允许，在客户端或API网关处实现防抖逻辑可以更早地过滤掉不必要的重复请求，从而减轻后端系统的负担。下面是一个简单的API网关例子，它基于Spring Cloud Gateway框架实现了防抖功能。

添加依赖
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-gateway</artifactId>
</dependency>
<dependency>
    <groupId>redis.clients</groupId>
    <artifactId>jedis</artifactId>
    <version>4.0.1</version>
</dependency>
配置类
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;

@Configuration
public class RedisConfig {

    @Bean
    public JedisPool jedisPool() {
        return new JedisPool(new JedisPoolConfig(), "localhost", 6379);
    }
}
自定义过滤器
import org.springframework.cloud.gateway.filter.GatewayFilterChain;
import org.springframework.cloud.gateway.filter.GlobalFilter;
import org.springframework.core.Ordered;
import org.springframework.stereotype.Component;
import org.springframework.web.server.ServerWebExchange;
import reactor.core.publisher.Mono;
import redis.clients.jedis.Jedis;

@Component
public class DebounceFilter implements GlobalFilter, Ordered {

    private static final int DEBOUNCE_WINDOW = 5; // 防抖窗口时间，单位秒
    private final JedisPool jedisPool;

    public DebounceFilter(JedisPool jedisPool) {
        this.jedisPool = jedisPool;
    }

    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        String operationId = exchange.getRequest().getQueryParams().getFirst("operationId");

        try (Jedis jedis = jedisPool.getResource()) {
            String key = "debounce:" + operationId;
            if (jedis.exists(key)) {
                System.out.println("Operation is within debounce period.");
                return exchange.getResponse().setComplete();
            } else {
                // 设置键值对，有效期为DEBOUNCE_WINDOW秒
                jedis.setex(key, DEBOUNCE_WINDOW, "true");
            }
        }

        return chain.filter(exchange);
    }

    @Override
    public int getOrder() {
        return -1;
    }
}

一致性哈希与分区

对于一些特定类型的请求，可以考虑使用一致性哈希算法将请求分配给固定的节点处理，从而简化防抖逻辑的实现。

限流和熔断机制

结合限流和熔断机制可以帮助保护系统免受过多的重复请求影响，虽然这不是直接解决防抖问题的方法，但在高并发情况下非常有用。

避免锁竞争导致的性能瓶颈

在分布式环境中，锁竞争是造成性能瓶颈的主要原因之一。为了减少这种竞争，我们可以采用无锁数据结构、分布式缓存以及合理的设计幂等操作等策略。此外，尽量减少锁的持有时间和范围也是提高系统性能的关键。我们还可以考虑以下几种方法：

  • 乐观锁：通过版本号或时间戳来实现非阻塞的并发控制。
  • 分片锁：将资源分成多个片段，每个片段有自己的锁，从而减少整体的竞争。
  • 读写分离：对于读多写少的情况，可以采用读写分离的方式，以减轻写锁的压力。

Java示例代码

本节提供了几种不同方法的Java代码示例，包括但不限于上述提到的技术。每种方法都有其特点和适用场景，选择合适的方案取决于具体的应用需求和技术栈。

实现幂等操作

为了确保操作是幂等的，我们可以设计一个服务接口，它接受一个唯一的标识符作为参数，并在执行之前检查这个标识符是否已经被处理过。这里我们假设有一个数据库表operations用于记录每个操作的状态。

数据库表结构（SQL）
CREATE TABLE operations (
    id VARCHAR(255) PRIMARY KEY,
    status ENUM('PENDING', 'COMPLETED') NOT NULL DEFAULT 'PENDING',
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);
Java代码
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;

public class IdempotentService {

    private static final String DB_URL = "jdbc:mysql://localhost:3306/yourdb";
    private static final String USER = "username";
    private static final String PASS = "password";

    /**
     * 尝试执行一个幂等操作。
     * 如果操作尚未完成，则标记为正在处理，并执行之；如果已完成，则直接返回结果。
     */
    public void executeIdempotentOperation(String operationId) throws SQLException {
        try (Connection conn = DriverManager.getConnection(DB_URL, USER, PASS)) {
            // 开始事务
            conn.setAutoCommit(false);

            // 检查操作状态
            String checkSql = "SELECT status FROM operations WHERE id = ?";
            try (PreparedStatement pstmt = conn.prepareStatement(checkSql)) {
                pstmt.setString(1, operationId);
                try (ResultSet rs = pstmt.executeQuery()) {
                    if (rs.next()) {
                        if ("COMPLETED".equals(rs.getString("status"))) {
                            System.out.println("Operation already completed: " + operationId);
                            conn.commit(); // 提交事务
                            return;
                        }
                    } else {
                        // 插入新操作记录
                        String insertSql = "INSERT INTO operations (id, status) VALUES (?, ?)";
                        try (PreparedStatement insertStmt = conn.prepareStatement(insertSql)) {
                            insertStmt.setString(1, operationId);
                            insertStmt.setString(2, "PENDING");
                            insertStmt.executeUpdate();
                        }

                        // 执行实际的操作...
                        System.out.println("Executing operation: " + operationId);

                        // 更新操作状态为已完成
                        String updateSql = "UPDATE operations SET status = 'COMPLETED' WHERE id = ?";
                        try (PreparedStatement updateStmt = conn.prepareStatement(updateSql)) {
                            updateStmt.setString(1, operationId);
                            updateStmt.executeUpdate();
                        }
                    }
                }
            }
            conn.commit(); // 提交事务
        }
    }

    // 测试用例
    public static void main(String[] args) {
        try {
            IdempotentService service = new IdempotentService();
            String operationId = "operation_001";
            service.executeIdempotentOperation(operationId);
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}

结论

在分布式系统中实现防抖策略是一门艺术，它要求我们在一致性和性能之间找到平衡点。通过合理运用幂等操作、分布式缓存、消息队列等技术，我们可以有效地减少锁竞争带来的性能瓶颈，同时保证防抖逻辑在多实例间的正确性。不同的应用场景可能需要不同的解决方案组合，因此理解各种方法的特点及其适用场景是非常重要的。

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

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

easegen将教材批量生成可控ppt课件方案设计

easegen将教材批量生成可控ppt课件方案设计

之前客户提出过一个需求&#xff0c;就是希望可以将一本教材&#xff0c;快速的转换为教学ppt&#xff0c;虽然通过人工程序脚本的方式&#xff0c;已经实现了该功能&#xff0c;但是因为没有做到通用&#xff0c;每次都需要修改脚本&#xff0c;无法让客户自行完成所有流程&am…
阅读更多...
高考志愿填报：如何制定合理的志愿梯度？

高考志愿填报：如何制定合理的志愿梯度？

高考志愿填报中常见的避雷行为&#xff0c;深入分析了专业选择、招生政策了解、学校选择、备选方案准备以及防诈骗等方面的关键问题&#xff0c;并提出了针对性的建议与策略。旨在为考生和家长提供实用的指导&#xff0c;助力考生科学合理地填报高考志愿&#xff0c;避免陷入各…
阅读更多...
如何查看vivado项目所使用的版本

如何查看vivado项目所使用的版本

在我们提供的各类教程中vivado使用的版本都不同&#xff0c;而使用不同版本的vivado打开项目时可能会产生一些其它错误&#xff0c;所有最好使用对应的vivado版本打开&#xff0c;本例主要演示如何查看项目所示使用的vivado版本。 如下图所示&#xff0c;为vivado2023.1版本创建…
阅读更多...
ue5 pcg（程序内容生成）真的简单方便，就5个节点

ue5 pcg（程序内容生成）真的简单方便，就5个节点

总结&#xff1a; 前情提示 鼠标单击右键平移节点 1.编辑-》插件-》procedural->勾选两个插件 2.右键-》pcg图表-》拖拽进入场景 3.先看点point 右键-》调试(快捷键d)->右侧设置粒子数 3.1调整粒子数 可以在右侧输入框&#xff0c;使用加减乘除 4.1 表面采样器 …
阅读更多...
光谱相机在农业的应用

光谱相机在农业的应用

一、作物生长监测1、营养状况评估 原理&#xff1a;不同的营养元素在植物体内的含量变化会导致植物叶片或其他组织的光谱反射率特性发生改变。例如&#xff0c;氮元素是植物叶绿素的重要组成部分&#xff0c;植物缺氮时&#xff0c;叶绿素含量下降&#xff0c;其在可见光波段&a…
阅读更多...
基于Springboot的数字科技风险报告管理系统

基于Springboot的数字科技风险报告管理系统

博主介绍&#xff1a;java高级开发&#xff0c;从事互联网行业六年&#xff0c;熟悉各种主流语言&#xff0c;精通java、python、php、爬虫、web开发&#xff0c;已经做了多年的设计程序开发&#xff0c;开发过上千套设计程序&#xff0c;没有什么华丽的语言&#xff0c;只有实…
阅读更多...
14，攻防世界Web_php_unserialize

14，攻防世界Web_php_unserialize

进入场景 看见代码&#xff0c;解析一下 这段PHP代码定义了一个名为Demo的类&#xff0c;并演示了如何通过URL参数进行反序列化和文件高亮显示的功能&#xff0c;同时也包含了一些安全措施以防止对象注入攻击。下面是对这段代码的逐行解释&#xff1a; 1.<php 开始PHP代码…
阅读更多...
基于NodeMCU的物联网窗帘控制系统设计

基于NodeMCU的物联网窗帘控制系统设计

最终效果 基于NodeMCU的物联网窗帘控制系统设计 项目介绍 该项目是“物联网实验室监测控制系统设计&#xff08;仿智能家居&#xff09;”项目中的“家电控制设计”中的“窗帘控制”子项目&#xff0c;最前者还包括“物联网设计”、“环境监测设计”、“门禁系统设计计”和“小…
阅读更多...
【Linux开发工具】自动化构建-make/Makefile

【Linux开发工具】自动化构建-make/Makefile

&#x1f525;个人主页&#x1f525;&#xff1a;孤寂大仙V &#x1f308;收录专栏&#x1f308;&#xff1a;Linux &#x1f339;往期回顾&#x1f339;&#xff1a;【Linux开发工具】gcc和g &#x1f516;流水不争&#xff0c;争的是滔滔不 一、make和Makefile简介1.1 什么是…
阅读更多...
Elasticsearch安装和数据迁移

Elasticsearch安装和数据迁移

Elasticsearch安装和数据迁移 Elasticsearch安装 下载并解压Elasticsearch 首先下载Elasticsearch的tar.gz文件&#xff0c;并将其解压&#xff1a; wget https://artifacts.elastic.co/downloads/elasticsearch/elasticsearch-8.8.2-linux-x86_64.tar.gz tar -xzf elastics…
阅读更多...
dockerfile文档编写（1）：基础命令

dockerfile文档编写（1）：基础命令

目录 Modelscope-agentARGFROMWORKDIRCOPYRUNENVCMD run_loopy Modelscope-agent ARG BASE_IMAGEregistry.cn-beijing.aliyuncs.com/modelscope-repo/modelscope:ubuntu22.04-cuda12.1.0-py310-torch2.1.2-tf2.14.0-1.12.0FROM $BASE_IMAGEWORKDIR /home/workspaceCOPY . /hom…
阅读更多...
【论文阅读笔记】Learning to sample

【论文阅读笔记】Learning to sample

Learning to sample 前沿引言方法问题声明S-NET匹配ProgressiveNet: sampling as ordering 实验分类检索重建 结论附录 前沿 这是一篇比较经典的基于深度学习的点云下采样方法 核心创新点&#xff1a; 首次提出了一种学习驱动的、任务特定的点云采样方法引入了两种采样网络&…
阅读更多...
置换密码程序设计

置换密码程序设计

实验目的与要求 1. 帮助学生掌握置换密码的加密解密过程&#xff0c;能够利用所学过的编程语言&#xff0c;实现加解密算法。使学生掌握编程实现实际问题中的方法&#xff0c;提高专业技能和专业素养。 2. 要求学生掌握算法的程序实现的方法,能应用密码算法的特点&#xff0c…
阅读更多...
Android修行手册 - 移动端几种常用动画方案对比

Android修行手册 - 移动端几种常用动画方案对比

Unity3D特效百例案例项目实战源码Android-Unity实战问题汇总游戏脚本-辅助自动化Android控件全解手册再战Android系列Scratch编程案例软考全系列Unity3D学习专栏蓝桥系列ChatGPT和AIGC &#x1f449;关于作者 专注于Android/Unity和各种游戏开发技巧&#xff0c;以及各种资源分…
阅读更多...
【计算机视觉基础CV-图像分类】03-深度学习图像分类实战：鲜花数据集加载与预处理详解

【计算机视觉基础CV-图像分类】03-深度学习图像分类实战：鲜花数据集加载与预处理详解

本文将深入介绍鲜花分类数据集的加载与处理方式&#xff0c;同时详细解释代码的每一步骤并给出更丰富的实践建议和拓展思路。以实用为导向&#xff0c;为读者提供从数据组织、预处理、加载到可视化展示的完整过程&#xff0c;并为后续模型训练打下基础。 前言 在计算机视觉的深…
阅读更多...
Windows查看MD5

Windows查看MD5

如何在Windows&#xff0c;查看一个文件的MD5 1、ctrlr&#xff0c;输入cmd 2、执行命令certutil -hashfile 文件路径&#xff08;按住将文件拖进来就行&#xff09; MD5 3、执行命令certutil -hashfile 文件路径&#xff08;按住将文件拖进来就行&#xff09;SHA1 可查看SHA…
阅读更多...
【优化算法】莲花效应优化算法（LEA）：一种基于莲花自然启发的工程设计优化算法

【优化算法】莲花效应优化算法（LEA）：一种基于莲花自然启发的工程设计优化算法

目录 1.摘要2.算法原理3.结果展示4.参考文献5.代码获取 1.摘要 本文提出了一种新的进化算法——莲花效应算法&#xff08;LEA&#xff09;&#xff0c;该算法结合了蜻蜓算法中的高效操作算子&#xff0c;例如蜻蜓在花朵授粉中的运动方式用于探索&#xff0c;以及水在花叶上的自…
阅读更多...
Next.js v15 - 服务器操作以及调用原理

Next.js v15 - 服务器操作以及调用原理

约定 服务器操作是在服务器上执行的异步函数。它们可以在服务器组件和客户端组件中调用&#xff0c;用于处理 Next.js 应用程序中的表单提交和数据修改。 服务器操作可以通过 React 的 “use server” 指令定义。你可以将该指令放在 async 函数的顶部以将该函数标记为服务器操…
阅读更多...
DataV的安装与使用（Vue3版本）

DataV的安装与使用（Vue3版本）

1、DataV(vue3)地址&#xff1a;DataV Vue3TSVite版 | DataV - Vue3 2、使用 npm install kjgl77/datav-vue3 安装 3、全局引入。 4、此时就可以按需使用了~
阅读更多...
隐藏指定文件/文件夹和自动提示功能消失解决方案

隐藏指定文件/文件夹和自动提示功能消失解决方案

一. 隐藏指定文件/文件夹 Idea中隐藏指定文件或指定类型文件 Setting → File Types → Ignored Files and Folders输入要隐藏的文件名&#xff0c;支持*号通配符回车确认添加 二. 自动提示功能消失解决方案 指定SpringBoot配置文件 File → Project Structure → Facets选…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023