java多线程

一朵祁连小鱼

已于 2024-07-24 17:42:58 修改

阅读量416

点赞数 6

文章标签： java

于 2024-07-24 17:39:48 首次发布

本文链接：https://blog.csdn.net/weixin_39459811/article/details/140668803

版权

1.java多线程的并发处理

多线程是指在一个程序中同时执行多个线程（子任务），每个线程都是独立的执行流程。

多线程使得程序可以同时执行多个任务，提高了系统的并发性和响应性。

在传统的单线程程序中，任务是按顺序依次执行的。而在多线程程序中，任务被划分为多个子任务，每个子任务由一个独立的线程执行。这些线程可以并发地执行，共享程序的资源（如内存空间），从而使得程序在同一时间内能够完成更多的工作。

long startTime = System.currentTimeMillis();
ExecutorService executor = Executors.newFixedThreadPool(10);  //创建大小为10的线程池
for (List data : listData) {
    executor.submit(() -> {
          xxx    //业务执行代码；这个集合的数据 并行执行xxx
          return;  
     });
}
executor.shutdown();   //关闭线程池
while (true){   //每隔1s查看任务是否都结束，如果已结束，则退出这个循环
    if(executor.isTerminated()){
        logger.info("跑数据结束，useTime：" + (System.currentTimeMillis()-startTime) + "ms");
        break;
    }
    Thread.sleep(1000);
}


补充：
1.这样写表示每隔1s打印一次，不要while表示：过了1s打印一次就结束了
while(true){
    Thread.sleep(1000);
}  

2.如果没有while循环直接返回成功，则表示：虽然接口返回成功，但是其实内部还在执行中，比如：批量导入大量数据、根据规则算分等场景其实是需要这样处理的，可以换种如下写法
（1）根据规则算分方法
private static ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(10, 20, 4, TimeUnit.SECONDS, new ArrayBlockingQueue<>(20));

public Result generateResult(XxxDto paramDto) {
    try {
        String key = "xxxTask";  //只能有一个任务在执行中
        if (redisTemplate.hasKey(key)) {
            Object value = redisTemplate.opsForValue().get(key);
            if (value != null) {
                Map map = JsonUtil.toMap((String) value);
                if ("0".equals(map.get("process"))) {
                    return Result.fail("已有正在执行的任务");
                }
            }
        }
        Integer executeHistoryId = addExecuteHistory(paramDto);   //添加执行记录
        
        threadPoolExecutor.execute(new XxxTask(key, redisTemplate, executeHistoryId, paramDto, xxxMapper));  //XxxTask.java 进行规则算分处理，见如下

        Map<String, String> processMap = new HashMap<>();
        processMap.put("process", "0");
        processMap.put("executeHistoryId", executeHistoryId.toString());
        redisTemplate.opsForValue().set(key, JsonUtil.toJsonString(processMap), 7200, TimeUnit.SECONDS);
        return Result.success("正在执行.....", key);
    } catch (Exception e) {
        log.error("生成计算结果异常：", e);
        return Result.fail("生成计算结果异常");
    }
}

XxxTask.java：
@Data
public class XxxTask implements Runnable{
    private static final Logger logger = LogManager.getLogger(XxxTask.class);

    private String key;
    private RedisTemplate redisTemplate;
    private Integer executeHistoryId;
    private XxxDto paramDto;
    private XxxMapper xxxMapper;
    

    public XxxTask(String key, RedisTemplate redisTemplate, Integer executeHistoryId, XxxDto paramDto, XxxMapper xxxMapper){
        this.key = key;
        this.redisTemplate = redisTemplate;
        this.executeHistoryId = executeHistoryId;
        this.paramDto = paramDto;
        this.xxxMapper = xxxMapper;
    }


    /**
     * 生成计算后的结果
     */
    @Override
    public void run() {
        long startTime = System.currentTimeMillis();
        logger.info("XxxTask 生成计算后的结果开始 executeHistoryId：{}，startTime：{}", executeHistoryId, startTime);
        try {
            //1.需要设置的来源数据中，设置排名、去年排名等
            xxxDataHandle();
            //2.来源数据中，根据第一步设置的排名、去年排名等 生成 结果数据
            xxxResultHandle();
    		
            //执行完成
            executeHistoryMapper.updateStatus(executeHistoryId, 1);   //0-执行中，1-执行结束并执行成功，-1-执行结束并执行失败
            processRedisHandle(1, startTime, null);
            
            logger.info("XxxTask 生成计算后的结果结束-执行成功 executeHistoryId：{}，useTime：{}ms", executeHistoryId, (System.currentTimeMillis()-startTime));
        }catch (Exception e) {
            executeHistoryMapper.updateStatus(executeHistoryId, -1);
            processRedisHandle(-1, startTime, e.getMsg);
            
            logger.error("XxxTask 生成计算后的结果结束-发生异常 executeHistoryId：{}，异常：{}", executeHistoryId, e);
        }
    }
}

private void processRedisHandle(String processPercent, long startTime, String errorMsg){
    Map<String, String> processMap = new HashMap<>();
    processMap.put("process", processPercent);
    processMap.put("executeHistoryId", executeHistoryId.toString());
    processMap.put("useTime", String.valueOf(System.currentTimeMillis()-startTime);
    processMap.put("errorMsg", errorMsg);
    redisTemplate.opsForValue().set(key, JsonUtil.toJsonString(processMap), 7200, TimeUnit.SECONDS);
}

（2）查看执行进度方法：0-执行中，1-执行结束并执行成功，-1-执行结束并执行失败
前端轮询调用该方法（比如每隔3s调用一次），如果返回还在执行中则继续调用，否则停止调用并提示执行成功或失败
public Result findProcess(String key) {
    if(!redisTemplate.hasKey(key)){
        return Result.success();
    }
    Object value = redisTemplate.opsForValue().get(key);
    if(value == null){
        return Result.success();
    }
    return Result.success(JsonUtil.toMap((String) value));
}

2.java多线程的同步与锁（处理高并发）

（1）多线程的同步是为了防止多个线程访问一个数据对象时，对数据造成的破坏，如果一个线程获得该锁，就没有其他线程可以获得锁，直到第一个线程释放（或返回）锁。

Java中每个对象都有一个内置锁，当程序运行到synchronized同步方法或代码块时该对象锁才起作用，一个对象只有一个锁，所以如果一个线程获得该锁，就没有其他线程可以获得锁，直到第一个线程释放（或返回）锁，这也意味着任何其他线程都不能进入该对象上的synchronized方法或代码块，直到该锁被释放（释放锁是指持锁线程退出了synchronized同步方法或代码块）

（2）高并发场景：防止重复提交、抢券、抢票等

常用锁：

a.悲观锁：比如java锁（synchronized和Lock），对于同一个数据的并发操作，悲观锁认为自己使用数据的时候一定有别的线程来修改数据，因此在获取数据的时候会先加锁，确保数据不会被别的线程修改。

b.乐观锁：比如数据库中的乐观锁，可以给表数据加一个version字段（时间戳或版本号），第一次读取的时候连version一起读取出来，数据更新一次就version+1，当我们提交更新的时候，判断当前版本号和第一次取出来的版本号做对比，如果版本号一样则更新，否则认为是过期数据，拒绝更新，让用户重新操作。

c.分布式锁：比如redis分布式锁

（3）实例

多个用户同时抢劵：java锁或数据库乐观锁

java锁：

接口处加个 synchronized 即可

@PostMapping("/userDrawCoupon")
public synchronized Result userDrawCoupon(@RequestBody UserCoupon userCoupon){
  return userCouponService.userDrawCoupon(userCoupon);
}

@Transactional(rollbackFor = Exception.class)
@Override
public Result userDrawCoupon(UserCoupon userCoupon) {
  Integer couponId = userCoupon.getCouponId();
  
  ......   //一系列校验该用户是否可以领取该劵，如果不能则返回：校验错误

  //新增用户领券
  userCouponMapper.insert(userCoupon);
  
  //修改劵：剩余金额
  couponMapper.updateAmountById(couponId, amount);

  return Result.success("恭喜您，领取成功！");
}

数据库乐观锁：

a.业务表中（user_coupon）：

`version` int(20) DEFAULT NULL COMMENT '版本号（一个批次劵的版本号是唯一的，用于处理高并发）',
UNIQUE KEY `index_coupon_version` (`coupon_id`,`version`) USING BTREE

b.代码中：

@PostMapping("/userDrawCoupon")
public Result userDrawCoupon(@RequestBody UserCoupon userCoupon){
  return userCouponService.userDrawCoupon(userCoupon);
}

@Transactional(rollbackFor = Exception.class)
@Override
public Result userDrawCoupon(UserCoupon userCoupon) {
  Integer couponId = userCoupon.getCouponId();
  Integer maxVersion = userCouponMapper.findMaxVersionByCouponId(couponId);  //SELECT IFNULL(MAX(version),0) FROM user_coupon WHERE coupon_id = #{couponId};
  
  ......   //一系列校验该用户是否可以领取该劵，如果不能则返回：校验错误

  //新增用户领券
  userCoupon.setVersion(maxVersion + 1);
  try {
      userCouponMapper.insert(userCoupon);  //因为建了唯一索引，所以数据库中如果已有同样的 coupon_id+version 数据，则插入会报错
  }catch (Exception e){
      return Result.fail("网络繁忙");
  }

  //修改劵：剩余金额
  couponMapper.updateAmountById(couponId, amount);

  return Result.success("恭喜您，领取成功！");
}

c.jmeter压测：

设置1000个线程调用抢券接口，大概有1/3个线程成功领取券，其余会报校验错误或者网络繁忙；

最后需要测试：所有券都领取完，系统上看一下领券总额是不是等于设置的券总额，以及领券用户数等是否正确

一朵祁连小鱼

关注

6
点赞
踩
5

收藏

觉得还不错? 一键收藏
0
评论
java多线程

多线程是指在一个程序中同时执行多个线程（子任务），每个线程都是独立的执行流程。多线程使得程序可以同时执行多个任务，提高了系统的并发性和响应性。在传统的单线程程序中，任务是按顺序依次执行的。而在多线程程序中，任务被划分为多个子任务，每个子任务由一个独立的线程执行。这些线程可以并发地执行，共享程序的资源（如内存空间），从而使得程序在同一时间内能够完成更多的工作。
复制链接

扫一扫