redis分布式锁+自定义注解+锁续期+动态获取锁名称

已于 2023-05-28 22:36:36 修改
阅读量168 收藏
点赞数
文章标签： redis 分布式 java
于 2023-05-16 23:17:19 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/PassionAnytime/article/details/130715871
版权

研究一周终于出成果啦！
注解

package com.it.annotation;

import java.lang.annotation.*;

@Target({ElementType.TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
public @interface JwLock {
    /**
     * 锁的名称
     */
    String lockName() default "jwLock";

    /**
     * 锁的后缀 动态锁名称
     * 适用能直接获取的参数 或者对象属性
     */
    String lockSuffix() default "";

    /**
     * 参数索引位置 第一位0
     */
    int lockIndex() default 0;

    /**
     * 锁的有效时间
     */
    long expireTime() default -1;

}

AOP 动态获取锁名称 也可以固定锁名称

package com.it.config;

import cn.hutool.core.util.StrUtil;
import cn.hutool.json.JSONObject;
import cn.hutool.json.JSONUtil;
import com.it.annotation.JwLock;
import com.it.util.RedisUtil;
import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.lang.reflect.Method;
import java.util.concurrent.TimeUnit;

/**
 * @description: 分布式互斥锁
 */
@Slf4j
@Aspect
@Component
public class JwLockAspect {

    @Autowired
    RedisUtil redisUtil;

    @Pointcut("@annotation(com.it.annotation.JwLock)")
    public void lockPointCut() {
    }

    @Around("lockPointCut()")
    public void around(ProceedingJoinPoint joinPoint) {
        Object[] args = joinPoint.getArgs();
        MethodSignature methodSignature = (MethodSignature) joinPoint.getSignature();
        Method method = methodSignature.getMethod();
        JwLock redisLock = method.getAnnotation(JwLock.class);

        //获取锁名称
        String lockName = redisLock.lockName();
        //获取超时时间
        long expireTime = redisLock.expireTime();
        String lockSuffix = redisLock.lockSuffix();
        int lockIndex = redisLock.lockIndex();

        if (args.length > 0 && StrUtil.isNotBlank(lockSuffix)) {
            if (lockIndex < 0 || lockIndex >= args.length) {
                throw new RuntimeException("lockIndex不能小于0或者大于等于参数个数");
            }
            Object arg = args[lockIndex];
            String suffix;
            //拼接锁后缀
            if (arg instanceof Integer || arg instanceof String || arg instanceof Long) {
                suffix = String.valueOf(arg);
            } else {
                JSONObject jsonObject = JSONUtil.parseObj(JSONUtil.toJsonStr(arg));
                suffix = String.valueOf(jsonObject.get(lockSuffix));
            }
            lockName = lockName + suffix;
        }

        boolean isLock = redisUtil.tryLock(lockName, expireTime);
        try {
            if (isLock) {
                log.info(Thread.currentThread().getName() + ",锁名称" + lockName + "加锁成功，开始执行业务...");
                joinPoint.proceed();
                log.info(Thread.currentThread().getName() + ",锁名称" + lockName + "业务执行完成...");
            } else {
                log.info(Thread.currentThread().getName() + ",锁名称" + lockName + "尝试获取锁失败, 稍后重试!");
                throw new RuntimeException("咦 ,姿势不对 ，手速慢了!");
            }
        } catch (Throwable throwable) {
            log.info(Thread.currentThread().getName() + ",锁名称" + lockName + "加锁失败", throwable);
        } finally {
            //如果该线程还持有该锁，那么释放该锁。如果该线程不持有该锁，说明该线程的锁已到过期时间，自动释放锁
            redisUtil.deleteLock(lockName);
        }
    }
}

package com.it.util;

import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.util.IdUtil;
import cn.hutool.core.util.StrUtil;
import lombok.Data;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.core.script.DefaultRedisScript;
import org.springframework.stereotype.Component;

import java.util.*;
import java.util.concurrent.TimeUnit;

@Slf4j
@Data
@Component
public class RedisUtil {

    @Autowired
    RedisTemplate<String, Object> redisTemplate;

    @Autowired
    StringRedisTemplate stringRedisTemplate;

    ThreadLocal<String> threadLocal = new ThreadLocal<>();
    /**
     * lua 脚本
     */
    public static final String Script = "if redis.call('get', KEYS[1]) == ARGV[1] then return redis.call('del', KEYS[1]) else return 0 end";

    /**
     * 分布式锁 timeout为-1时锁自动续期
     *
     * @param lockName 锁名称
     * @return Boolean
     */
    public Boolean setNx(String lockName) {
        return setNx(lockName, -1L);
    }

    /**
     * 分布式锁 自定义过期时间
     *
     * @param lockName 锁名称
     * @return Boolean
     */
    public Boolean setNx(String lockName, long timeout) {
        String uuid = IdUtil.simpleUUID();
        if (timeout == -1) {
            timeout = 30L;
            Boolean isLock = setNx(lockName, timeout);
            if (isLock) {
                threadLocal.set(uuid);
                //锁续期
                renewExpireTime(lockName, uuid, timeout);
            }
            return isLock;
        } else {
            timeout = timeout <= 0 ? 120 : timeout;
            Boolean isLock = stringRedisTemplate.opsForValue().setIfAbsent(lockName, uuid, timeout, TimeUnit.SECONDS);
            if (Boolean.TRUE.equals(isLock)) {
                threadLocal.set(uuid);
                log.info(Thread.currentThread().getName() + "获取锁{}成功,UUID:{}", lockName, uuid);
            }
            return isLock;
        }
    }

    private void renewExpireTime(String lockName, String uuid, long timeout) {
        //自动续期脚本
        String script = " if redis.call('exists',KEYS[1],ARGV[1]) == 1 then " +
                " return redis.call('expire',KEYS[1],ARGV[2]) " +
                " else" +
                " return 0 " +
                " end ";
        log.info(Thread.currentThread().getName() + "锁名称：{},renewExpireTime.uuid:{}", lockName, uuid);
        new Timer().schedule(new TimerTask() {
            @Override
            public void run() {
                if (Boolean.TRUE.equals(stringRedisTemplate.execute(new DefaultRedisScript<>(script, Boolean.class), Collections.singletonList(lockName), uuid, String.valueOf(timeout)))) {
                    Long expire = stringRedisTemplate.getExpire(lockName, TimeUnit.SECONDS);
                    log.info(Thread.currentThread().getName() + "锁名称：{}续命成功,还有{}秒过期", lockName, expire);
                    renewExpireTime(lockName, uuid, timeout);
                }
                ;
            }
        }, (timeout * 1000) / 3);

    }

    /**
     * 释放分布式锁
     *
     * @param lockName 锁名称
     */
    public void deleteLock(String lockName) {
        String uuid = threadLocal.get();
        if (StrUtil.isNotEmpty(uuid)) {
            log.info(Thread.currentThread().getName() + ",锁名称:{},uuid:{}", lockName, uuid);
            String curLock = stringRedisTemplate.opsForValue().get(lockName);
            if (StrUtil.isNotEmpty(curLock) && uuid.equals(curLock)) {
                redisTemplate.delete(lockName);
                redisTemplate.execute(new DefaultRedisScript<>(Script, Long.TYPE), Collections.singletonList(lockName), uuid);
                threadLocal.remove();
                log.info(Thread.currentThread().getName() + ",锁名称" + lockName + "释放锁成功...");
            }
        }
    }

    /**
     * 分布式锁
     *
     * @param lockName 锁名称
     * @return uuid
     */
    public String setNxStr(String lockName, int timeout) {
        String uuid = UUID.randomUUID().toString().replace("-", "");
        timeout = timeout <= 0 ? 30 : timeout;
        Boolean flag = stringRedisTemplate.opsForValue().setIfAbsent(lockName, uuid, timeout, TimeUnit.SECONDS);
        if (Boolean.TRUE.equals(flag)) {
            log.info(Thread.currentThread().getName() + "获取锁{}成功,UUID:{}", lockName, uuid);
            return uuid;
        }
        return null;
    }

    /**
     * 释放分布式锁
     *
     * @param lockMap 锁名称:uuid
     */
    public void deleteLock(Map<String, Object> lockMap) {
        if (CollUtil.isNotEmpty(lockMap)) {
            lockMap.forEach((key, uuid) -> {
                log.info(Thread.currentThread().getName() + ",锁名称:{},uuid:{}", key, uuid);
                String curLock = stringRedisTemplate.opsForValue().get(key);
                if (StrUtil.isNotEmpty(curLock) && uuid.equals(curLock)) {
                    redisTemplate.delete(key);
                    redisTemplate.execute(new DefaultRedisScript<Long>(Script, Long.TYPE), Collections.singletonList(key), uuid);
                    log.info(Thread.currentThread().getName() + ",锁名称" + key + "释放锁成功...");
                }
            });
        }
    }
}

pom

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <parent>
        <artifactId>item-master</artifactId>
        <groupId>org.example</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>redis-lock</artifactId>

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>
        <dependency>
            <groupId>org.redisson</groupId>
            <artifactId>redisson</artifactId>
            <version>3.19.3</version>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
        </dependency>
        <!-- Redis依赖 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
            <version>3.0.4</version>
        </dependency>

        <dependency>
            <groupId>cn.hutool</groupId>
            <artifactId>hutool-all</artifactId>
        </dependency>
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.9.7</version>
        </dependency>

    </dependencies>

</project>

演示
Controller

@GetMapping("/tryLock2")
    public String tryLock2() {
        boolean isLock = redisUtil.setNx(maoTai,30);
        try {
            if (isLock) {
                log.info(Thread.currentThread().getName() + "获取锁 开始执行");
                Thread.sleep(3000);
                log.info(Thread.currentThread().getName() + "执行结束");
            } else {
                log.info(Thread.currentThread().getName() + "获取锁失败");
                return "fail";
            }
        } catch (InterruptedException e) {
            log.error("获取锁失败" + e.getMessage());
        } finally {
            redisUtil.deleteLock(maoTai);
        }
        return "success";
    }


    @GetMapping("/tryLock3")
    public String tryLock3() {
        log.info(Thread.currentThread().getName() + "来了...");
        testService.tryLock3();
        return "success";
    }

    @PostMapping("/tryLock4")
    public String tryLock4(@RequestBody TaskDTO taskDTO) {
        testService.tryLock4(taskDTO);
        return "success";
    }

    @GetMapping("/tryLock5")
    public String tryLock5() {
        Boolean isLock = redisUtil.tryLock(maoTai, -1);
        try {
            if (isLock) {
                log.info(Thread.currentThread().getName() + "获取锁 开始执行");
                Thread.sleep(25000);
                log.info(Thread.currentThread().getName() + "执行结束");
            } else {
                log.info(Thread.currentThread().getName() + "获取锁失败");
                return "fail";
            }
        } catch (InterruptedException e) {
            log.error(e.getMessage());
        } finally {
            redisUtil.deleteLock(maoTai);
        }
        return "success";
    }

    @GetMapping("/tryLock6")
    public String tryLock6() {
        testService.tryLock6();
        return "success";
    }

service

package com.it.service;

import com.it.annotation.JwLock;
import com.it.annotation.RedisLock;
import com.it.entity.TaskDTO;
import lombok.extern.slf4j.Slf4j;
import org.springframework.context.annotation.EnableAspectJAutoProxy;
import org.springframework.stereotype.Service;

@Slf4j
@Service
public class TestService {

    @RedisLock(lockName = "redis-lock")
    public void tryLock3() {
        log.info(Thread.currentThread().getName() + "获取锁 开始执行");
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            log.info(e.getMessage());
        }
        log.info(Thread.currentThread().getName() + "执行结束");

    }
	/**
	*动态获取锁名称
	*/
    @JwLock(lockName = "JwLock",lockSuffix = "dataPart")
    public void tryLock4(TaskDTO taskDTO) {
        log.info(Thread.currentThread().getName() + "获取锁 开始执行");
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            log.info(e.getMessage());
        }
        log.info(Thread.currentThread().getName() + "执行结束");
    }

    @JwLock(lockName = "JwLock")
    public void tryLock6() {
        try {
            Thread.sleep(35000);
        } catch (InterruptedException e) {
            log.info(e.getMessage());
        }
    }
}


package com.it.entity;

import lombok.Data;

@Data
public class TaskDTO {
    String taskId;
    Integer dataPart;
}

用jmeter测试 5个线程同时调用/tryLock4
{
“taskId”:“1”,
“dataPart”:“20230501”
}

动态获取锁名称演示
在这里插入图片描述

用jmeter测试 5个线程同时调用/tryLock6
锁续命演示
在这里插入图片描述
橘右今
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
java面试题Redis分布式锁+zk 分布式锁.md
09-15
java面试题Redis分布式锁+zk 分布式锁.md
Redis分布式锁使用+Redis处理数据并发+springboot整合Redis
03-22
springboot整合Redis实现在分布式情况，使用分布式锁解决数据并发的方案，主要使用Redis提供的setIfAbsent方法实现，并且考虑到了setIfAbsent在极端情况下的多实例同时设置一个key成功的情况。 本案例通过实现对库存...
Redis分布式锁的实现原理
qq_38990795的博客
10-16 245
一、Redisson实现Redis分布式锁的底层原理 (1)加锁机制 现在某个客户端要加锁,如果该客户端面对的是一个redis cluster集群,首先会根据hash节点选择一台机器(仅仅只是选择一台机器). 紧接着会发送一段lua脚本到redis上,lua脚本如下: 为什么要用lua脚本呢:因为一大坨复杂的业务逻辑,可以通过封装在lua脚本中发送给redis,保证这段复杂业务逻辑...
Redis分布式锁如何续期
JavaBoy的博客
06-26 8606
Redis分布式锁的正确姿势 据肥朝了解,很多同学在用分布式锁时,都是直接百度搜索找一个Redis分布式锁工具类就直接用了.关键是该工具类中还充斥着很多System.out.println();等语句.其实Redis分布式锁比较正确的姿势是采用redisson这个客户端工具.具体介绍可以搜索最大的同性交友网站github. 如何回答 首先如果你之前用Redis的分布式锁的姿势正确,并且看过相应的官...
Redis第14讲——Redis实现分布式锁（Redission源码解析）
最新发布
让~学习~成为一种习惯（橡 皮 人の技术博客）
04-25 1195
在多线程环境下，为了保证数据的线程安全，我们通常用加锁的方式，使同一时刻只有一个线程可以对这个共享资源进行操作，在单服务系统我们常用JVM锁——Synchronized、ReentrantLock等。然而在多台服务系统的情况下，JVM锁就无法在多个服务器之间生效了，这时候我们就需要用分布式锁来解决线程安全的问题。分布式锁的实现方式有很多，主流的就是基于数据库、zookeeper以及redis，当然使用redis的居多，由于篇幅原因，本节就详细介绍一下使用redis实现分布式锁的几种方式。
Redis分布式锁的原理以及如何续期
weixin_44026997的博客
09-27 961
Question: Redis锁的过期时间小于业务的执行时间该如何续期？ Answer: 只要客户端一旦加锁成功，就会启动一个watch dog看门狗，他是一个后台线程，会每隔10秒检查一下，如果客户端还持有锁key，那么就会不断的延长锁key的生存时间。 默认情况下,加锁的时间是30秒,.如果加锁的业务没有执行完,那么到 30-10 = 20秒的时候,就会进行一次续期,把锁重置成30秒.那这个时候可能又有同学问了,那业务的机器万一宕机了呢?宕机了定时任务跑不了,就续不了期,那自然30秒之后锁就解开了呗.
redis锁
weixin_38110854的博客
03-14 214
3.注意：业务中断或者抛出异常，删除redis锁；(按照1、2方式，不会造成死锁，但是压测的时候会产生大量的锁，占用内存空间)2.锁的value为：时间戳，防止死锁。每次获取锁的时候，取出锁内时间，计算时间间隔，时间间隔超过限定，返回新锁;1.申请获取锁，并为锁设置过期时间；
实现分布式锁都有哪些方式？
KobeHoo的博客
10-14 238
正在上传…重新上传取消 面试题 一般实现分布式锁都有哪些方式？ 使用 redis 如何设计分布式锁？ 使用 zk 来设计分布式锁可以吗？ 这两种分布式锁的实现方式哪种效率比较高？ 面试官心理分析 其实一般问问题，都是这么问的，先问问你 zk，然后其实是要过度到 zk 关联的一些问题里去，比如分布式锁。因为在分布式系统开发中，分布式锁的使用场景还是很常见的...
golang实现Redis分布式自旋锁+本地自旋锁
01-20
golang使用redis的setnx实现了一个自选锁，有key超时，同时也有我们调用redis链接时的超时。 package locker import ( context github.com/go-redis/redis runtime time ) type Lock struct { resource string...
Redis实现分布式锁(附源码+讲义)
07-01
分布式锁有很多种解决方案，今天我们要讲的是怎么使用缓存数据库Redis来实现分布式锁。 课程目标:  理解redis分布式锁的应用场景  掌握redis分布式锁的实现原理  掌握redis分布式锁在微服务项目中的应用  掌握...
Redis分布式锁的实现方式(redis面试题)
09-08
分布式锁是一种在分布式系统中实现锁的机制，用于协调分布在不同节点上的进程对共享资源的访问。在单机系统中，我们通常使用线程锁（如Java中的`synchronized`关键字或`java.util.concurrent.locks.Lock`接口）来...
关于分布式锁的续命问题——基于Redis实现的分布式锁
weixin_39555954的博客
06-10 3081
如果在分布式锁中，业务代码没有执行完，然后锁的键值过期了会发生什么呢？本文记录了模拟秒杀系统来实现的分布式锁过期的问题。。。。。。
Redis实现分布式锁的六种方式。最佳实践：原子性获取锁+LUA脚本释放锁
weixin_43989347的博客
06-19 1915
redis实现分布式锁
Redis锁
weixin_52683740的博客
04-10 827
关于Redis锁
基于redis实现分布式锁（二）根据资源动态生成锁名称
阿鹏的博客
07-26 397
前言 上次写了一篇实现分布式redis锁的文章，见《AOP+自定义注解实现Redis分布式锁》，是在防止定时任务并行启动场景的时候用的。 最近业务上又遇到了个新场景，要求：不允许对资源进行并行发布的操作。如此，上次封装的reids锁已经不能满足需求了，主要是，锁的key必须要使用资源id。例如场景：要对某个班级的所有学生手动推送通知，在这个推送通知的过程中，不允许其他人同时对这个班级的学生进行推送通知操作。所以根据班级 id 拼接成分布式锁 key 。 按照之前的代码，锁是可以实现的，但是在 aop 的时候
自定义Redis分布式锁(续期,指定抢锁时间)
m0_48767062的博客
01-14 921
假如说目前有这样一个场景,多个客户同时去下单抢购同一件商品,为了出现防止商品超卖的情况,常规的做法是会进行上锁,锁住这个库存,同一时刻只能有一个扣减库存的操作,防止出现超卖的现象。 在只有一个服务实例的情况下可以使用synchronized来进行上锁控制多线程的并发。但是由于目前大部分的项目都是分布式开发的,所以很多服务会部署多个节点进行抗压保证服务的可靠性,所以synchronized的话就无法保证多个jvm之间的并发操作。此时我们就需要借助第三方工具将原本多个服务之间的
基于redis锁的实现
u014477164的博客
12-02 334
实现redis锁基于以下两个条件： 第一： 从2.6.12版本开始，redis为SET命令增加了一系列选项: EX seconds – Set the specified expire time, in seconds.PX milliseconds – Set the specified expire time, in milliseconds.NX – Only set
04-redis分布式锁实战
zengqingfa123的博客
10-23 572
redis分布式锁实战
redis实现分布式锁
大海技术博客
07-11 1072
慢慢总接慢慢更新对于分布式场景，我们可以使用分布式锁，它是控制分布式系统之间互斥访问共享资源的一种方式分布式锁一般有如下的特点：我们一般实现分布式锁有以下几种方式：Redis的SETNX命令，setnx key value，将key设置为value，当键不存在时，才能成功，若键存在，什么也不做，成功返回1，失败返回0 。 SETNX实际上就是SET IF NOT Exists的缩写因为分布式锁还需要超时机制，所以我们利用expire命令来设置，所以利用setnx+expire命令的核心代码如下： 实际上
redis分布式锁+lua脚本代码实现
07-25
下面是一个使用Lua脚本实现Redis分布式锁的代码示例： ```lua -- Lua脚本实现Redis分布式锁 local lockKey = 'lock' local uuid = ARGV\[1\] if redis.call('get', lockKey) == uuid then redis.call('del', lockKey) return 1 else return 0 end ``` 这段代码首先定义了一个锁的键名为`lockKey`，然后通过传入的参数`ARGV\[1\]`获取到要删除的锁的UUID。接下来，它会通过`redis.call('get', lockKey)`来获取当前锁的值，如果与传入的UUID相等，则说明当前锁是由该UUID持有的，此时会使用`redis.call('del', lockKey)`来删除锁，并返回1表示删除成功。如果锁的值与传入的UUID不相等，则说明当前锁不是由该UUID持有的，此时直接返回0表示删除失败。 这段代码可以用于实现Redis分布式锁的原子性删除操作，确保只有持有锁的客户端才能删除锁，避免误删锁的问题。同时，使用Lua脚本可以保证删除锁的操作是原子性的，避免并发情况下的竞争问题。 #### 引用[.reference_title] - *1* *2* [Redis 实现分布式锁+执行lua脚本](https://blog.csdn.net/qq_34285557/article/details/129700808)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v91^control_2,239^v3^insert_chatgpt"}} ] [.reference_item] - *3* [Redis的分布式锁问题（九）Redis + Lua 脚本实现分布式锁](https://blog.csdn.net/weixin_43715214/article/details/127982757)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v91^control_2,239^v3^insert_chatgpt"}} ] [.reference_item] [ .reference_list ]

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

橘右今

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值