Ouyzc

java高并发秒杀活动的各种简单实现【springBoot+mybatis+redis+mysql】

最近遇到比较多数据不一致的问题，大多数都是因为并发请求时，没及时处理的原因，故用一个比较有代表性的业务场景【活动秒杀】来模拟一下这个这种高并发所产生的问题。

众所周知，电商系统的秒杀活动是高并发的很好应用场景，这里用的demo模拟的基本框架是springBoot+mybatis+redis+mysql，搭建的过程，我这里就不提了，有需要的可以自行百度。

1.搭好的项目目录：

2.建了一张表（记录商品名称、本次可秒杀的库存量）：

加了一条记录（后面每次测试都先手动把库存恢复成100才进行测试）

3.实体：

package com.mybatis.model;

public class MiaoShaGoods {
    private Integer id;

    private String goodsName;

    private Integer goodsSum;

    private Integer version;

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getGoodsName() {
        return goodsName;
    }

    public void setGoodsName(String goodsName) {
        this.goodsName = goodsName == null ? null : goodsName.trim();
    }

    public Integer getGoodsSum() {
        return goodsSum;
    }

    public void setGoodsSum(Integer goodsSum) {
        this.goodsSum = goodsSum;
    }

    public Integer getVersion() {
        return version;
    }

    public void setVersion(Integer version) {
        this.version = version;
    }
}

一、不做任何处理的高并发秒杀实现（错误演示）：

1.Controller层，模拟500个并发调用：

package com.mybatis.controller;

import com.mybatis.domain.BaseResponse;
import com.mybatis.domain.MiaoshaRequest;
import com.mybatis.service.MiaoshaService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.*;



@Controller
@RequestMapping(value="/miaoshagoods")
public class MiaoshaController {

    @Autowired
    public MiaoshaService miaoshaService;


    @PostMapping("/miaosha_java_sql_lock")
    public @ResponseBody BaseResponse miaoshaJavaSqlLock(@RequestBody MiaoshaRequest request){

        BaseResponse response=new BaseResponse();
            for(int i=0;i<500;i++){
                Thread thread=new Thread(new Runnable() {
                    @Override
                    public void run() {
                        //不做任何处理的秒杀实现
                        miaoshaService.miaoshaGoods(request,response);              
                    }
                });
                thread.start();
            }
            return response;
     }
}

2.Service层，每个请求进来就去数据库里查剩余的库存量，并且抢购成功后，就减1个库存：

package com.mybatis.service.Impl;

import com.mybatis.dao.MiaoShaGoodsDao;
import com.mybatis.domain.BaseResponse;
import com.mybatis.domain.MiaoshaRequest;
import com.mybatis.model.MiaoShaGoods;
import com.mybatis.service.MiaoshaService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;


@Service
public class MiashaServiceImpl implements MiaoshaService{

    @Autowired
    MiaoShaGoodsDao miaoShaGoodsDao;

    private Lock lock = new ReentrantLock();

    @Autowired
    private RedisTemplate redisTemplate;

    /**
     * 不做任何处理的秒杀实现
     * @param request
     * @return
     */
    @Override
    public BaseResponse miaoshaGoods(MiaoshaRequest request, BaseResponse response) {
        int countSuc=0;
        MiaoShaGoods miaoShaGoods=miaoShaGoodsDao.getGoods(request.getGoodNames());
        if(miaoShaGoods.getGoodsSum()>0){
            miaoShaGoods.setGoodsSum(miaoShaGoods.getGoodsSum()-1);
            countSuc= miaoShaGoodsDao.updateMsGoods(miaoShaGoods);
        }
        if(countSuc==1){
            System.out.println("抢到iphoneX,成功！");
        }else{
            System.out.println("抢到iphoneX,失败！");
        }
        return response;
    }
}

3.dao层（mybatis的xml文件）：

  

  
    update miao_sha_goods
    set goods_sum = #{goodsSum,jdbcType=INTEGER}
    where goods_name = #{goodsName,jdbcType=VARCHAR}

4.测试结果：

截图表明，居然有500个人抢购成功，而且库存量却只减少了12个，这是明显是错误的。

二、数据库乐观锁处理的高并发秒杀实现：

1.Controller层，模拟500个并发调用：

package com.mybatis.controller;

import com.mybatis.domain.BaseResponse;
import com.mybatis.domain.MiaoshaRequest;
import com.mybatis.service.MiaoshaService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.*;


@Controller
@RequestMapping(value="/miaoshagoods")
public class MiaoshaController {

    @Autowired
    public MiaoshaService miaoshaService;

    @PostMapping("/miaosha_java_sql_lock")
    public @ResponseBody BaseResponse miaoshaJavaSqlLock(@RequestBody MiaoshaRequest request){

        BaseResponse response=new BaseResponse();
        for(int i=0;i<500;i++){
            Thread thread=new Thread(new Runnable() {
                @Override
                public void run() {

                    //不做任何处理的秒杀实现
                    //miaoshaService.miaoshaGoods(request,response);
                    //数据库乐观锁秒杀
                    miaoshaService.miaoshaGoods_sql_optimistic_lock(request,response);

                }
            });
            thread.start();
        }
        return response;
    }
}

2.Service层，每个请求进来就去数据库里查剩余的库存量，并且抢购成功后，就减1个库存：

package com.mybatis.service.Impl;

import com.mybatis.dao.MiaoShaGoodsDao;
import com.mybatis.domain.BaseResponse;
import com.mybatis.domain.MiaoshaRequest;
import com.mybatis.model.MiaoShaGoods;
import com.mybatis.service.MiaoshaService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;


@Service
public class MiashaServiceImpl implements MiaoshaService{

    @Autowired
    MiaoShaGoodsDao miaoShaGoodsDao;

    private Lock lock = new ReentrantLock();

    @Autowired
    private RedisTemplate redisTemplate;

    /**
     * 不做任何处理的秒杀实现
     * @param request
     * @return
     */
    @Override
    public BaseResponse miaoshaGoods(MiaoshaRequest request, BaseResponse response) {
        int countSuc=0;
        MiaoShaGoods miaoShaGoods=miaoShaGoodsDao.getGoods(request.getGoodNames());
        if(miaoShaGoods.getGoodsSum()>0){
            miaoShaGoods.setGoodsSum(miaoShaGoods.getGoodsSum()-1);
            countSuc= miaoShaGoodsDao.updateMsGoods(miaoShaGoods);
        }
        if(countSuc==1){
            System.out.println("抢到iphoneX,成功！");
        }else{
            System.out.println("抢到iphoneX,失败！");
        }
        return response;
    }
    /**
     * 数据库乐观锁实现秒杀
     * @param request
     * @return
     */
    @Override
    public BaseResponse miaoshaGoods_sql_optimistic_lock(MiaoshaRequest request,BaseResponse response) {
        int countSuc=0;
        MiaoShaGoods miaoShaGoods=miaoShaGoodsDao.getGoods_lgs(request.getGoodNames());
        if(miaoShaGoods.getGoodsSum()>0){
            miaoShaGoods.setGoodsSum(miaoShaGoods.getGoodsSum()-1);
            countSuc= miaoShaGoodsDao.updateMsGoods_lgs(miaoShaGoods);
        }
        if(countSuc==1){
            System.out.println("抢到iphoneX,成功！");

            //做出相应的逻辑（记录抢购成功的用户名什么的....）

        }else{
            System.out.println("抢到iphoneX,失败！");

            //重试或者返回友好的提示什么的....
        }
        return response;
    }
}

3.dao层（mybatis的xml文件）[在SQL层面改为数据库乐观锁]：



  
    update miao_sha_goods
    set goods_sum = #{goodsSum,jdbcType=INTEGER},version=version+1
    where goods_name = #{goodsName,jdbcType=VARCHAR} and version = #{version,jdbcType=VARCHAR}

4.测试结果：

截图表明，总共有500个人抢，有29个人抢购成功，而且库存量减少了29个，这保证了库存的正确性。但却会有抢购不成功的请求，需要我们后续去处理。

三、数据库悲观锁处理的高并发秒杀实现：

1.Controller层，模拟500个并发调用：

package com.mybatis.controller;

import com.mybatis.domain.BaseResponse;
import com.mybatis.domain.MiaoshaRequest;
import com.mybatis.service.MiaoshaService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.*;


@Controller
@RequestMapping(value="/miaoshagoods")
public class MiaoshaController {

    @Autowired
    public MiaoshaService miaoshaService;

    @PostMapping("/miaosha_java_sql_lock")
    public @ResponseBody BaseResponse miaoshaJavaSqlLock(@RequestBody MiaoshaRequest request){

        BaseResponse response=new BaseResponse();
        for(int i=0;i<500;i++){
            Thread thread=new Thread(new Runnable() {
                @Override
                public void run() {

                    //不做任何处理的秒杀实现
                    //miaoshaService.miaoshaGoods(request,response);
                    //数据库乐观锁秒杀
                    //miaoshaService.miaoshaGoods_sql_optimistic_lock(request,response);
                    //数据库悲观锁秒杀
                    miaoshaService.miaoshaGoods_sql_pessimistic_lock(request,response);

                }
            });
            thread.start();
        }
        return response;
    }
}

2.Service层，每个请求进来就去数据库里查剩余的库存量，并且抢购成功后，就减1个库存（查询和更新必须在同一个事务）：

package com.mybatis.service.Impl;

import com.mybatis.dao.MiaoShaGoodsDao;
import com.mybatis.domain.BaseResponse;
import com.mybatis.domain.MiaoshaRequest;
import com.mybatis.model.MiaoShaGoods;
import com.mybatis.service.MiaoshaService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;


@Service
public class MiashaServiceImpl implements MiaoshaService{

    @Autowired
    MiaoShaGoodsDao miaoShaGoodsDao;

    private Lock lock = new ReentrantLock();

    @Autowired
    private RedisTemplate redisTemplate;

    /**
     * 不做任何处理的秒杀实现
     * @param request
     * @return
     */
    @Override
    public BaseResponse miaoshaGoods(MiaoshaRequest request, BaseResponse response) {
        int countSuc=0;
        MiaoShaGoods miaoShaGoods=miaoShaGoodsDao.getGoods(request.getGoodNames());
        if(miaoShaGoods.getGoodsSum()>0){
            miaoShaGoods.setGoodsSum(miaoShaGoods.getGoodsSum()-1);
            countSuc= miaoShaGoodsDao.updateMsGoods(miaoShaGoods);
        }
        if(countSuc==1){
            System.out.println("抢到iphoneX,成功！");
        }else{
            System.out.println("抢到iphoneX,失败！");
        }
        return response;
    }
    /**
     * 数据库乐观锁实现秒杀
     * @param request
     * @return
     */
    @Override
    public BaseResponse miaoshaGoods_sql_optimistic_lock(MiaoshaRequest request,BaseResponse response) {
        int countSuc=0;
        MiaoShaGoods miaoShaGoods=miaoShaGoodsDao.getGoods_lgs(request.getGoodNames());
        if(miaoShaGoods.getGoodsSum()>0){
            miaoShaGoods.setGoodsSum(miaoShaGoods.getGoodsSum()-1);
            countSuc= miaoShaGoodsDao.updateMsGoods_lgs(miaoShaGoods);
        }
        if(countSuc==1){
            System.out.println("抢到iphoneX,成功！");

            //做出相应的逻辑（记录抢购成功的用户名什么的....）

        }else{
            System.out.println("抢到iphoneX,失败！");

            //重试或者返回友好的提示什么的....
        }
        return response;
    }
    /**
     * 数据库悲观锁实现秒杀
     * @param request
     * @return
     */
    @Override
    @Transactional
    public BaseResponse miaoshaGoods_sql_pessimistic_lock(MiaoshaRequest request,BaseResponse response) {
        int countSuc=0;
        MiaoShaGoods miaoShaGoods=miaoShaGoodsDao.getGoods_bgs(request.getGoodNames());
        if(miaoShaGoods.getGoodsSum()>0){
            miaoShaGoods.setGoodsSum(miaoShaGoods.getGoodsSum()-1);
            countSuc= miaoShaGoodsDao.updateMsGoods_bgs(miaoShaGoods);
        }
        if(countSuc==1){
            System.out.println("抢到iphoneX,成功！");
        }else{
            System.out.println("抢到iphoneX,失败！");
        }
        return response;
    }
}

3.dao层（mybatis的xml文件）[在SQL层面改为数据库悲观锁]：

  

  
    update miao_sha_goods
    set goods_sum = #{goodsSum,jdbcType=INTEGER}
    where goods_name = #{goodsName,jdbcType=VARCHAR}

4.测试结果：

截图表明，总共有500个人抢，有100个人抢购成功，而且库存量减少了100个，这保证了库存的正确性。

四、java线程同步锁处理的高并发秒杀实现：

1.Controller层，模拟500个并发调用：

package com.mybatis.controller;

import com.mybatis.domain.BaseResponse;
import com.mybatis.domain.MiaoshaRequest;
import com.mybatis.service.MiaoshaService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.*;


@Controller
@RequestMapping(value="/miaoshagoods")
public class MiaoshaController {

    @Autowired
    public MiaoshaService miaoshaService;

    @PostMapping("/miaosha_java_sql_lock")
    public @ResponseBody BaseResponse miaoshaJavaSqlLock(@RequestBody MiaoshaRequest request){

        BaseResponse response=new BaseResponse();
        for(int i=0;i<500;i++){
            Thread thread=new Thread(new Runnable() {
                @Override
                public void run() {

                    //不做任何处理的秒杀实现
                    //miaoshaService.miaoshaGoods(request,response);
                    //数据库乐观锁秒杀
                    //miaoshaService.miaoshaGoods_sql_optimistic_lock(request,response);
                    //数据库悲观锁秒杀
                    //miaoshaService.miaoshaGoods_sql_pessimistic_lock(request,response);
                    //java线程同步锁秒杀
                    miaoshaService.miaoshaGoods_java_synchronized_lock(request,response);

                }
            });
            thread.start();
        }
        return response;
    }
}

2.Service层，每个请求进来就去数据库里查剩余的库存量，并且抢购成功后，就减1个库存：

package com.mybatis.service.Impl;

import com.mybatis.dao.MiaoShaGoodsDao;
import com.mybatis.domain.BaseResponse;
import com.mybatis.domain.MiaoshaRequest;
import com.mybatis.model.MiaoShaGoods;
import com.mybatis.service.MiaoshaService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;


@Service
public class MiashaServiceImpl implements MiaoshaService{

    @Autowired
    MiaoShaGoodsDao miaoShaGoodsDao;

    private Lock lock = new ReentrantLock();

    @Autowired
    private RedisTemplate redisTemplate;

    /**
     * 不做任何处理的秒杀实现
     * @param request
     * @return
     */
    @Override
    public BaseResponse miaoshaGoods(MiaoshaRequest request, BaseResponse response) {
        int countSuc=0;
        MiaoShaGoods miaoShaGoods=miaoShaGoodsDao.getGoods(request.getGoodNames());
        if(miaoShaGoods.getGoodsSum()>0){
            miaoShaGoods.setGoodsSum(miaoShaGoods.getGoodsSum()-1);
            countSuc= miaoShaGoodsDao.updateMsGoods(miaoShaGoods);
        }
        if(countSuc==1){
            System.out.println("抢到iphoneX,成功！");
        }else{
            System.out.println("抢到iphoneX,失败！");
        }
        return response;
    }
    /**
     * 数据库乐观锁实现秒杀
     * @param request
     * @return
     */
    @Override
    public BaseResponse miaoshaGoods_sql_optimistic_lock(MiaoshaRequest request,BaseResponse response) {
        int countSuc=0;
        MiaoShaGoods miaoShaGoods=miaoShaGoodsDao.getGoods_lgs(request.getGoodNames());
        if(miaoShaGoods.getGoodsSum()>0){
            miaoShaGoods.setGoodsSum(miaoShaGoods.getGoodsSum()-1);
            countSuc= miaoShaGoodsDao.updateMsGoods_lgs(miaoShaGoods);
        }
        if(countSuc==1){
            System.out.println("抢到iphoneX,成功！");

            //做出相应的逻辑（记录抢购成功的用户名什么的....）

        }else{
            System.out.println("抢到iphoneX,失败！");

            //重试或者返回友好的提示什么的....
        }
        return response;
    }
    /**
     * 数据库悲观锁实现秒杀
     * @param request
     * @return
     */
    @Override
    @Transactional
    public BaseResponse miaoshaGoods_sql_pessimistic_lock(MiaoshaRequest request,BaseResponse response) {
        int countSuc=0;
        MiaoShaGoods miaoShaGoods=miaoShaGoodsDao.getGoods_bgs(request.getGoodNames());
        if(miaoShaGoods.getGoodsSum()>0){
            miaoShaGoods.setGoodsSum(miaoShaGoods.getGoodsSum()-1);
            countSuc= miaoShaGoodsDao.updateMsGoods_bgs(miaoShaGoods);
        }
        if(countSuc==1){
            System.out.println("抢到iphoneX,成功！");
        }else{
            System.out.println("抢到iphoneX,失败！");
        }
        return response;
    }
    /**
     * java同步锁实现秒杀
     * @param request
     * @return
     */
    @Override
    public BaseResponse miaoshaGoods_java_synchronized_lock(MiaoshaRequest request,BaseResponse response) {
        synchronized(this){
            int countSuc=0;
            MiaoShaGoods miaoShaGoods=miaoShaGoodsDao.getGoods(request.getGoodNames());
            if(miaoShaGoods.getGoodsSum()>0){
                miaoShaGoods.setGoodsSum(miaoShaGoods.getGoodsSum()-1);
                countSuc= miaoShaGoodsDao.updateMsGoods(miaoShaGoods);
            }
            if(countSuc==1){
                System.out.println("抢到iphoneX,成功！");
            }else{
                System.out.println("抢到iphoneX,失败！");
            }
        }
        return response;
    }
}

3.dao层（mybatis的xml文件）：

  

  
    update miao_sha_goods
    set goods_sum = #{goodsSum,jdbcType=INTEGER}
    where goods_name = #{goodsName,jdbcType=VARCHAR}

4.测试结果：

截图表明，总共有500个人抢，有100个人抢购成功，而且库存量减少了100个，这保证了库存的正确性。

五、java线程可重入锁处理的高并发秒杀实现：

1.Controller层，模拟500个并发调用：

package com.mybatis.controller;

import com.mybatis.domain.BaseResponse;
import com.mybatis.domain.MiaoshaRequest;
import com.mybatis.service.MiaoshaService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.*;


@Controller
@RequestMapping(value="/miaoshagoods")
public class MiaoshaController {

    @Autowired
    public MiaoshaService miaoshaService;

    @PostMapping("/miaosha_java_sql_lock")
    public @ResponseBody BaseResponse miaoshaJavaSqlLock(@RequestBody MiaoshaRequest request){

        BaseResponse response=new BaseResponse();
        for(int i=0;i<500;i++){
            Thread thread=new Thread(new Runnable() {
                @Override
                public void run() {

                    //不做任何处理的秒杀实现
                    //miaoshaService.miaoshaGoods(request,response);
                    //数据库乐观锁秒杀
                    //miaoshaService.miaoshaGoods_sql_optimistic_lock(request,response);
                    //数据库悲观锁秒杀
                    //miaoshaService.miaoshaGoods_sql_pessimistic_lock(request,response);
                    //java线程同步锁秒杀
                  //miaoshaService.miaoshaGoods_java_synchronized_lock(request,response);
                    //java线程可重入锁秒杀
                    miaoshaService.miaoshaGoods_java_reentrant_lock(request,response);

                }
            });
            thread.start();
        }
        return response;
    }
}

2.Service层，每个请求进来就去数据库里查剩余的库存量，并且抢购成功后，就减1个库存：

package com.mybatis.service.Impl;

import com.mybatis.dao.MiaoShaGoodsDao;
import com.mybatis.domain.BaseResponse;
import com.mybatis.domain.MiaoshaRequest;
import com.mybatis.model.MiaoShaGoods;
import com.mybatis.service.MiaoshaService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;


@Service
public class MiashaServiceImpl implements MiaoshaService{

    @Autowired
    MiaoShaGoodsDao miaoShaGoodsDao;

    private Lock lock = new ReentrantLock();

    @Autowired
    private RedisTemplate redisTemplate;

    /**
     * 不做任何处理的秒杀实现
     * @param request
     * @return
     */
    @Override
    public BaseResponse miaoshaGoods(MiaoshaRequest request, BaseResponse response) {
        int countSuc=0;
        MiaoShaGoods miaoShaGoods=miaoShaGoodsDao.getGoods(request.getGoodNames());
        if(miaoShaGoods.getGoodsSum()>0){
            miaoShaGoods.setGoodsSum(miaoShaGoods.getGoodsSum()-1);
            countSuc= miaoShaGoodsDao.updateMsGoods(miaoShaGoods);
        }
        if(countSuc==1){
            System.out.println("抢到iphoneX,成功！");
        }else{
            System.out.println("抢到iphoneX,失败！");
        }
        return response;
    }
    /**
     * 数据库乐观锁实现秒杀
     * @param request
     * @return
     */
    @Override
    public BaseResponse miaoshaGoods_sql_optimistic_lock(MiaoshaRequest request,BaseResponse response) {
        int countSuc=0;
        MiaoShaGoods miaoShaGoods=miaoShaGoodsDao.getGoods_lgs(request.getGoodNames());
        if(miaoShaGoods.getGoodsSum()>0){
            miaoShaGoods.setGoodsSum(miaoShaGoods.getGoodsSum()-1);
            countSuc= miaoShaGoodsDao.updateMsGoods_lgs(miaoShaGoods);
        }
        if(countSuc==1){
            System.out.println("抢到iphoneX,成功！");

            //做出相应的逻辑（记录抢购成功的用户名什么的....）

        }else{
            System.out.println("抢到iphoneX,失败！");

            //重试或者返回友好的提示什么的....
        }
        return response;
    }
    /**
     * 数据库悲观锁实现秒杀
     * @param request
     * @return
     */
    @Override
    @Transactional
    public BaseResponse miaoshaGoods_sql_pessimistic_lock(MiaoshaRequest request,BaseResponse response) {
        int countSuc=0;
        MiaoShaGoods miaoShaGoods=miaoShaGoodsDao.getGoods_bgs(request.getGoodNames());
        if(miaoShaGoods.getGoodsSum()>0){
            miaoShaGoods.setGoodsSum(miaoShaGoods.getGoodsSum()-1);
            countSuc= miaoShaGoodsDao.updateMsGoods_bgs(miaoShaGoods);
        }
        if(countSuc==1){
            System.out.println("抢到iphoneX,成功！");
        }else{
            System.out.println("抢到iphoneX,失败！");
        }
        return response;
    }
    /**
     * java同步锁实现秒杀
     * @param request
     * @return
     */
    @Override
    public BaseResponse miaoshaGoods_java_synchronized_lock(MiaoshaRequest request,BaseResponse response) {
        synchronized(this){
            int countSuc=0;
            MiaoShaGoods miaoShaGoods=miaoShaGoodsDao.getGoods(request.getGoodNames());
            if(miaoShaGoods.getGoodsSum()>0){
                miaoShaGoods.setGoodsSum(miaoShaGoods.getGoodsSum()-1);
                countSuc= miaoShaGoodsDao.updateMsGoods(miaoShaGoods);
            }
            if(countSuc==1){
                System.out.println("抢到iphoneX,成功！");
            }else{
                System.out.println("抢到iphoneX,失败！");
            }
        }
        return response;
    }
    /**
     * java可重入锁实现秒杀
     * @param request
     * @return
     */
    @Override
    public BaseResponse miaoshaGoods_java_reentrant_lock(MiaoshaRequest request,BaseResponse response) {

        lock.lock();
        int countSuc=0;
        MiaoShaGoods miaoShaGoods=miaoShaGoodsDao.getGoods(request.getGoodNames());
        if(miaoShaGoods.getGoodsSum()>0){
            miaoShaGoods.setGoodsSum(miaoShaGoods.getGoodsSum()-1);
            countSuc= miaoShaGoodsDao.updateMsGoods(miaoShaGoods);
        }
        if(countSuc==1){
            System.out.println(request.getGoodNames()+"抢到iphoneX,成功！");
        }else{
            System.out.println("抢到iphoneX,失败！");
        }
        lock.unlock();
        return response;
    }
}

3.dao层（mybatis的xml文件）：

  

  
    update miao_sha_goods
    set goods_sum = #{goodsSum,jdbcType=INTEGER}
    where goods_name = #{goodsName,jdbcType=VARCHAR}

4.测试结果：

截图表明，总共有500个人抢，有100个人抢购成功，而且库存量减少了100个，这保证了库存的正确性。

六、redis单线程处理的高并发秒杀实现（推荐）：

1.Controller层，模拟500个并发调用：

package com.mybatis.controller;

import com.mybatis.domain.BaseResponse;
import com.mybatis.domain.MiaoshaRequest;
import com.mybatis.service.MiaoshaService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.*;



@Controller
@RequestMapping(value="/miaoshagoods")
public class MiaoshaController {

    @Autowired
    public MiaoshaService miaoshaService;

    @Autowired
    private RedisTemplate redisTemplate;


    @PostMapping("/miaosha_java_sql_lock")
    public @ResponseBody BaseResponse miaoshaJavaSqlLock(@RequestBody MiaoshaRequest request){

        BaseResponse response=new BaseResponse();
        for(int i=0;i<500;i++){
            Thread thread=new Thread(new Runnable() {
                @Override
                public void run() {

                    //不做任何处理的秒杀实现
                    //miaoshaService.miaoshaGoods(request,response);
                    //数据库乐观锁秒杀
                    //miaoshaService.miaoshaGoods_sql_optimistic_lock(request,response);
                    //数据库悲观锁秒杀
                    //miaoshaService.miaoshaGoods_sql_pessimistic_lock(request,response);
                    //java线程同步锁秒杀
                    //miaoshaService.miaoshaGoods_java_synchronized_lock(request,response);
                    //java线程可重入锁秒杀
                    miaoshaService.miaoshaGoods_java_reentrant_lock(request,response);
                }
            });
            thread.start();
        }
        return response;
    }

   @PostMapping("/miaosha_redis_lock")
    public @ResponseBody BaseResponse miaoshaRedisLock(@RequestBody MiaoshaRequest request){
        BaseResponse response=new BaseResponse();
        //初始化商品数量
        Integer goodsSum=miaoshaService.getGoodsSum(request);
        redisTemplate.opsForValue().set(request.getGoodNames()+":goodsSum",goodsSum+"");
        System.out.println("总共的库存量："+goodsSum);

        for(int i=0;i<500;i++){
            Thread thread=new Thread(new Runnable() {
                @Override
                public void run() {
                    miaoshaService.miaoshaGoods_redis(request,response);
                }
            });
            thread.start();
        }
        return response;
    }
}

2.Service层，先把参与秒杀的总库存量写入redis里，然后再利用redis的增量方法去递减：

package com.mybatis.service.Impl;

import com.mybatis.dao.MiaoShaGoodsDao;
import com.mybatis.domain.BaseResponse;
import com.mybatis.domain.MiaoshaRequest;
import com.mybatis.model.MiaoShaGoods;
import com.mybatis.service.MiaoshaService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;


@Service
public class MiashaServiceImpl implements MiaoshaService{

    @Autowired
    MiaoShaGoodsDao miaoShaGoodsDao;

    private Lock lock = new ReentrantLock();

    @Autowired
    private RedisTemplate redisTemplate;

    /**
     * 不做任何处理的秒杀实现
     * @param request
     * @return
     */
    @Override
    public BaseResponse miaoshaGoods(MiaoshaRequest request, BaseResponse response) {
        int countSuc=0;
        MiaoShaGoods miaoShaGoods=miaoShaGoodsDao.getGoods(request.getGoodNames());
        if(miaoShaGoods.getGoodsSum()>0){
            miaoShaGoods.setGoodsSum(miaoShaGoods.getGoodsSum()-1);
            countSuc= miaoShaGoodsDao.updateMsGoods(miaoShaGoods);
        }
        if(countSuc==1){
            System.out.println("抢到iphoneX,成功！");
        }else{
            System.out.println("抢到iphoneX,失败！");
        }
        return response;
    }
    /**
     * 数据库乐观锁实现秒杀
     * @param request
     * @return
     */
    @Override
    public BaseResponse miaoshaGoods_sql_optimistic_lock(MiaoshaRequest request,BaseResponse response) {
        int countSuc=0;
        MiaoShaGoods miaoShaGoods=miaoShaGoodsDao.getGoods_lgs(request.getGoodNames());
        if(miaoShaGoods.getGoodsSum()>0){
            miaoShaGoods.setGoodsSum(miaoShaGoods.getGoodsSum()-1);
            countSuc= miaoShaGoodsDao.updateMsGoods_lgs(miaoShaGoods);
        }
        if(countSuc==1){
            System.out.println("抢到iphoneX,成功！");

            //做出相应的逻辑（记录抢购成功的用户名什么的....）

        }else{
            System.out.println("抢到iphoneX,失败！");

            //重试或者返回友好的提示什么的....
        }
        return response;
    }
    /**
     * 数据库悲观锁实现秒杀
     * @param request
     * @return
     */
    @Override
    @Transactional
    public BaseResponse miaoshaGoods_sql_pessimistic_lock(MiaoshaRequest request,BaseResponse response) {
        int countSuc=0;
        MiaoShaGoods miaoShaGoods=miaoShaGoodsDao.getGoods_bgs(request.getGoodNames());
        if(miaoShaGoods.getGoodsSum()>0){
            miaoShaGoods.setGoodsSum(miaoShaGoods.getGoodsSum()-1);
            countSuc= miaoShaGoodsDao.updateMsGoods_bgs(miaoShaGoods);
        }
        if(countSuc==1){
            System.out.println("抢到iphoneX,成功！");
        }else{
            System.out.println("抢到iphoneX,失败！");
        }
        return response;
    }
    /**
     * java同步锁实现秒杀
     * @param request
     * @return
     */
    @Override
    public BaseResponse miaoshaGoods_java_synchronized_lock(MiaoshaRequest request,BaseResponse response) {
        synchronized(this){
            int countSuc=0;
            MiaoShaGoods miaoShaGoods=miaoShaGoodsDao.getGoods(request.getGoodNames());
            if(miaoShaGoods.getGoodsSum()>0){
                miaoShaGoods.setGoodsSum(miaoShaGoods.getGoodsSum()-1);
                countSuc= miaoShaGoodsDao.updateMsGoods(miaoShaGoods);
            }
            if(countSuc==1){
                System.out.println("抢到iphoneX,成功！");
            }else{
                System.out.println("抢到iphoneX,失败！");
            }
        }
        return response;
    }
    /**
     * java可重入锁实现秒杀
     * @param request
     * @return
     */
    @Override
    public BaseResponse miaoshaGoods_java_reentrant_lock(MiaoshaRequest request,BaseResponse response) {

        lock.lock();
        int countSuc=0;
        MiaoShaGoods miaoShaGoods=miaoShaGoodsDao.getGoods(request.getGoodNames());
        if(miaoShaGoods.getGoodsSum()>0){
            miaoShaGoods.setGoodsSum(miaoShaGoods.getGoodsSum()-1);
            countSuc= miaoShaGoodsDao.updateMsGoods(miaoShaGoods);
        }
        if(countSuc==1){
            System.out.println(request.getGoodNames()+"抢到iphoneX,成功！");
        }else{
            System.out.println("抢到iphoneX,失败！");
        }
        lock.unlock();
        return response;
    }

    @Override
    public Integer getGoodsSum(MiaoshaRequest request) {
        MiaoShaGoods miaoShaGoods=miaoShaGoodsDao.getGoods(request.getGoodNames());
        return miaoShaGoods.getGoodsSum();
    }
    /**
     * redis实现秒杀
     * @param response
     * @return
     */
    @Override
    public BaseResponse miaoshaGoods_redis(MiaoshaRequest request,BaseResponse response) {

        //增量计算剩余库存(利用redis的单线程特性)
        double goodsSurplusSum=redisTemplate.opsForValue().increment(request.getGoodNames()+":goodsSum",-1);
        if(goodsSurplusSum>=0){
            System.out.println("抢到iphoneX,成功！还剩下："+goodsSurplusSum);
        }else {
            System.out.println("抢到iphoneX,失败！");
        }
        return response;
    }
}

3.测试结果：

截图表明，总共有500个人抢，有100个人抢购成功，而且库存量减少了100个，这保证了库存的正确性，抢后redis显示是-400个，说明有500个人进来了，有400个人抢不到。

综上所述，要控制库存量，一般要用锁机制。但是一般加锁的话会比较影响性能（只能用于单服务），推荐大家使用redis自带的线程安全属性来实现（可实现分布式锁）。

如有错漏，望各位指出！

你可能感兴趣的:(高并发处理)

揭秘Nginx架构-10000并发连接背后的秘密 w风雨无阻w Nginx nginx 架构运维
在当今移动互联网时代,网站的高并发、高性能成为了决胜关键。作为一款出色的开源Web服务器,Nginx以其非凡的高并发处理能力成为了架构师的利器。让我们一同揭开Nginx源码的神秘面纱,探索它高效处理海量请求的秘密。一、为何高并发是如此重要?2000年代以来,随着PC、移动设备的普及,互联网用户数激增。网站的并发连接数也随之大幅提高,常见的网站要承载数十万甚至上百万的并发请求。与此同时,Ajax和H
高性能web服务器-nginx（一） calm–1 数据库服务器前端运维 nginx
nginx高性能web服务详解1.1nginx简介Nginx(enginex)是一个高性能的HTTP和反向代理服务器，也是一个IMAP/POP3/SMTP邮件代理服务器。由IgorSysoev于2004年首次发布，其设计目标是解决C10K问题，即在一台服务器上同时处理一万个并发连接。Nginx以其高并发处理能力、低资源消耗和模块化设计而闻名，广泛应用于Web服务器、反向代理、负载均衡等场景。随着信
“八股文”在程序员面试中的价值：助力还是阻力？精神阿祝尝鲜面试职场和发展
文章目录引言1.什么是“八股文”？2.“八股文”的支持者观点2.1理论基础的重要性2.2规范与标准化2.3应对突发问题3.“八股文”的反对者观点3.1实战经验的重视3.2忽视创新与灵活性3.3学习成本与心理压力4.八股文的具体内容分析4.1数据结构与算法4.1.1数据结构的重要性4.1.2算法的应用4.2系统设计4.2.1系统的架构设计4.2.2高并发处理4.3编程语言基础4.4框架与工具的使用5
使用 Nginx 部署前端 Vue 项目：跨平台详细指南 Hello.Reader 运维 web 前端 vue.js javascript nginx
一、为什么选择Nginx？Nginx是一个高性能的Web服务器和反向代理服务器，以其稳定性和高并发处理能力而闻名。它可以快速处理静态内容，同时支持负载均衡、反向代理等功能，非常适合部署前端应用，如Vue项目。二、准备工作：构建Vue项目在部署之前，首先需要将Vue项目进行打包构建，生成可部署的静态文件。以下是构建步骤：确保你的项目依赖已经安装完毕：npminstall运行以下命令进行项目构建：np
小白？转型？毕业生？外行学习快速入行大数据开发指南 weixin_45732643 Hadoop 大数据开发编程语言大数据大数据开发大数据学习 Hadoop 编程语言
大数据是对海量数据进行存储、计算、统计、分析处理的一系列处理手段，处理的数据量通常是TB级，甚至是PB或EB级的数据，这是传统数据处理手段所无法完成的，其涉及的技术有分布式计算、高并发处理、高可用处理、集群、实时性计算等，汇集了当前IT领域热门流行的IT技术。大数据是什么？投资者眼里是金光闪闪的两个字：资产。比如，Facebook上市时，评估机构评定的有效资产中大部分都是其社交网站上的数据。如果把
HAProxy 负载均衡指南私有运维负载均衡运维
一、HAProxy简介HAProxy(HighAvailabilityProxy)是一款高性能、开源的负载均衡器和代理服务器。它以其高并发处理能力、灵活的配置选项和强大的功能而闻名，广泛应用于各种Web服务场景，如：负载均衡:将流量分配到多个后端服务器，提高系统可用性和性能。反向代理:隐藏真实服务器，提供安全防护、缓存内容等功能。SSL/TLS终止:处理HTTPS请求，提高网站安全性。Web性能优
Django后端架构开发：Nginx服务优化实践 Switch616 Python Web django 架构 nginx python 后端中间件
Django后端架构开发：Nginx服务优化实践目录Nginx核心概念Nginx服务原理Nginx负载均衡Nginx反向代理⚙️Nginx动静分离Nginx核心概念Nginx作为一款轻量级且功能强大的HTTP服务器，广泛应用于现代Web开发中。在Django后端架构中，Nginx不仅可以用作静态文件服务器，还可以充当反向代理服务器，将请求分发到后端的应用服务器。它的高并发处理能力和低资源占用，使其
Nginx 高性能架构解析快乐非自愿 nginx 架构运维
1.Nginx简介与核心架构1.1Nginx简介Nginx(enginex)是一个高性能的HTTP和反向代理服务器，也是一个IMAP/POP3/SMTP邮件代理服务器。由IgorSysoev于2004年首次发布，其设计目标是解决C10K问题，即在一台服务器上同时处理一万个并发连接。Nginx以其高并发处理能力、低资源消耗和模块化设计而闻名，广泛应用于Web服务器、反向代理、负载均衡等场景。1.1.
Nginx服务老伙子53 nginx 运维
Nginx服务一、什么是Nginx1、概念Nginx是一个高性能的开源的HTTP和反向代理服务器，以及邮件（IMAP/POP3）代理服务器。它最初由IgorSysoev创建，并于2004年首次公开发布。Nginx的主要特点包括高性能、低内存占用、高并发处理能力以及高度的可靠性。2、特点高性能Nginx被设计成高性能的服务器软件，能够处理大量并发连接和高流量的请求。它采用了事件驱动的架构，使用异步I
初识Nginx 懒洋洋的华369 初入后端 nginx 运维后端
摘要：最近几个项目中的接口总是访问受限，需要后端同事配置Nginx代理，了解下Nginx后面自己配置。Nginx是一款高性能的开源Web服务器和反向代理服务器。它具有轻量级、高并发、低内存消耗等特点，常被用作静态资源服务、负载均衡、反向代理和缓存等方面的解决方案。下面是Nginx的一些重要特点和主要用途：高并发处理能力：Nginx使用事件驱动的异步非阻塞架构，能够处理大量并发连接而不会因为连接数增
Nginx介绍和使用 Y T nginx
Nginx（发音为“engine-x”）是一个开源的高性能HTTP服务器和反向代理服务器，由俄罗斯的IgorSysoev创建。它以轻量级、高并发处理能力和低资源消耗而闻名，非常适合处理大量并发连接，这使得它成为许多高流量网站的首选服务器软件。Nginx的主要功能：HTTP服务器：Nginx可以作为独立的HTTP服务器，处理静态文件、索引文件和自动索引。反向代理：Nginx可以作为反向代理服务器，将
提高网站访问速度 nginx 常用配置参数人生万事须自为，跬步江山即寥廓。服务器 nginx 运维
Nginx是一种高性能的HTTP和反向代理服务器，因其轻量级、高并发处理能力和易于配置而广受欢迎。要提高网站访问速度，可以通过优化Nginx配置来实现。以下是一些可以用来提高网站访问速度的Nginx配置参数，以及它们的详细说明：1.**worker_processes**：这个参数设置Nginx工作进程的数量。理想情况下，这个数字应该等于服务器的CPU核心数。这样可以最大化利用CPU资源，提高处理
C++服务器端开发（2）:确定服务器框架 Galaxy银河 C++更多语法计算机 /人工智能 c++服务器开发语言
选择C++服务器框架时，可以考虑：并发性能：C++的强项之一是其并发性能。选择一个具有高并发处理能力的服务器框架，可以更好地满足大量并发请求的需求。例如，libevent、Boost.Asio和CppServer都是具有良好并发性能的C++服务器框架。可扩展性：服务器应用程序通常需要处理大量数据和请求，因此选择一个具有良好可扩展性的服务器框架非常重要。一些流行的可扩展性强的C++服务器框架包括Po
RedissonClient妙用-分布式布隆过滤器林犀居士 java 分布式布隆过滤器 Redisson 以太坊大数据量去重
目录布隆过滤器介绍布隆过滤器的落地应用场景高并发处理多个过滤器平滑切换分析总结布隆过滤器介绍布隆过滤器（BloomFilter）是1970年由布隆提出的。它实际上是一个很长的二进制向量和一系列随机映射函数。布隆过滤器可以用于检索一个元素是否在一个集合中。它的优点是空间效率和查询时间都比一般的算法要好的多，缺点是有一定的误识别率和删除困难。什么业务场景需要使用这个布隆过滤器呢？我个人觉得是对误判数据
高并发架构初步详解海·是倒过来的天系统架构数据库架构安全架构
什么是统一异常处理高并发经常会发生在有大活跃用户量，用户高聚集的业务场景中，如：秒杀活动，定时领取红包等。为了让业务可以流畅的运行并且给用户一个好的交互体验，我们需要根据业务场景预估达到的并发量等因素，来设计适合自己业务场景的高并发处理方案。在电商相关产品开发的这些年，我有幸的遇到了并发下的各种坑，这一路摸爬滚打过来有着不少的血泪史，这里进行的总结，作为自己的归档记录，同时分享给大家。服务器架构业
性能超Spark 100倍，算立方补上邦盛科技实时智能技术体系的关键拼图丨爱分析访谈 ifenxi爱分析 spark 科技大数据
随着互联网和物联网的逐渐普及，各行业都开始源源不断产生单源或多源数据，这些高并发的数据具有高度的实时性和明显的时间序列，数据越热的时候处理，获得的业务价值越高。随着数字化转型的深入，企业都在积极建设数据能力，开发数据应用，以实现数据驱动业务。邦盛科技是一家专注于大数据实时智能领域的人工智能厂商，提出“时序中间态”技术体系，针对高并发的热数据可毫秒间完成计算。其核心技术之一是能够实时快速、高并发处理
Go 如何应对高并发 | 高并发详解 Lamb! Go golang 开发语言
并发编程是当前软件领域中不可忽视的一个关键概念。随着CPU等硬件的不断发展，我们都渴望让我们的程序运行速度更快、更快。而Go语言在语言层面天生支持并发，充分利用现代CPU的多核优势，这也是Go语言能够广泛流行的一个重要原因。在Java中，要支持高并发有几种方案可供选择。首先，我们可以通过开启多部署节点集群来增加高并发处理能力，通过增加机器硬件来实现。其次，我们可以在单节点上开启多线程来处理请求。然
设计高并发架构与系统多级缓存架构如何设计？ 90后小伙追梦之路 java 架构后端面试 java 程序人生分布式数据结构
高并发经常会发生在有大活跃用户量，用户高聚集的业务场景中，如：秒杀活动，定时领取红包等。为了让业务可以流畅的运行并且给用户一个好的交互体验，我们需要根据业务场景预估达到的并发量等因素，来设计适合自己业务场景的高并发处理方案。在电商相关产品开发的这些年，我有幸的遇到了并发下的各种坑，这一路摸爬滚打过来有着不少的血泪史，这里进行的总结，作为自己的归档记录，同时分享给大家。服务器架构业务从发展的初期到逐
项目部署 win_zcj Django django nginx linux python
目标:在浏览器输入www.rabbit.com回车进入到Django项目主页**1.概念Django项目(Web应用)Web服务1.nginx:高并发处理的好2.Apache:稳定LNMP:LinuxNginxMySQLPython/PHP/PerlLAMP:LinuxApacheMySQLPython/PHP/Perl3.uwsgi是Web服务器与Web框架之间一种简单而通用的接口2.项目部署部
Java - 深入四大限流算法：原理、实现与应用小小工匠【Spring Boot2.X】【Java -Java Base】java 流控算法
文章目录Pre概述简单计数器原理实现测试优缺点滑动窗口算法原理实现测试优缺点漏桶算法原理实现测试优缺点令牌桶算法原理实现测试优缺点小结Pre深入理解分布式技术-限流并发编程-25高并发处理手段之消息队列思路+应用拆分思路+应用限流思路SpringBoot-优雅的实现【流控】SpringBoot-利用Resilience4j-RateLimiter进行流量控制和服务降级MQ-19安全_限流方案的设计
使用nginx+uwsgi+Django部署(绝对可行版) 探索1者
服务器上部署最糟心的就是看了很多有关django项目部署的博客，却没有一个可以运行成功的，今天就发表一篇有关部署的文章，保证可行。目标:在浏览器输入www.rabbit.com回车，进入到Django项目主页首先，我们先简单看一些概念的东西：Django项目(Web应用)Web服务nginx:高并发处理的好Apache:稳定LNMP:LinuxNginxMySQLPython/PHP/PerlLA
使用nginx代理ws为 [奸笑]这个不是斜眼笑[奸笑] 计算机网络 java nginx 运维
Nginx是一个高性能的开源Web服务器，也可以用作反向代理服务器、负载均衡器和HTTP缓存。它具有低内存消耗和高并发处理能力，因此被广泛用于大型网站和应用程序的部署。Nginx的架构采用事件驱动模型，能够高效地处理并发连接，同时具有灵活的配置选项和丰富的功能模块，使其成为一个流行的Web服务器解决方案。Nginx支持多种操作系统，包括Linux、Unix、Windows等，同时也支持多种协议，如
ElasticSearch 5. 搭建ES集群自挂东南只自学ElasticSearch
Elasticsearch集群1.why?提高负载能力提高存储容量上限实现高可用提高并发处理能力…2.数据分片（Shard）es集群把数据拆分成多份，每一份存储到不同节点（node），从而实现减少每个节点的数据量，减少单个服务器的压力，构成分布式搜索。它通过将一个索引切分为多个底层物理的Lucene索引完成索引数据的分割存储功能，这每一个物理的Lucene索引称为一个分片(shard)。当集群规模
开篇词 | 想吃透架构？得看看真实、接地气的架构案例 _Rye_ 架构实战案例架构
架构的内容，相信你也看过很多了，博客、书籍、技术大会等等，都会有大量架构方面的分享。但一方面，这些内容比较碎片化，比如这一次讲的是技术的高并发处理，下一次讲的是老业务的改造。表面上看，脑子里塞得满满的，但实际上，很难循序渐进、系统地去学习架构。另一方面，这些内容大多比较含糊，看似说的要点很全，但缺乏关键的实现细节，这样的话，说的和做的联系不起来，结果就是你可能理解起来都有困难，更不用说在实际工作中
高并发方案设计(海量数据，高并发处理方案) 郑..方..醒 Java 系统架构高并发 java
提示：海量数据设计方案、高并发设计方案、宽表是什么、什么是写扩散、微博这种高并发写高并发读怎么设计、什么是对冲请求、什么是重写轻读文章目录前言一、分类二、高并发读1、策略1：加副本1.1、加缓存1.2、加节点1.3、CDN/静态文件加速/动静分离2、策略2：并发读2.1、异步rpc2.2、冗余请求(对冲请求)3、策略3：重写轻读3.1、微博Feeds流的实现3.1.1、原始方案实现3.1.2、重写
集成SpringCloudAlibaba短信服务短信验证码海海向前冲 java java springcloud 阿里云 Alibaba
1.1SpringCloudAlibaba短信服务简介短信服务（ShortMessageService）是阿里云为用户提供的一种通信服务的能力。产品优势：覆盖全面、高并发处理、消息堆积处理、开发管理简单、智能监控调度产品功能：短信通知、短信验证码、推广短信、异步通知、数据统计应用场景：短信验证码、系统信息推送、推广短信等SpringCloudAlibaba提供的短信服务，集成更加方便，代码更加简洁
RateLimiter限流 LiuM150428 高并发 java
RateLimiter限流1、处理高并发1.1高并发处理方案：缓存缓存的目的是提升系统访问速度和增大系统处理容量降级降级是当服务出现问题或者影响到核心流程时，需要暂时屏蔽掉，待高峰或者问题解决后再打开限流限流的目的是通过对并发访问/请求进行限速，或者对一个时间窗口内的请求进行限速来保护系统，一旦达到限制速率则可以拒绝服务、排队或等待、降级等处理1、2限流方式：mq、ratelimiter2、rat
服务器高并发处理/服务器宕机了怎么处理？ PAINzw 服务器运维安全
服务器高并发处理/服务器宕机了怎么处理？高并发问题是大部分服务器都经历过的，由于资源的有限性，其同时处理请求的能力自然也有限制。当高并发出现时，服务端的处理和响应速度会大幅降低，更严重的会使服务器崩溃一、服务器高并发处理1、减少请求数量高并发的主要原因之一就是请求量过于庞大，以致超出服务器的承受范围，因此想要解决问题就需要在这方面做出处理，一是需要避免重复的请求消耗不必要的资源，二是通过客户端自身
JanusGraph简介娃娃学软件
JanusGraph的优点JanusGraph支持对大图(单机往往难以处理的大图)进行实时的分析和遍历。主要有以下优点：JanusGraph可以通过扩展集群中的机器数量来进行弹性的扩展，从而能够实现对非常大的图数据处理。JanusGraph支持对图的高并发处理以及事务处理，并且能力能够随着机器的扩展而弹性扩展。JanusGraph支持Hadoop框架，并能够利用Hadoop对图进行大批量的处理和分
【C语言】Linux实现高并发处理的过程一尘之中编程 #C语言网络开发语言 c语言 linux
一、实现高并发的几种策略C语言本身并没有内建的多线程支持（新版C语言支持，但用得不多），但是在多数操作系统中，可以使用库来实现多线程编程。例如，在POSIX兼容系统上，可以使用pthreads库来创建和管理线程。然而，传统的多线程存在着资源限制，比如每个线程都需要独立的堆栈空间，上下文切换开销大，线程数量多时还会导致竞争情况加剧。为了兼顾高并发和高性能，可以采取以下几种策略：1.线程池(Threa
java数字签名三种方式知了ing java jdk
以下3钟数字签名都是基于jdk7的 1，RSA String password="test"; // 1.初始化密钥 KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("RSA"); keyPairGenerator.initialize(51
Hibernate学习笔记 caoyong Hibernate
1>、Hibernate是数据访问层框架，是一个ORM(Object Relation Mapping)框架，作者为:Gavin King 2>、搭建Hibernate的开发环境 a>、添加jar包: aa>、hibernatte开发包中/lib/required/所
设计模式之装饰器模式Decorator（结构型）漂泊一剑客 Decorator
1. 概述若你从事过面向对象开发，实现给一个类或对象增加行为，使用继承机制，这是所有面向对象语言的一个基本特性。如果已经存在的一个类缺少某些方法，或者须要给方法添加更多的功能（魅力），你也许会仅仅继承这个类来产生一个新类—这建立在额外的代码上。
读取磁盘文件txt，并输入String 一炮送你回车库 String
public static void main(String[] args) throws IOException { String fileContent = readFileContent("d:/aaa.txt"); System.out.println(fileContent);
js三级联动下拉框 3213213333332132 三级联动
//三级联动省/直辖市<select id="province"></select> 市/省直辖<select id="city"></select> 县/区 <select id="area"></select>
erlang之parse_transform编译选项的应用 616050468 parse_transform 游戏服务器属性同步 abstract_code
最近使用erlang重构了游戏服务器的所有代码，之前看过C++/lua写的服务器引擎代码，引擎实现了玩家属性自动同步给前端和增量更新玩家数据到数据库的功能，这也是现在很多游戏服务器的优化方向，在引擎层面去解决数据同步和数据持久化，数据发生变化了业务层不需要关心怎么去同步给前端。由于游戏过程中玩家每个业务中玩家数据更改的量其实是很少
JAVA JSON的解析 darkranger java
// { // “Total”：“条数”， // Code: 1, // // “PaymentItems”:[ // { // “PaymentItemID”:”支款单ID”, // “PaymentCode”:”支款单编号”, // “PaymentTime”:”支款日期”, // ”ContractNo”:”合同号”， //
POJ-1273-Drainage Ditches aijuans ACM_POJ
POJ-1273-Drainage Ditches http://poj.org/problem?id=1273 基本的最大流，按LRJ的白书写的 #include<iostream> #include<cstring> #include<queue> using namespace std; #define INF 0x7fffffff int ma
工作流Activiti5表的命名及含义 atongyeye 工作流 Activiti
activiti5 - http://activiti.org/designer/update在线插件安装 activiti5一共23张表 Activiti的表都以ACT_开头。第二部分是表示表的用途的两个字母标识。用途也和服务的API对应。 ACT_RE_*: 'RE'表示repository。这个前缀的表包含了流程定义和流程静态资源（图片，规则，等等）。 A
android的广播机制和广播的简单使用百合不是茶 android 广播机制广播的注册
Android广播机制简介在Android中，有一些操作完成以后，会发送广播，比如说发出一条短信，或打出一个电话，如果某个程序接收了这个广播，就会做相应的处理。这个广播跟我们传统意义中的电台广播有些相似之处。之所以叫做广播，就是因为它只负责“说”而不管你“听不听”，也就是不管你接收方如何处理。另外，广播可以被不只一个应用程序所接收，当然也可能不被任何应
Spring事务传播行为详解 bijian1013 java spring 事务传播行为
在service类前加上@Transactional，声明这个service所有方法需要事务管理。每一个业务方法开始时都会打开一个事务。 Spring默认情况下会对运行期例外(RunTimeException)进行事务回滚。这
eidtplus operate 征客丶 eidtplus
开启列模式: Alt+C 鼠标选择 OR Alt+鼠标左键拖动列模式替换或复制内容(多行): 右键-->格式-->填充所选内容-->选择相应操作 OR Ctrl+Shift+V(复制多行数据,必须行数一致) -------------------------------------------------------
【Kafka一】Kafka入门 bit1129 kafka
这篇文章来自Spark集成Kafka(http://bit1129.iteye.com/blog/2174765)，这里把它单独取出来，作为Kafka的入门吧下载Kafka http://mirror.bit.edu.cn/apache/kafka/0.8.1.1/kafka_2.10-0.8.1.1.tgz 2.10表示Scala的版本，而0.8.1.1表示Kafka
Spring 事务实现机制 BlueSkator spring 代理事务
Spring是以代理的方式实现对事务的管理。我们在Action中所使用的Service对象，其实是代理对象的实例，并不是我们所写的Service对象实例。既然是两个不同的对象，那为什么我们在Action中可以象使用Service对象一样的使用代理对象呢？为了说明问题，假设有个Service类叫AService，它的Spring事务代理类为AProxyService，AService实现了一个接口
bootstrap源码学习与示例：bootstrap-dropdown（转帖） BreakingBad bootstrap dropdown
bootstrap-dropdown组件是个烂东西，我读后的整体感觉。一个下拉开菜单的设计： <ul class="nav pull-right"> <li id="fat-menu" class="dropdown">
读《研磨设计模式》-代码笔记-中介者模式-Mediator bylijinnan java 设计模式
声明：本文只为方便我个人查阅和理解，详细的分析以及源代码请移步原作者的博客http://chjavach.iteye.com/ /* * 中介者模式（Mediator）：用一个中介对象来封装一系列的对象交互。 * 中介者使各对象不需要显式地相互引用，从而使其耦合松散，而且可以独立地改变它们之间的交互。 * * 在我看来，Mediator模式是把多个对象（
常用代码记录 chenjunt3 UI Excel J#
1、单据设置某行或某字段不能修改 //i是行号,"cash"是字段名称 getBillCardPanelWrapper().getBillCardPanel().getBillModel().setCellEditable(i, "cash", false); //取得单据表体所有项用以上语句做循环就能设置整行了 getBillC
搜索引擎与工作流引擎 comsci 算法工作搜索引擎网络应用
最近在公司做和搜索有关的工作，(只是简单的应用开源工具集成到自己的产品中)工作流系统的进一步设计暂时放在一边了，偶然看到谷歌的研究员吴军写的数学之美系列中的搜索引擎与图论这篇文章中的介绍，我发现这样一个关系(仅仅是猜想) -----搜索引擎和流程引擎的基础--都是图论，至少像在我在JWFD中引擎算法中用到的是自定义的广度优先
oracle Health Monitor daizj oracle Health Monitor
About Health Monitor Beginning with Release 11g, Oracle Database includes a framework called Health Monitor for running diagnostic checks on the database. About Health Monitor Checks Health M
JSON字符串转换为对象 dieslrae java json
作为前言,首先是要吐槽一下公司的脑残编译部署方式,web和core分开部署本来没什么问题,但是这丫居然不把json的包作为基础包而作为web的包,导致了core端不能使用,而且我们的core是可以当web来用的(不要在意这些细节),所以在core中处理json串就是个问题.没办法,跟编译那帮人也扯不清楚,只有自己写json的解析了.
C语言学习八结构体，综合应用，学生管理系统 dcj3sjt126com C语言
实现功能的代码： # include <stdio.h> # include <malloc.h> struct Student { int age; float score; char name[100]; }; int main(void) { int len; struct Student * pArr; int i,
vagrant学习笔记 dcj3sjt126com vagrant
想了解多主机是如何定义和使用的, 所以又学习了一遍vagrant 1. vagrant virtualbox 下载安装 https://www.vagrantup.com/downloads.html https://www.virtualbox.org/wiki/Downloads 查看安装在命令行输入vagrant 2.
14.性能优化-优化-软件配置优化 frank1234 软件配置性能优化
1.Tomcat线程池修改tomcat的server.xml文件： <Connector port="8080" protocol="HTTP/1.1" connectionTimeout="20000" redirectPort="8443" maxThreads="1200" m
一个不错的shell 脚本教程入门级 HarborChung linux shell
一个不错的shell 脚本教程入门级建立一个脚本　　Linux中有好多中不同的shell，但是通常我们使用bash (bourne again shell) 进行shell编程，因为bash是免费的并且很容易使用。所以在本文中笔者所提供的脚本都是使用bash（但是在大多数情况下，这些脚本同样可以在 bash的大姐，bourne shell中运行）。　　如同其他语言一样
Spring4新特性——核心容器的其他改进 jinnianshilongnian spring 动态代理 spring4 依赖注入
Spring4新特性——泛型限定式依赖注入 Spring4新特性——核心容器的其他改进 Spring4新特性——Web开发的增强 Spring4新特性——集成Bean Validation 1.1(JSR-349)到SpringMVC Spring4新特性——Groovy Bean定义DSL Spring4新特性——更好的Java泛型操作API Spring4新
Linux设置tomcat开机启动 liuxingguome tomcat linux 开机自启动
执行命令sudo gedit /etc/init.d/tomcat6 然后把以下英文部分复制过去。（注意第一句#!/bin/sh如果不写，就不是一个shell文件。然后将对应的jdk和tomcat换成你自己的目录就行了。 #!/bin/bash # # /etc/rc.d/init.d/tomcat # init script for tomcat precesses
第13章 Ajax进阶（下） onestopweb Ajax
index.html <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"> <html xmlns="http://www.w3.org/
Troubleshooting Crystal Reports off BW blueoxygen BO
http://wiki.sdn.sap.com/wiki/display/BOBJ/Troubleshooting+Crystal+Reports+off+BW#TroubleshootingCrystalReportsoffBW-TracingBOE Quite useful, especially this part: SAP BW connectivity For t
Java开发熟手该当心的11个错误 tomcat_oracle java jvm 多线程单元测试
#1、不在属性文件或XML文件中外化配置属性。比如，没有把批处理使用的线程数设置成可在属性文件中配置。你的批处理程序无论在DEV环境中，还是UAT（用户验收测试）环境中，都可以顺畅无阻地运行，但是一旦部署在PROD 上，把它作为多线程程序处理更大的数据集时，就会抛出IOException，原因可能是JDBC驱动版本不同，也可能是#2中讨论的问题。如果线程数目可以在属性文件中配置，那么使它成为
正则表达式大全 yang852220741 html 编程正则表达式
今天向大家分享正则表达式大全，它可以大提高你的工作效率正则表达式也可以被当作是一门语言，当你学习一门新的编程语言的时候，他们是一个小的子语言。初看时觉得它没有任何的意义，但是很多时候，你不得不阅读一些教程，或文章来理解这些简单的描述模式。一、校验数字的表达式数字：^[0-9]*$ n位的数字：^\d{n}$ 至少n位的数字：^\d{n,}$ m-n位的数字：^\d{m,n}$