缓存和数据库一致性

前言：

项目的难点是如何保证缓存和数据库的一致性。无论我们是先更新数据库，后更新缓存还是先更新数据库，然后删除缓存，在并发场景之下，仍然会存在数据不一致的情况（也存在删除失败的情况，删除失败可以使用异步重试解决）。有一种解决方法是延迟双删的策略，先删除缓存，再更新数据库，然后休眠一会儿，再删除一次缓存，这样做可以提高提高数据的一致性，但是，延迟的时间是要根据业务需求决定的，需要谨慎设置，同时由于删除了两次缓存，导致性能下降。这个项目中选择的是借助canal，订阅binlog的方式来实现同步。当我们对数据进行修改的时候，数据库就有一个binlog，用canal订阅这个binlog，并将消息投放到kafka中，获取到变更数据的id，删除缓存，如果失败，则重新从消息队列中获得该数据进行重试，超过次数后提示错误信息。重试使用的是@Retryable注解，有最大重试次数、重试延迟时间等属性，如果三次重试后仍然失败，会抛出 RuntimeException，然后触发@recover注解标记的备用方法。

（把canal.serverMode = kafka，canal.destinations = example （对应一个数据库实例），

在example下修改MySQL实例配置文件，设置用户名、登陆密码、需要同步的表，topic等等）

然后创建消费者，接收topic传过来的消息，进行解析，获取id，删除缓存。

canal本质（工作原理）

  • canal 模拟 MySQL slave 的交互协议，伪装自己为 MySQL slave ，向 MySQL master 发送 dump 协议；
  • MySQL master 收到 dump 请求，开始推送 binary log 给 slave (即 canal )；
  • canal 解析 binary log 对象(原始为 byte 流)；
  • 并将其发送给下游消息队列
     
/**
 * canal 发送过来的消息
 *
 * @author huan.fu 2021/9/2 - 下午4:06
 */
@Getter
@Setter
@ToString
public class CanalMessage {

    /**
     * 测试得出 同一个事物下产生多个修改，这个id的值是一样的。
     */
    private Integer id;

    /**
     * 数据库或schema
     */
    private String database;
    /**
     * 表名
     */
    private String table;
    /**
     * 主键字段名
     */
    private List<String> pkNames;
    /**
     * 是否是ddl语句
     */
    private Boolean isDdl;
    /**
     * 类型:INSERT/UPDATE/DELETE
     */
    private String type;
    /**
     * binlog executeTime, 执行耗时
     */
    private Long es;
    /**
     * dml build timeStamp, 同步时间
     */
    private Long ts;
    /**
     * 执行的sql,dml sql为空
     */
    private String sql;
    /**
     * 数据列表
     */
    private List<Map<String, Object>> data;
    /**
     * 旧数据列表,用于update,size和data的size一一对应
     */
    private List<Map<String, Object>> old;
}

import org.springframework.kafka.annotation.KafkaListener;
import org.springframework.retry.annotation.Backoff;
import org.springframework.retry.annotation.Recover;
import org.springframework.retry.annotation.Retryable;
import org.springframework.stereotype.Component;

@Component
@Slf4j
public class KafkaConsumer {

    @KafkaListener(topics = "customer", groupId = "canal-kafka-springboot-001", concurrency = "5")
    @Retryable(maxAttempts = 3, backoff = @Backoff(delay = 1000))
    public void consumer(ConsumerRecord<String, String> record, Acknowledgment ack) throws InterruptedException {
        log.info(Thread.currentThread().getName() + ":" + LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")) + "接收到kafka消息,partition:" + record.partition() + ",offset:" + record.offset() + "value:" + record.value());

        CanalMessage canalMessage = JSON.parseObject(record.value(), CanalMessage.class);

        log.info("\r=================================");
        log.info("接收到的原始 canal message为: {}", record.value());
        log.info("转换成Java对象后转换成Json为 : {}", JSON.toJSONString(canalMessage));

        // 重试删除缓存的操作
        retryDeleteCache(canalMessage, 1); // 初始重试次数为 1

        ack.acknowledge();
    }

    @Retryable(maxAttempts = 3, backoff = @Backoff(delay = 1000))
    private void retryDeleteCache(CanalMessage canalMessage, int retryCount) {
        try {
            // 删除缓存的操作
            deleteCache(canalMessage);
            log.info("删除缓存成功");
        } catch (Exception e) {
            // 处理删除缓存失败的异常
            log.error("删除缓存失败：{}", e.getMessage());
            if (retryCount < 3) {
                // 如果未达到最大重试次数，继续重试
                retryDeleteCache(canalMessage, retryCount + 1);
            } else {
                // 达到最大重试次数，抛出异常触发 @Recover 方法
                throw new RuntimeException("删除缓存达到最大重试次数");
            }
        }
    }

    private void deleteCache(CanalMessage canalMessage) {
        // 实际的删除缓存的操作
        // ...
        // 这里可以模拟删除失败的情况
        if (shouldFailToDeleteCache()) {
            throw new RuntimeException("模拟删除缓存失败");
        }
    }

    private boolean shouldFailToDeleteCache() {
        // 模拟删除缓存失败的条件，你可以根据实际情况进行修改
        return Math.random() < 0.5;
    }

    @Recover
    private void recoverAfterMaxAttempts(Exception e, CanalMessage canalMessage) {
        // 在达到最大重试次数后执行的备用方法
        log.error("删除缓存达到最大重试次数，执行备用方法：{}", e.getMessage());
        // 可以在这里处理达到最大重试次数后的逻辑，例如记录日志、发送通知等
    }
}

先更新数据库，后更新缓存

假设我们采用「先更新数据库，再更新缓存」的方案，并且两步都可以「成功执行」的前提下，如果存在并发，情况会是怎样的呢？

有线程 A 和线程 B 两个线程，需要更新「同一条」数据，会发生这样的场景：

  1. 线程 A 更新数据库（X = 1）

  2. 线程 B 更新数据库（X = 2）

  3. 线程 B 更新缓存（X = 2）

  4. 线程 A 更新缓存（X = 1）

最终 X 的值在缓存中是 1，在数据库中是 2，发生不一致。A 虽然先于 B 发生，但 B 操作数据库和缓存的时间，却要比 A 的时间短，执行时序发生「错乱」，最终这条数据结果是不符合预期的。

先更新数据库，后删除缓存

依旧是 2 个线程并发「读写」数据：

  1. 缓存中 X 不存在（数据库 X = 1）

  2. 线程 A 读取数据库，得到旧值（X = 1）

  3. 线程 B 更新数据库（X = 2)

  4. 线程 B 删除缓存

  5. 线程 A 将旧值写入缓存（X = 1）

最终 X 的值在缓存中是 1（旧值），在数据库中是 2（新值），也发生不一致。

相关代码：

    public R save(UserVO userVO) {
        User user = new User();
        BeanUtils.copyProperties(userVO, user);
        saveUser(user);
        //删除缓存
        redisTemplate.delete("userInfo:" + user.getUserName());
        return R.success("操作成功");
    }

在查询数据时，先从缓存获取，如果缓存没有，就从数据库查询，并同时存放到缓存上，这样保证了下次访问时数据能直接从缓存获取，减少了数据库压力

    public User getByUserName(String userName) {
        User user = (User) redisTemplate.opsForValue().get(userName);
        if (user != null) {
            return user;
        }
        user = this.getOne(Wrappers.<User>lambdaQuery().eq(User::getUserName, userName));
        redisTemplate.opsForValue().set("userInfo:" + userName, user);
        return user;
    }

但是执行redis的删除操作时，比如因为网络问题，或者redis本身服务问题，就会失败，而且多线程并发访问时，也会出现数据不一致的情况。

    //使用注解，直接实现先更新数据库，后删除缓存的操作
    @CacheEvict(value = "category",allEntries = true)       //删除某个分区下的所有数据

延迟双删：

  1. 首先，删除了 Redis 中的缓存数据，以确保接下来的读取操作会从数据库中读取最新的数据。
  2. 接着，更新数据库中的数据，将数据更新为最新的值。
  3. 在此之后，代码让当前线程休眠一段时间N，这个时间段是为了给数据库操作足够的时间来完成，确保数据已经持久化到数据库中。
  4. 最后，代码再次删除 Redis 中的缓存数据。这里是延迟双删的关键步骤。由于之前已经删除了缓存数据，再次删除的目的是为了防止在休眠的时间内有其他线程读取到旧的数据，加载到缓存中。

休眠时间的控制

  • 延迟时间要大于「主从复制」的延迟时间

  • 延迟时间要大于线程 B 读取数据库 + 写入缓存的时间

方案的选择：

  • 延时双删适用于对数据一致性要求较高的场景。它能够保证在数据库更新期间，读取请求不会读取到已经失效的缓存数据，从而保证数据的一致性。但是它需要进行两次缓存删除操作，可能会增加一定的资源开销;
  • 先更新数据库后删除缓存对性能要求较高的场景。它能够减少一次缓存删除的开销，但是在数据库更新期间，读取请求可能会读取到已经失效的缓存数据，从而导致数据不一致。
     

RedisUtils.del(key);// 先删除缓存    
updateDB(user);// 更新db中的数据    
Thread.sleep(N);// 延迟一段时间，在删除该缓存key    
RedisUtils.del(key);// 先删除缓存

最好的方法是开设一个线程池，在线程中删除key，而不是使用Thread.sleep进行等待，这样会阻塞用户的请求。

代码：

OrderController中新增接口：

/**
 * 下单接口：先更新数据库，再删缓存
 * @param sid
 * @return
 */
@RequestMapping("/createOrderWithCacheV2/{sid}")
@ResponseBody
public String createOrderWithCacheV2(@PathVariable int sid) {
    int count = 0;
    try {
        // 完成扣库存下单事务
        orderService.createPessimisticOrder(sid);
        // 删除库存缓存
        stockService.delStockCountCache(sid);
    } catch (Exception e) {
        LOGGER.error("购买失败：[{}]", e.getMessage());
        return "购买失败，库存不足";
    }
    LOGGER.info("购买成功，剩余库存为: [{}]", count);
    return String.format("购买成功，剩余库存为：%d", count);
}

新增线程池接口

// 延时双删线程池
private static ExecutorService cachedThreadPool = new ThreadPoolExecutor(0, Integer.MAX_VALUE, 60L, TimeUnit.SECONDS,new SynchronousQueue<Runnable>());
 
 
/**
 * 缓存再删除线程
 */
private class delCacheByThread implements Runnable {
    private int sid;
    public delCacheByThread(int sid) {
        this.sid = sid;
    }
    public void run() {
        try {
            LOGGER.info("异步执行缓存再删除，商品id：[{}]， 首先休眠：[{}] 毫秒", sid, DELAY_MILLSECONDS);
            Thread.sleep(DELAY_MILLSECONDS);
            stockService.delStockCountCache(sid);
            LOGGER.info("再次删除商品id：[{}] 缓存", sid);
        } catch (Exception e) {
            LOGGER.error("delCacheByThread执行出错", e);
        }
    }
}

异步重试：

将删除缓存的请求写到消息队列中，如果删除成功，则去除消息；如果删除失败，执行失败策略，重试服务从消息队列中重新读取这些值，然后再次进行删除重试，重试超过的一定次数，向业务层发送报错信息。但是这在一定程度上也会增加代码的耦合度和维护成本。

高内聚，低耦合：耦合指模块与模块之间的关系，依赖程度，尽量减少一个模块过度依赖另一个模块的情况（我们在A元素去调用B元素，当B元素有问题或者不存在的时候，A元素就不能正常的工作，那么就说元素A和元素B耦合）。内聚模块内部的功能职责的相关性，如果元素有高度的相关职责，除了这些职责在没有其他的工作，那么该元素就有高内聚。这样做是为了可读性，复用性，可维护性和易变更性。

代码实现（使用rocketmq）：

pom.xml新增rocketmq依赖：

<rocketmq-spring-boot-starter-version>2.0.3</rocketmq-spring-boot-starter-version>

<dependency>
    <groupId>org.apache.rocketmq</groupId>
    <artifactId>rocketmq-client</artifactId>
    <version>4.9.3</version>
</dependency>
<dependency>
    <groupId>org.apache.rocketmq</groupId>
    <artifactId>rocketmq-spring-boot-starter</artifactId>
    <version>${rocketmq-spring-boot-starter-version}</version>
</dependency>

yaml配置

rocketmq:
  name-server: xxx.xxx.xxx.174:9876;xxx.xxx.xxx.246:9876
  producer:
    group: shopDataGroup

创建服务：

@Override
@Transactional
public Result updateShopById(Shop shop) {
    Long id = shop.getId();
    if(ObjectUtil.isNull(id)){
        return Result.fail("====>店铺ID不能为空");
    }
    log.info("====》开始更新数据库");
    //更新数据库
    updateById(shop);
    String shopRedisKey = SHOP_CACHE_KEY + id;
    Message message = new Message(TOPIC_SHOP,"shopRe",shopRedisKey.getBytes());
    //异步发送MQ
    try {
        rocketMQTemplate.getProducer().send(message);
    } catch (Exception e) {
        log.info("=========>发送异步消息失败：{}",e.getMessage());
    }
    //stringRedisTemplate.delete(SHOP_CACHE_KEY + id);
    //int i = 1/0;  验证异常流程后，
    return Result.ok();
}

创建消费者：

package com.hmdp.mq;
/**
 * @author xbhog
 * @describe:
 * @date 2022/12/21
 */
@Slf4j
@Component
@RocketMQMessageListener(topic = TOPIC_SHOP,consumerGroup = "shopRe",
        messageModel = MessageModel.CLUSTERING)
public class RocketMqNessageListener  implements RocketMQListener<MessageExt> {
    @Resource
    private StringRedisTemplate stringRedisTemplate;

    @SneakyThrows
    @Override
    public void onMessage(MessageExt message) {
        log.info("========>异步消费开始");
        String body = null;
        body = new String(message.getBody(), "UTF-8");
        stringRedisTemplate.delete(body);
        int reconsumeTimes = message.getReconsumeTimes();
        log.info("======>重试次数{}",reconsumeTimes);
        if(reconsumeTimes > 3){
            log.info("消费失败：{}",body);
            return;
        }
        throw new RuntimeException("模拟异常抛出");
    }

}

kafuka的删除重试机制：Kafka 生产者负责将删除缓存的请求发送到指定主题，而 Kafka 消费者则监听该主题，处理删除缓存的逻辑。在处理失败时，通过不提交偏移量来实现消息的重试。

import org.apache.kafka.clients.consumer.*;
import org.apache.kafka.common.TopicPartition;

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

public class CacheDeletionConsumer {

    private static final String TOPIC = "cache-deletion-topic";
    private static final String GROUP_ID = "cache-deletion-group";
    private static final String BOOTSTRAP_SERVERS = "your_bootstrap_servers";

    public static void main(String[] args) {
        Properties props = new Properties();
        props.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG, BOOTSTRAP_SERVERS);
        props.put(ConsumerConfig.GROUP_ID_CONFIG, GROUP_ID);
        props.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, "org.apache.kafka.common.serialization.StringDeserializer");
        props.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, "org.apache.kafka.common.serialization.StringDeserializer");

        try (KafkaConsumer<String, String> consumer = new KafkaConsumer<>(props)) {
            consumer.subscribe(Collections.singletonList(TOPIC));

            while (true) {
                ConsumerRecords<String, String> records = consumer.poll(Duration.ofMillis(100));

                for (ConsumerRecord<String, String> record : records) {
                    try {
                        // 处理删除缓存的业务逻辑
                        processCacheDeletion(record);

                        // 如果删除成功，手动提交偏移量
                        consumer.commitSync();
                    } catch (Exception e) {
                        // 处理删除缓存失败，不提交偏移量，消息将在下次拉取时重新获取
                        handleCacheDeletionFailure(record, e);
                    }
                }
            }
        }
    }

    private static void processCacheDeletion(ConsumerRecord<String, String> record) {
        // 实际的删除缓存逻辑
        String cacheKey = record.value().substring("DELETE_CACHE:".length());
        System.out.println("Deleting cache for key: " + cacheKey);
    }

    private static void handleCacheDeletionFailure(ConsumerRecord<String, String> record, Exception e) {
        // 处理删除缓存失败的逻辑，可以记录日志、进行重试等
        System.err.println("Error deleting cache for key: " + record.value() + ". Exception: " + e.getMessage());
    }
}

参考：两难！先更新数据库再删缓存？还是先删缓存再更新数据库？-CSDN博客

https://www.cnblogs.com/xbhog/p/17004151.html

订阅binlog异步删除，使用canal

流程如下图所示：

（1）更新数据库数据

（2）数据库会将操作信息写入binlog日志当中

（3）canal订阅程序提取出所需要的数据以及key

（4）另起一段非业务代码，获得该信息

（5）尝试删除缓存操作，发现删除失败

（6）将这些信息发送至消息队列

（7）重新从消息队列中获得该数据，重试操作

canal基础知识：

Canal组件是一个基于MysQL数据库增量日志解析,提供增量数据订阅和消费,支持将增量数据投递到下游消费者(如Kafka、RocketMQ等)或者存储(如Elasticsearch、HBase等)的组件。

binlog的格式：

canal工作原理

  1. Canal将自己伪装为MysQL slave(从库),向MysQL master(住库)发送dump协议
  2. MysQLmaster(主库)收到dump请求,开始推送binarylog给slave(即canal).
  3. Canal接收并解析Binlog日志,得到变更的数据,执行后续逻辑

修改配置支持binlog：

修改canal.properties配置：

修改mysql文件的instance.properties配置：

代码：

//1.获取canal连接对象
CanalConnector canalConnector=CanalConnectors.newSingleConnector(new InetSocketAddress(   hostname:"localhost",port:11111),destination:"example",username:"",password:"");
    while(true){
        //2.获取连接
        canalConnector.connect(;
        //3.指定要监控的数据库
        canalConnector.subscribe( s:"canal-demo.*");
        //4.获取Message
        Message message =canalConnector.get(100);
        List<CanalEntry.Entry>entries =message.getEntries();
        if(entries.size()<=0){
            System.out.println("没有数据,休息一会");
            try {
                Thread.sleep(millis:1000);
            }catch(InterruptedException e){
                e.printStackTrace();
            }
        }else{
            for(CanalEntry.Entry entry:entries){
            //获取表名
            String tableName =entry.getHeader().getTableName();
            //Entry类型
            CanalEntry.EntryType entryType =entry.getEntryType();
            //判断entryType 是否为ROWDATA
            if (CanalEntry.EntryType.ROWDATA.equals(entryType)){    
            //序列化数据
            ByteString storeValue =entry.getStoreValue();
            // 反序列化
            CanalEntry.RowChange rowChange =CanalEntry.RowChange.parseForm(storeValue);
            //获取事件类型
            CanalEntry.EventType eventType =rowChange.getEventType();
            //获取具体的数据
            List<CanalEntry.RowData>rowDatasList =rowChange.getRowDatasList();
            //遍历并打卬
            for (CanalEntry.RowData rowData : rowDatasList){
                //获取变更前的列
                List<CanalEntry.Column> beforeColumnsList = rowData.getBeforeColumnsList();
                Map<String,0bject>bMap=new HashMap<>();
                for (CanalEntry.CoLumn coLumn : beforeCoLumnsList)
                    //列名和对应的值
                    Map.put(column.getName(O),column.getValue(0);
                    Map<String,0bject> afMap =new HashMap>();
                    //变更后的
                    List<CanalEntry.ColumnafterColumnsList=rowData.getAfterColumnsList();

问:Canal是什么?有哪些特性?
答:Canal是阿里巴巴开源的一款基于Netty实现的分布式、高性能、可靠的消息队列,在实时数据同步和数据分发场景下有着广泛的应用。Canal具有以下特性:支持MysQL、Oracle等数据库的日志解析和订阅;支持多种数据输出方式,如Kafka、RocketMQ、ActiveMQ等;支持支持数据过滤和格式转换;拥有低延迟和高可靠性等优秀的性能指标。
问:Canal的工作原理是什么?
答:Canal主要通过解析数据库的binlog日志来获取到数据库的增、删、改操作,然后将这些变更事件发送给下游的消费者。Canal核心组件包括Client和Server两部分,Client负责连接数据库,并启动日志解析工作,将解析出来的数据发送给Server;Server则负责接收Client发送的数据,并进行数据过滤和分发。Canal还支持多种数据输出器,如Kafka、RocketMQ、ActiveMQ等,可以将解析出来的数据发送到不同的消息队列中,以便进行进一步的处理和分析。
问:Canal的优缺点是什么?
答:Canal的优点主要包括:高性能、分布式、可靠性好、支持数据过滤和转换、跨数据库类型(如MysQL、Oracle等)等。缺点包括:使用难度较大、对数据库的日志产生一定的影响、不支持数据的回溯(即无法获取历史数据)等。
问:Canal在业务中有哪些应用场景?
答:Canal主要用于实时数据同步和数据分发场景,常见的应用场景包括:数据备份与灾备、增量数据抽取和同步、数据实时分析、在线数据迁移等。特别是在互联网大数据场景下,Canal已经成为了各种数据处理任务的重要工具之一。

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

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

相关文章

Docker-Compose构建lnmp

Docker-Compose构建lnmp

目录 实验前准备安装composeNginx准备工作目录准备Dockerfile脚本准备nginx.conf Mysql准备工作目录编写Dockerfile脚本准备my.cnf PHP准备工作目录准备相关文件 编写docker-compose.yml配置文件目录结构启动测试Mysql授权测试 问题Mysql容器无权访问问题浏览器访问file not fo…
阅读更多...
计算机网络 网络安全

计算机网络 网络安全

网络安全 网络安全问题概述 计算机网络面临的女全性威胁 计算机网络的通信而临两大类威胁&#xff0c;即被动攻击和主动攻击 被动攻击是指攻击者从网络上窃听他人的通信内容。通常把这类攻击称为截获。在被动攻击中&#xff0c;攻击者只是观察和分析某一个协议数据单元 PDU…
阅读更多...
R语言【paleobioDB】——pbdb_orig_ext()：绘制随着时间变化而出现的新类群

R语言【paleobioDB】——pbdb_orig_ext()：绘制随着时间变化而出现的新类群

Package paleobioDB version 0.7.0 paleobioDB 包在2020年已经停止更新&#xff0c;该包依赖PBDB v1 API。 可以选择在Index of /src/contrib/Archive/paleobioDB (r-project.org)下载安装包后&#xff0c;执行本地安装。 Usage pbdb_orig_ext (data, rank, temporal_extent…
阅读更多...
各种版本对应关系：SpringCloudAlibaba——SpringCloud——SpringBoot——SpringFramework——JDK

各种版本对应关系：SpringCloudAlibaba——SpringCloud——SpringBoot——SpringFramework——JDK

SpringCloudAlibaba——SpringCloud——SpringBoot——SpringFramework——JDK 一般情况&#xff0c;在https://github.com/项目/wiki目录下有发布信息及对应的要求其他依赖的版本信息SpringCloudAlibaba——SpringCloud——SpringBootSpringBoot和SpringFramework的版本对应关…
阅读更多...
基于MATLAB计算无线通信覆盖（一）环境准备

基于MATLAB计算无线通信覆盖（一）环境准备

一、环境 MATLAB 2022b 注&#xff1a;开始仿真前需部署地理坐标区和地理图&#xff0c;最好采用第三种&#xff0c;直接把底图数据下载到本地&#xff0c;防止连接不上网络时只能显示darkwater的底图。 可用于地理坐标区和地理图的底图如下表所示 二、下载底图并安装 工具&…
阅读更多...
如何用GPT进行论文润色与改写？

如何用GPT进行论文润色与改写？

详情点击链接&#xff1a;如何用GPT/GPT4进行论文润色与改写&#xff1f;一OpenAI 1.最新大模型GPT-4 Turbo 2.最新发布的高级数据分析&#xff0c;AI画图&#xff0c;图像识别&#xff0c;文档API 3.GPT Store 4.从0到1创建自己的GPT应用 5. 模型Gemini以及大模型Claude2二…
阅读更多...
最新可用GPT-3.5、GPT-4、Midjourney绘画、DALL-E3文生图模型教程【宝藏级收藏】

最新可用GPT-3.5、GPT-4、Midjourney绘画、DALL-E3文生图模型教程【宝藏级收藏】

一、前言 ChatGPT3.5、GPT4.0、GPT语音对话、Midjourney绘画&#xff0c;文档对话总结DALL-E3文生图&#xff0c;相信对大家应该不感到陌生吧&#xff1f;简单来说&#xff0c;GPT-4技术比之前的GPT-3.5相对来说更加智能&#xff0c;会根据用户的要求生成多种内容甚至也可以和…
阅读更多...
极狐GitLab 线下『 DevOps专家训练营』成都站开班在即

极狐GitLab 线下『 DevOps专家训练营』成都站开班在即

成都机器人创新中心联合极狐(GitLab)隆重推出极狐GitLab DevOps系列认证培训课程。该课程主要面向使用极狐GitLab的DevOps工程师、安全审计人员、系统运维工程师、系统管理员、项目经理或项目管理人员&#xff0c;完成该课程后&#xff0c;学员将达到DevOps的专家级水平&#x…
阅读更多...
CentOs7.8安装原生Jenkins2.38教程

CentOs7.8安装原生Jenkins2.38教程

CentOs7.8安装Jenkins教程 前提&#xff1a;1、下载安装包2、安装&#xff1a;3、检验是否安装成功&#xff1a;4、查询java路径5、修改配置文件6、创建jenkins用户7、给jenkins用户授权8、开放防火墙端口9、运行和其他jenkins相关命令10、异常情况10.1 提示超时&#xff0c;查…
阅读更多...
DAG最小路径点覆盖，最小路径可重复覆盖，详解

DAG最小路径点覆盖，最小路径可重复覆盖，详解

文章目录 前言有向无环图的最小路径点覆盖概念拆点二分图定理**证明** 最小路径可重复覆盖解决策略代码实现 OJ练习 前言 关于二分图&#xff1a;二分图及染色法判定 关于二分图最大匹配&#xff1a;二分图最大匹配——匈牙利算法详解 关于二分图带权最大完备匹配&#xff1…
阅读更多...
NFS网络共享服务存储

NFS网络共享服务存储

目录 一、NFS简介 1、NFS定义&#xff1a; 2、NFS的特点 3、NFS的优缺点 4、NFS的原理图示 二、服务端NFS配置文件&#xff1a;/etc/exports 三、实验&#xff1a;NFS共享存储服务配置 1、服务端安装nfs-utils与rpcbind软件包 2、服务端新建共享文件夹目录并赋予权限 …
阅读更多...
前端（html+css+javascript）作业--展现家乡的网页

前端（html+css+javascript）作业--展现家乡的网页

期末期间&#xff0c;老师布置了前端作业&#xff0c;现在放到这里&#xff0c;给各位同志参考。 桂平市是广西壮族自治区的一个美丽的城市&#xff0c;拥有丰富的历史文化和自然景观&#xff0c;属于贵港市管辖&#xff0c;那为什么是看起来是市级而不是县级&#xff0c;其实他…
阅读更多...
HAL库配置RS485通信

HAL库配置RS485通信

在配置好串口的基础上完成RS485的配置 一、使能RS485的发送和接收模式引脚 __HAL_RCC_GPIOG_CLK_ENABLE();//高电平是发送模式&#xff0c;低电平是接收模式&#xff0c;默认是接收模式HAL_GPIO_WritePin(PG4_RS485_DIR1_Port, PG4_RS485_DIR1_Pin, GPIO_PIN_RESET);GPIO_Init…
阅读更多...
Java基础面试题（三）

Java基础面试题（三）

Java基础面试题&#xff08;三&#xff09; 文章目录 Java基础面试题&#xff08;三&#xff09;什么是字节码?采用字节码的好处是什么?为什么说 Java 语言“编译与解释并存”&#xff1f; 文章来自Java Guide 用于学习如有侵权&#xff0c;立即删除 什么是字节码?采用字节码…
阅读更多...
Qt命令行安装：linux（ubuntu）

Qt命令行安装：linux（ubuntu）

起因是我上一篇文章说的&#xff0c;官网下的安装包卡死在第一步安装界面了。 于是我就问GPT有没有纯命令行的安装方式&#xff0c;果然是有的。 在Ubuntu上安装Qt可以使用以下命令&#xff1a; 1. 首先&#xff0c;添加Qt的官方存储库到系统中&#xff1a; sudo add-apt-rep…
阅读更多...
在Ubuntu下载Python3.6 并建立软连接

在Ubuntu下载Python3.6 并建立软连接

打开终端&#xff0c;输入su root,进入root模式 su root为了避免权限问题 安装zlib1g-dev apt-get install zlib1g-dev1.然后创建目录 mkdir -p /usr/local/python32.进入python3目录 cd /usr/local/python33.从官网下载好python3.6.2 wget https://www.python.org/ftp/p…
阅读更多...
Qt QRubberBand 如何实现鼠标框选控件

Qt QRubberBand 如何实现鼠标框选控件

QRubberBand类提供了一个矩形或直线&#xff0c;可以指示选择或边界。常见的模式是结合鼠标事件来执行此操作。本文将使用框选QCheckBox控件&#xff0c;来演示QRubberBand是如何配合鼠标进行工作的。 一、RubberBand 框选效果图 二、RubberBand 代码 rubberband.h #ifndef …
阅读更多...
【ug572】UltraScale体系结构时钟资源手册节选

【ug572】UltraScale体系结构时钟资源手册节选

概述 时钟架构概述 The UltraScale architecture clocking resources manage complex and simple clocking requirements with dedicated global clocks distributed on clock routing and clock distribution resources. The clock management tiles (CMTs) provide clock f…
阅读更多...
经典目标检测YOLO系列(二)YOLOv2算法详解

经典目标检测YOLO系列(二)YOLOv2算法详解

经典目标检测YOLO系列(二)YOLOv2算法详解 YOLO-V1以完全端到端的模式实现达到实时水平的目标检测。但是&#xff0c;YOLO-V1为追求速度而牺牲了部分检测精度&#xff0c;在检测速度广受赞誉的同时&#xff0c;其检测精度也饱受诟病。正是由于这个原因&#xff0c;YOLO团队在20…
阅读更多...
【RT-DETR有效改进】移动设备网络ShuffleNetV1（超轻量化网络主干）

【RT-DETR有效改进】移动设备网络ShuffleNetV1（超轻量化网络主干）

前言 大家好&#xff0c;这里是RT-DETR有效涨点专栏。 本专栏的内容为根据ultralytics版本的RT-DETR进行改进&#xff0c;内容持续更新&#xff0c;每周更新文章数量3-10篇。 专栏以ResNet18、ResNet50为基础修改版本&#xff0c;同时修改内容也支持ResNet32、ResNet101和PP…
阅读更多...
最新文章

Copyright @ 2022~2023