秒杀优化+秒杀安全

news2024/11/17 23:56:25

1.Redis预减库存

1.OrderServiceImpl.java 问题分析

image-20240513102548010

2.具体实现 SeckillController.java
1.实现InitializingBean接口的afterPropertiesSet方法，在bean初始化之后将库存信息加载到Redis
    /**
     * 系统初始化，将秒杀商品库存加载到redis中
     *
     * @throws Exception
     */
    @Override
    public void afterPropertiesSet() throws Exception {
        // 将秒杀商品库存加载到redis中
        List<GoodsVo> goodsVoList = goodsService.findGoodsVo();
        // 如果没有秒杀商品，直接返回
        if (CollectionUtils.isEmpty(goodsVoList)) {
            return;
        }
        goodsVoList.forEach(goodsVo -> {
            redisTemplate.opsForValue().set("seckillGoods:" + goodsVo.getId(), goodsVo.getStockCount());
        });
    }
2.进行库存预减
        // 库存预减
        Long stock = redisTemplate.opsForValue().decrement("seckillGoods:" + goodsId);
        // 判断库存是否充足
        if (stock < 0) {
            // 库存不足，返回秒杀失败页面
            redisTemplate.opsForValue().increment("seckillGoods:" + goodsId);
            model.addAttribute("errmsg", RespBeanEnum.EMPTY_STOCK.getMessage());
            return "secKillFail";
        }
3.优化分析
  • 正常情况下，每次都需要到数据库减少库存，来解决超卖问题
  • 使用Redis进行库存预减，可以减少对数据库的操作，从而提升效率
4.测试
1.清空Redis

image-20240513111015701

2.清空订单表和秒杀商品表，设置一号商品库存为10

image-20240513111216371

3.将项目部署上线
4.UserUtil.java生成100个用户

image-20240513111713541

5.发送5000次请求
1.线程组配置

image-20240513111955965

2.cookie管理器

image-20240513112038442

3.秒杀请求

image-20240513112155873

4.QPS为307，从80提升到了307提升了283%

image-20240513112324226

5.但是，出现了库存遗留问题

image-20240513113053268

5.缓存遗留原因分析

image-20240513120739584

2.内存标记优化高并发

1.问题分析
  • 在未使用内存标记时，每次请求都需要对库存进行预减，来判断是否有库存，即使库存为0
  • 所以采用内存标记的方式，当库存为0的时候，就不用进行库存预减
2.具体实现 SeckillController.java
1.首先定义一个标记是否有库存的map

image-20240513133912046

2.在系统初始化时，初始化map

image-20240513134008613

3.如果库存预减发现没有库存了，就设置内存标记

image-20240513134102161

4.在库存预减前，判断内存标记，减少redis访问

image-20240513134121258

3.测试
1.将项目上线
2.清空订单表和秒杀商品表，设置一号商品库存为10
3.清空Redis
4.发送5000次请求，QPS为330，从307提高到了330

image-20240513135337854

3.消息队列实现异步秒杀

1.问题分析

image-20240513140733314

2.思路分析

image-20240513140723821

image-20240513141159400

3.构建秒杀消息对象 SeckillMessage.java
package com.sxs.seckill.pojo;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

/**
 * Description: 秒杀消息
 *
 * @Author sun
 * @Create 2024/5/13 14:15
 * @Version 1.0
 */
@Data
@NoArgsConstructor
@AllArgsConstructor
public class SeckillMessage {
    private User user;
    private Long goodsId;
}
4.秒杀RabbitMQ配置
package com.sxs.seckill.config;

import org.springframework.amqp.core.Binding;
import org.springframework.amqp.core.BindingBuilder;
import org.springframework.amqp.core.Queue;
import org.springframework.amqp.core.TopicExchange;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * Description: 秒杀RabbitMQ配置
 *
 * @Author sun
 * @Create 2024/5/13 14:23
 * @Version 1.0
 */
@Configuration
public class RabbitMQSeckillConfig {
    // 定义一个消息队列和一个topic交换机的名字
    public static final String SECKILL_QUEUE = "seckillQueue";
    public static final String SECKILL_EXCHANGE = "seckillExchange";

    // 创建一个消息队列
    @Bean
    public Queue seckillQueue() {
        return new Queue(SECKILL_QUEUE, true);
    }

    // 创建一个topic交换机
    @Bean
    public TopicExchange seckillExchange() {
        return new TopicExchange(SECKILL_EXCHANGE);
    }

    // 将消息队列绑定到交换机
    @Bean
    public Binding binding() {
        // 绑定消息队列到交换机，并指定routingKey，表示只接收routingKey为seckill.#的消息
        return BindingBuilder.bind(seckillQueue()).to(seckillExchange()).with("seckill.#");
    }
}
5.生产者和消费者
1.生产者 MQSendMessage.java
package com.sxs.seckill.rabbitmq;

import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;

/**
 * Description: 消息队列发送消息
 *
 * @Author sun
 * @Create 2024/5/13 15:14
 * @Version 1.0
 */
@Service
@Slf4j
public class MQSendMessage {
    @Resource
    private RabbitTemplate rabbitTemplate;

    // 发送秒杀消息
    public void sendSeckillMessage(String message) {
        log.info("发送消息：" + message);
        rabbitTemplate.convertAndSend("seckillExchange", "seckill.message", message);
    }
}
2.消费者，进行秒杀
1.引入hutool工具类
        <dependency>
            <groupId>cn.hutool</groupId>
            <artifactId>hutool-all</artifactId>
            <version>5.3.3</version>
        </dependency>
2. MQReceiverMessage.java
package com.sxs.seckill.rabbitmq;

import cn.hutool.json.JSONUtil;
import com.sxs.seckill.pojo.SeckillMessage;
import com.sxs.seckill.pojo.User;
import com.sxs.seckill.service.GoodsService;
import com.sxs.seckill.service.OrderService;
import com.sxs.seckill.service.SeckillGoodsService;
import com.sxs.seckill.vo.GoodsVo;
import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;

/**
 * Description: 消息队列接收消息
 *
 * @Author sun
 * @Create 2024/5/13 15:17
 * @Version 1.0
 */
@Service
@Slf4j
public class MQReceiverMessage {
    @Resource
    private GoodsService goodsService;
    @Resource
    private OrderService orderService;

    // 接收秒杀消息
    @RabbitListener(queues = "seckillQueue")
    public void receiveSeckillMessage(String message) {
        log.info("接收消息：" + message);
        // 此时的message是秒杀的消息，要将其转换为SeckillMessage对象
        SeckillMessage seckillMessage = JSONUtil.toBean(message, SeckillMessage.class);
        // 获取秒杀信息
        User user = seckillMessage.getUser();
        Long goodsId = seckillMessage.getGoodsId();
        // 根据商品id查询商品详情
        GoodsVo goodsVoByGoodsId = goodsService.findGoodsVoByGoodsId(goodsId);
        // 进行秒杀
        orderService.seckill(user, goodsVoByGoodsId);
    }
}
6.编写控制层
1.SeckillController.java

image-20240513154029078

        // MQ实现异步秒杀
        // 封装秒杀信息
        SeckillMessage seckillMessage = new SeckillMessage(user, goodsId);
        // 使用hutool工具类将SeckillMessage对象转换为json字符串并发送
        mqSendMessage.sendSeckillMessage(JSONUtil.toJsonStr(seckillMessage));
        // 返回排队中页面
        model.addAttribute("errmsg", RespBeanEnum.QUEUE_ERROR.getMessage());
        return "secKillFail";
2.RespBeanEnum.java 新增响应枚举类

image-20240513154055007

7.测试
1.将项目上线
2.清空订单表和秒杀商品表，设置一号商品库存为10
3.清空Redis
4.发送5000次请求，QPS为363

image-20240513161847459

秒杀安全

1.秒杀接口隐藏

1.需求分析

image-20240514103812853

2.思路分析

image-20240514104439584

3.具体实现
1.RespBeanEnum.java 新增几个响应
2.OrderService.java 新增方法
    /**
     * 方法：生成秒杀路径
     * @param user
     * @param goodsId
     * @return
     */
    String createPath(User user, Long goodsId);

    /**
     * 方法：校验秒杀路径
     * @param user
     * @param goodsId
     * @param path
     * @return
     */
    boolean checkPath(User user, Long goodsId, String path);
3.OrderServiceImpl.java
    @Override
    public String createPath(User user, Long goodsId) {
        // 对参数进行校验
        if (user == null || goodsId <= 0) {
            return null;
        }
        // 生成秒杀路径
        String path = MD5Util.md5(UUIDUtil.uuid() + "123456");
        // 保存到redis中，设置过期时间为60秒
        redisTemplate.opsForValue().set("seckillPath:" + user.getId() + ":" + goodsId, path, 60, TimeUnit.SECONDS);
        return path;
    }

    @Override
    public boolean checkPath(User user, Long goodsId, String path) {
        // 对参数进行校验
        if (user == null || goodsId <= 0 || StringUtils.isBlank(path)) {
            return false;
        }
        // 从redis中获取秒杀路径
        String redisPath = (String) redisTemplate.opsForValue().get("seckillPath:" + user.getId() + ":" + goodsId);
        // 判断是否相等，并返回
        return path.equals(redisPath);
    }
4.SeckillController.java
    @RequestMapping("/{path}/doSeckill")
    public RespBean doSeckill(Model model, User user, Long goodsId, @PathVariable String path) {
        // 判断用户是否登录
        if (user == null) {
            return RespBean.error(RespBeanEnum.SESSION_ERROR);
        }
        // 校验path
        boolean check = orderService.checkPath(user, goodsId, path);
        if (!check) {
            return RespBean.error(RespBeanEnum.REQUEST_ILLEGAL);
        }
        // 根据goodsId获取GoodsVo
        GoodsVo goodsVoByGoodsId = goodsService.findGoodsVoByGoodsId(goodsId);
        // 判断是否有库存
        if (goodsVoByGoodsId.getStockCount() < 1) {
            return RespBean.error(RespBeanEnum.EMPTY_STOCK);
        }
        // 从redis中判断是否复购
        if (redisTemplate.hasKey("order:" + user.getId() + ":" + goodsId)) {
            return RespBean.error(RespBeanEnum.REPEATE_ERROR);
        }
        // 首先判断内存标记
        if (inventoryTagging.get(goodsId)) {
            return RespBean.error(RespBeanEnum.EMPTY_STOCK);
        }
        // 库存预减
        Long stock = redisTemplate.opsForValue().decrement("seckillGoods:" + goodsId);
        // 判断库存是否充足
        if (stock < 0) {
            // 标记库存不足
            inventoryTagging.put(goodsId, true);
            // 库存不足，返回秒杀失败页面
            redisTemplate.opsForValue().increment("seckillGoods:" + goodsId);
            return RespBean.error(RespBeanEnum.EMPTY_STOCK);
        }

        // MQ实现异步秒杀
        // 封装秒杀信息
        SeckillMessage seckillMessage = new SeckillMessage(user, goodsId);
        // 使用hutool工具类将SeckillMessage对象转换为json字符串并发送
        mqSendMessage.sendSeckillMessage(JSONUtil.toJsonStr(seckillMessage));
        // 返回排队中
        return RespBean.success(RespBeanEnum.SEK_KILL_WAIT);
    }

    /**
     * 生成秒杀地址
     * @param user
     * @param goodsId
     * @return
     */
    @ResponseBody
    @RequestMapping("/path")
    public RespBean getPath(User user, Long goodsId) {
        // 参数校验
        if (user == null || goodsId <= 0) {
            return RespBean.error(RespBeanEnum.REQUEST_ILLEGAL);
        }
        // 调用OrderService中的createPath方法生成秒杀地址
        String path = orderService.createPath(user, goodsId);
        return RespBean.success(path);
    }
5.goodsDetail.html
1.秒杀首先获取路径

image-20240514132039228

2.解析环境变量，区分多环境

image-20240514120006961

3.新增两个方法，使用隐藏秒杀接口的方式秒杀商品

4.测试

image-20240514133435103

image-20240514133441653

2.验证码防止脚本攻击

1.思路分析

image-20240514134151357

2.具体实现
1.pom.xml 引入依赖
        <dependency>
            <groupId>com.ramostear</groupId>
            <artifactId>Happy-Captcha</artifactId>
            <version>1.0.1</version>
        </dependency>
2.SeckillController.java 编写方法生成验证码
    /**
     * 生成验证码
     * @param user
     * @param goodsId
     * @param request
     * @param response
     */
	@RequestMapping("/captcha")
    public void happyCaptcha(User user, Long goodsId, HttpServletRequest request, HttpServletResponse response) {
        HappyCaptcha.require(request, response)
                .style(CaptchaStyle.ANIM) //设置展现样式为动画
                .type(CaptchaType.NUMBER) //设置验证码内容为数字
                .length(6) //设置字符长度为 6
                .width(220) //设置动画宽度为 220
                .height(80) //设置动画高度为 80
                .font(Fonts.getInstance().zhFont()) //设置汉字的字体
                .build().finish(); //生成并输出验证码

        // 这个验证码的结果会存储在session中，可以通过request.getSession().getAttribute("happy-captcha")获取
        // 获取验证码的值，放入redis中
        String verifyCode = request.getSession().getAttribute("happy-captcha").toString();
        redisTemplate.opsForValue().set("captcha:" + user.getId() + ":" + goodsId, verifyCode, 60, TimeUnit.SECONDS);
    }
3.OrderService.java 校验用户输入的验证码
    /**
     * 校验用户输入的验证码
     * @param user
     * @param goodsId
     * @param captcha
     * @return
     */
    boolean checkCaptcha(User user, Long goodsId, String captcha);
4.OrderServiceImpl.java
    @Override
    public boolean checkCaptcha(User user, Long goodsId, String captcha) {
        // 参数校验
        if (user == null || goodsId <= 0 || StringUtils.isBlank(captcha)) {
            return false;
        }
        // 从redis中获取验证码
        String verifyCode = (String) redisTemplate.opsForValue().get("captcha:" + user.getId() + ":" + goodsId);
        return captcha.equals(verifyCode);
    }
5.SeckillController.java 加入验证码校验
6.goodsDetail.html
1.前端请求验证码
2.测试

image-20240514142410612

3.获取用户输入的验证码，并携带验证码

image-20240514142750293

image-20240514143247969

3.秒杀接口限流-防刷

1.思路分析

image-20240514144320230

2.简单接口限流
1.SeckillController.java

image-20240514151732430

2.测试

image-20240514151841132

4.通用接口限流防刷

1.思路分析

image-20240514153042300

2.编写自定义限流注解 AccessLimit.java
package com.sxs.seckill.config;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * Description: 限流注解
 *
 * @Author sun
 * @Create 2024/5/14 15:38
 * @Version 1.0
 */
@Retention(RetentionPolicy.RUNTIME) // 运行时生效
@Target(ElementType.METHOD) // 作用在方法上
public @interface AccessLimit {
    int seconds(); // 时间范围
    int maxCount(); // 最大访问次数
    boolean needLogin() default true; // 是否需要登录
}
3.使用方式 SeckillController.java

image-20240514154353081

4.编写 config/UserContext.java 使用ThreadLocal存储user
package com.sxs.seckill.config;

import com.sxs.seckill.pojo.User;

/**
 * Description:
 *
 * @Author sun
 * @Create 2024/5/14 15:46
 * @Version 1.0
 */
public class UserContext {
    // 初始化ThreadLocal以存储用户信息
    private static ThreadLocal<User> threadLocal = new ThreadLocal<>();

    public static User getUser() {
        return threadLocal.get();
    }

    public static void setUser(User user) {
        threadLocal.set(user);
    }

    // 清除ThreadLocal中的数据
    public static void removeUser() {
        threadLocal.remove();
    }
}
5.编写自定义限流拦截器 config/AccessLimitInterceptor.java
package com.sxs.seckill.config;

import com.sxs.seckill.exception.GlobalException;
import com.sxs.seckill.pojo.User;
import com.sxs.seckill.service.UserService;
import com.sxs.seckill.utils.CookieUtil;
import com.sxs.seckill.vo.RespBeanEnum;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;
import org.springframework.web.method.HandlerMethod;
import org.springframework.web.servlet.HandlerInterceptor;

import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.util.concurrent.TimeUnit;

/**
 * Description: 限流拦截器
 *
 * @Author sun
 * @Create 2024/5/14 15:55
 * @Version 1.0
 */
@Component
public class AccessLimitInterceptor implements HandlerInterceptor {
    @Resource
    private UserService userService;
    @Resource
    RedisTemplate redisTemplate;

    /**
     * 拦截请求，进行限流处理，在目标方法前执行
     *
     * @param request
     * @param response
     * @param handler
     * @return
     * @throws Exception
     */
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        if (handler instanceof HandlerMethod) {
            // 如果是方法级别的拦截
            // 1.获取user对象，放到threadLocal中
            User user = getUser(request, response);
            UserContext.setUser(user);
            // 2.处理限流注解
            HandlerMethod handlerMethod = (HandlerMethod) handler;
            AccessLimit accessLimit = handlerMethod.getMethodAnnotation(AccessLimit.class);
            if (accessLimit == null) {
                return true;
            }
            // 3.获取注解上的参数
            int seconds = accessLimit.seconds();
            int maxCount = accessLimit.maxCount();
            boolean needLogin = accessLimit.needLogin();
            String key = request.getRequestURI();
            if (needLogin) {
                // 如果需要登录，但是没有登录，返回错误信息
                if (user == null) {
                    // 如果需要登录，但是没有登录，返回错误信息
                    throw new GlobalException(RespBeanEnum.USER_NOT_LOGIN);
                }
                // 如果登录了，key加上用户id
                key += ":" + user.getId();
            }
            // 4.对访问次数进行限制，如果登陆了就是对这个用户的访问次数进行限制，如果没有登录就是对这个接口的访问次数进行限制
            Integer count = (Integer) redisTemplate.opsForValue().get(key);
            if (count == null) {
                // 第一次访问
                redisTemplate.opsForValue().set(key, 1, seconds, TimeUnit.SECONDS);
            } else if (count < maxCount) {
                // 访问次数加1
                redisTemplate.opsForValue().increment(key);
            } else {
                // 超过访问次数
                throw new GlobalException(RespBeanEnum.ACCESS_LIMIT_REACHED);
            }
        }
        // 如果不是方法级别的拦截，直接放行
        return true;
    }

    // 单独编写方法，获取User对象
    private User getUser(HttpServletRequest request, HttpServletResponse response) {
        String ticket = CookieUtil.getCookieValue(request, "userTicket");
        if (ticket == null) {
            return null;
        }
        return userService.getUserByCookie(ticket, request, response);
    }
}
6.config/WebConfig.java中注册拦截器

image-20240514165547226

7.修改自定义参数解析器UserArgumentResolver.java，直接从ThreadLocal中获取User

image-20240514165815611

8.测试

image-20240514170313513

9.解决库存遗留问题，为每个用户id加锁即可

image-20240515084923122

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

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

相关文章

深入解析智慧互联网医院系统源码：医院小程序开发的架构到实现

深入解析智慧互联网医院系统源码：医院小程序开发的架构到实现

本篇文章&#xff0c;小编将深入解析智慧互联网医院系统的源码&#xff0c;重点探讨医院小程序开发的架构和实现&#xff0c;旨在为相关开发人员提供指导和参考。 一、架构设计 智慧互联网医院系统的架构设计是整个开发过程的核心&#xff0c;直接影响到系统的性能、扩展性和维…
阅读更多...
Vue3 【实战】封装 useLocation

Vue3 【实战】封装 useLocation

技术要点 通过 Vue3 的组合式API 仿写 react 中的 hook 代码实现 封装 hooks/useLocation.js import { reactive, onMounted, toRefs } from vue// 模拟异步获取 function getLocation(fail) {return new Promise((resolve) > {setTimeout(() > {if (fail) {// 模拟失败…
阅读更多...
计算机网络学习记录 网络层 Day4（下）

计算机网络学习记录 网络层 Day4（下）

计算机网络学习记录 网络层 Day4 &#xff08;下&#xff09; 你好,我是Qiuner. 为记录自己编程学习过程和帮助别人少走弯路而写博客 这是我的 github https://github.com/Qiuner ⭐️ ​ gitee https://gitee.com/Qiuner &#x1f339; 如果本篇文章帮到了你 不妨点个赞吧~ 我…
阅读更多...
（深度学习记录）第TR4周：Pytorch复现Transformer

（深度学习记录）第TR4周：Pytorch复现Transformer

&#x1f368; 本文为&#x1f517;365天深度学习训练营 中的学习记录博客&#x1f356; 原作者&#xff1a;K同学啊 | 接辅导、项目定制 &#x1f3e1;我的环境&#xff1a; 语言环境&#xff1a;Python3.11.4编译器&#xff1a;Jupyter Notebooktorcch版本&#xff1a;2.0.…
阅读更多...
聊聊DoIP吧(二）-报文结构和时间参数

聊聊DoIP吧(二）-报文结构和时间参数

书接上回&#xff0c;DoIP报文及其在以太网帧中的位置&#xff1a;图片来自Vector官网 这里我们来看看DoIP报文结构&#xff1a; DoIP协议时间参数详解 - 知乎 (zhihu.com)
阅读更多...
MySQL 高级 - 第十一章 | 索引优化与查询优化

MySQL 高级 - 第十一章 | 索引优化与查询优化

目录 第十一章 索引优化与查询优化11.1 数据准备11.2 索引失效案例11.2.1 全值匹配10.2.2 最佳左前缀法则10.2.3 主键插入顺序10.2.4 计算、函数、类型转换&#xff08;自动或手动&#xff09;导致索引失效10.2.5 范围条件右边的列索引失效10.2.6 不等于&#xff08;! 或者 <…
阅读更多...
算法-分治策略

算法-分治策略

概念 分治算法&#xff08;Divide and Conquer&#xff09;是一种解决问题的策略&#xff0c;它将一个问题分解成若干个规模较小的相同问题&#xff0c;然后递归地解决这些子问题&#xff0c;最后合并子问题的解得到原问题的解。分治算法的基本思想是将复杂问题分解成若干个较…
阅读更多...
一文读懂AI时代GPU的内存新宠-HBM

一文读懂AI时代GPU的内存新宠-HBM

一文读懂GPU最强辅助&#xff1a;HBM HBM&#xff0c;即高带宽内存&#xff0c;是一项领先的3D堆叠DRAM技术&#xff0c;专为高性能计算和图形处理单元&#xff08;GPU&#xff09;设计&#xff0c;满足其对内存带宽和容量的极致需求。该技术由AMD与海力士携手研发&#xff0c;…
阅读更多...
eclipse连接后端mysql数据库并且查询

eclipse连接后端mysql数据库并且查询

教学视频&#xff1a;https://www.bilibili.com/video/BV1mK4y157kE/?spm_id_from333.337.search-card.all.click&vd_source26e80390f500a7ceea611e29c7bcea38本人eclipse和up主不同的地方如下&#xff0c;右键项目名称->build path->configure build path->Libr…
阅读更多...
EasyExcel导出多个sheet封装

EasyExcel导出多个sheet封装

导出多个sheet 在需求中&#xff0c;会有需要导出多种sheet的情况&#xff0c;那么这里使用easyexcel进行整合 步骤 1、导入依赖 <dependency><groupId>org.projectlombok</groupId><artifactId>lombok</artifactId></dependency><d…
阅读更多...
IO进程线程（十）进程间通信 消息队列 共享内存 信号灯集

IO进程线程（十）进程间通信 消息队列 共享内存 信号灯集

文章目录 一、IPC(Inter-Process Communication)进程间通信相关命令 &#xff1a;&#xff08;一&#xff09;ipcs --- 查看IPC对象&#xff08;二&#xff09;获取IPC键值&#xff08;三&#xff09;删除IPC对象的命令&#xff08;四&#xff09;获取IPC键值的函数1. 函数定义…
阅读更多...
CorelDRAW2024最新版本有哪些功能？揭秘设计界最新神器！

CorelDRAW2024最新版本有哪些功能？揭秘设计界最新神器！

“设计”一词最早来源于拉丁语“designare”&#xff0c;意为计划&#xff0c;构思。随着时代的发展&#xff0c;人们将“设计”理解为一种创造性活动&#xff0c;通过这种活动&#xff0c;人们可以创造出新的产品、新的场景以及新的体验。 「CorelDRAW汉化版下载」&#xff0c…
阅读更多...
讯方618代表有话说 | 行业大咖详解鸿蒙，全程在线答疑

讯方618代表有话说 | 行业大咖详解鸿蒙，全程在线答疑

讯方618“代表有话说” 系列专场直播活动来啦 6月11日&#xff08;周二&#xff09;19:30 本期直播特邀华为、学校、讯方代表 与大家畅聊鸿蒙奥秘 共同开启未来技术之门&#xff01; 行业大咖将带大家 了解鸿蒙概况和岗位需求 解析鸿蒙系统强势崛起带来的影响 解读高校…
阅读更多...
Netty中的ByteBuf使用介绍

Netty中的ByteBuf使用介绍

ByteBuf有三类&#xff1a; 堆缓存区&#xff1a;JVM堆内存分配直接缓冲区&#xff1a;有计算机内存分配&#xff0c;JVM只是保留分配内存的地址信息&#xff0c;相对于堆内存方式较为昂贵&#xff1b;复合缓冲区&#xff1a;复合缓冲区CompositeByteBuf&#xff0c;它为多个B…
阅读更多...
【算法专题--栈】最小栈--高频面试题（图文详解，小白一看就会！！）

【算法专题--栈】最小栈--高频面试题（图文详解，小白一看就会！！）

目录 一、前言 二、题目描述 三、解题方法 ⭐解题方法--1 ⭐解题方法--2 四、总结 五、共勉 一、前言 最小栈这道题&#xff0c;可以说是--栈专题--&#xff0c;比较经典的一道题&#xff0c;也是在面试中频率较高的一道题目&#xff0c;通常在面试中&#xff0c;面试官可…
阅读更多...
python - DataFrame查询数据操作

python - DataFrame查询数据操作

学习目标 掌握获取df一列或多列数据的方法 知道loc和iloc的区别以及使用方法 知道df的query函数的使用方法 知道isin函数的作用和使用方法 获取DataFrame子集的基本方法 1.1 从前从后获取多行数据 案例中用到的数据集在文章顶部 LJdata.csv 前景回顾 head() & tail(…
阅读更多...
西门子PLC学习之数据块的单个实例，多重实例与参数实例间的区别

西门子PLC学习之数据块的单个实例，多重实例与参数实例间的区别

首先介绍下函数&#xff0c;函数块与数据块这三个概念。 数据块 数据块里可以存储各种类型的参数。有人可能会问&#xff0c;m寄存器不是可以存储布尔值&#xff0c;8位&#xff0c;16位&#xff0c;32位变量吗&#xff0c;为什么要多此一举&#xff1f;因为虽然m寄存器能存储以…
阅读更多...
超详细的java Comparable，Comparator接口解析

超详细的java Comparable，Comparator接口解析

前言 Hello大家好呀&#xff0c;在java中我们常常涉及到对象的比较&#xff0c;不同于基本数据类型&#xff0c;对于我们的自定义对象&#xff0c;需要我们自己去建立比较标准&#xff0c;例如我们自定义一个People类&#xff0c;这个类有name和age两个属性&#xff0c;那么问…
阅读更多...
QT creator c动态链接库的创建与调用

QT creator c动态链接库的创建与调用

QT creator c动态链接库的创建与调用 QT5.15.2 1.创建dll项目 确保两类型选择正确 2.选择MinGW 64-bit 3.点击完成 pro文件参考&#xff1a; QT - guiTEMPLATE lib DEFINES QT_DLL_DEMO_LIBRARYCONFIG c17# You can make your code fail to compile if it uses deprecat…
阅读更多...
计算机组成结构—IO系统概述

计算机组成结构—IO系统概述

目录 一、I/O 系统的发展 1. 早期阶段 2. 接口模块和 DMA 阶段 3. 通道结构阶段 4. 处理机阶段 二、I/O 系统的组成 1. I/O 软件 2. I/O 硬件 三、I/O 设备 1. I/O 设备分类 2. I/O 设备的组成 在计算机中&#xff0c;除 CPU 和主存两大模块之外&#xff0c;第三个重…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023