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
统一思想认识永夜-极光思想
1.统一思想认识的基础,才能有的放矢原因: 总有一种描述事物的方式最贴近本质,最容易让人理解. 如何让教育更轻松,在于找到最适合学生的方式. 难点在于,如何模拟对方的思维基础选择合适的方式. &
Joda Time使用笔记 bylijinnan java joda time
Joda Time的介绍可以参考这篇文章： http://www.ibm.com/developerworks/cn/java/j-jodatime.html 工作中也常常用到Joda Time，为了避免每次使用都查API，记录一下常用的用法： /** * DateTime变化（增减） */ @Tes
FileUtils API eksliang FileUtils FileUtils API
转载请出自出处：http://eksliang.iteye.com/blog/2217374 一、概述这是一个Java操作文件的常用库，是Apache对java的IO包的封装，这里面有两个非常核心的类FilenameUtils跟FileUtils，其中FilenameUtils是对文件名操作的封装;FileUtils是文件封装，开发中对文件的操作，几乎都可以在这个框架里面找到。非常的好用。
各种新兴技术不懂事的小屁孩技术
1:gradle Gradle 是以 Groovy 语言为基础，面向Java应用为主。基于DSL（领域特定语言）语法的自动化构建工具。现在构建系统常用到maven工具，现在有更容易上手的gradle，搭建java环境: http://www.ibm.com/developerworks/cn/opensource/os-cn-gradle/ 搭建android环境： http://m
tomcat6的https双向认证酷的飞上天空 tomcat6
1.生成服务器端证书 keytool -genkey -keyalg RSA -dname "cn=localhost,ou=sango,o=none,l=china,st=beijing,c=cn" -alias server -keypass password -keystore server.jks -storepass password -validity 36
托管虚拟桌面市场势不可挡蓝儿唯美
用户还需要冗余的数据中心，dinCloud的高级副总裁兼首席营销官Ali Din指出。该公司转售一个MSP可以让用户登录并管理和提供服务的用于DaaS的云自动化控制台，提供服务或者MSP也可以自己来控制。在某些情况下，MSP会在dinCloud的云服务上进行服务分层，如监控和补丁管理。 MSP的利润空间将根据其参与的程度而有所不同，Din说。 “我们有一些合作伙伴负责将我们推荐给客户作为个
spring学习——xml文件的配置 a-john spring
在Spring的学习中，对于其xml文件的配置是必不可少的。在Spring的多种装配Bean的方式中，采用XML配置也是最常见的。以下是一个简单的XML配置文件： <?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.or
HDU 4342 History repeat itself 模拟 aijuans 模拟
来源：http://acm.hdu.edu.cn/showproblem.php?pid=4342 题意：首先让求第几个非平方数，然后求从1到该数之间的每个sqrt(i)的下取整的和。思路：一个简单的模拟题目，但是由于数据范围大，需要用__int64。我们可以首先把平方数筛选出来，假如让求第n个非平方数的话，看n前面有多少个平方数，假设有x个，则第n个非平方数就是n+x。注意两种特殊情况，即
java中最常用jar包的用途 asia007 java
java中最常用jar包的用途 jar包用途axis.jarSOAP引擎包commons-discovery-0.2.jar用来发现、查找和实现可插入式接口，提供一些一般类实例化、单件的生命周期管理的常用方法.jaxrpc.jarAxis运行所需要的组件包saaj.jar创建到端点的点到点连接的方法、创建并处理SOAP消息和附件的方法，以及接收和处理SOAP错误的方法. w
ajax获取Struts框架中的json编码异常和Struts中的主控制器异常的解决办法百合不是茶 js json编码返回异常
一:ajax获取自定义Struts框架中的json编码出现以下问题: 1,强制flush输出 json编码打印在首页 2, 不强制flush js会解析json 打印出来的是错误的jsp页面却没有跳转到错误页面 3, ajax中的dataType的json 改为text 会
JUnit使用的设计模式 bijian1013 java 设计模式 JUnit
JUnit源代码涉及使用了大量设计模式 1、模板方法模式（Template Method）定义一个操作中的算法骨架，而将一些步骤延伸到子类中去，使得子类可以不改变一个算法的结构，即可重新定义该算法的某些特定步骤。这里需要复用的是算法的结构，也就是步骤，而步骤的实现可以在子类中完成。
Linux常用命令（摘录） sunjing crond chkconfig
chkconfig --list 查看linux所有服务 chkconfig --add servicename 添加linux服务 netstat -apn | grep 8080 查看端口占用 env 查看所有环境变量 echo $JAVA_HOME 查看JAVA_HOME环境变量安装编译器 yum install -y gcc
【Hadoop一】Hadoop伪集群环境搭建 bit1129 hadoop
结合网上多份文档，不断反复的修正hadoop启动和运行过程中出现的问题，终于把Hadoop2.5.2伪分布式安装起来，跑通了wordcount例子。Hadoop的安装复杂性的体现之一是，Hadoop的安装文档非常多，但是能一个文档走下来的少之又少，尤其是Hadoop不同版本的配置差异非常的大。Hadoop2.5.2于前两天发布，但是它的配置跟2.5.0，2.5.1没有分别。 &nb
Anychart图表系列五之事件监听白糖_ chart
创建图表事件监听非常简单：首先是通过addEventListener('监听类型',js监听方法)添加事件监听，然后在js监听方法中定义具体监听逻辑。以钻取操作为例，当用户点击图表某一个point的时候弹出point的name和value，代码如下： <script> //创建AnyChart var chart = new AnyChart(); //添加钻取操作&quo
Web前端相关段子 braveCS web前端
Web标准：结构、样式和行为分离使用语义化标签 0）标签的语义：使用有良好语义的标签，能够很好地实现自我解释，方便搜索引擎理解网页结构，抓取重要内容。去样式后也会根据浏览器的默认样式很好的组织网页内容，具有很好的可读性，从而实现对特殊终端的兼容。 1）div和span是没有语义的：只是分别用作块级元素和行内元素的区域分隔符。当页面内标签无法满足设计需求时，才会适当添加div
编程之美-24点游戏 bylijinnan 编程之美
import java.util.ArrayList; import java.util.Arrays; import java.util.HashSet; import java.util.List; import java.util.Random; import java.util.Set; public class PointGame { /**编程之美
主页面子页面传值总结 chengxuyuancsdn 总结
1、showModalDialog returnValue是javascript中html的window对象的属性,目的是返回窗口值,当用window.showModalDialog函数打开一个IE的模式窗口时,用于返回窗口的值主界面 var sonValue=window.showModalDialog("son.jsp"); 子界面 window.retu
[网络与经济]互联网+的含义 comsci 互联网+
互联网+后面是一个人的名字 = 网络控制系统互联网+你的名字 = 网络个人数据库每日提示:如果人觉得不舒服,千万不要外出到处走动,就呆在床上,玩玩手游,更不能够去开车,现在交通状况不
oracle 创建视图 with check option daizj 视图 view oralce
我们来看下面的例子： create or replace view testview as select empno,ename from emp where ename like ‘M%’ with check option; 这里我们创建了一个视图，并使用了with check option来限制了视图。然后我们来看一下视图包含的结果： select * from testv
ToastPlugin插件在cordova3.3下使用 dibov Cordova
自己开发的Todos应用，想实现“ 再按一次返回键退出程序 ”的功能，采用网上的ToastPlugins插件，发现代码或文章基本都是老版本，运行问题比较多。折腾了好久才弄好。下面吧基于cordova3.3下的ToastPlugins相关代码共享。 ToastPlugin.java package&nbs
C语言22个系统函数 dcj3sjt126com c function
C语言系统函数一、数学函数下列函数存放在math.h头文件中Double floor(double num) 求出不大于num的最大数。Double fmod(x, y) 求整数x/y的余数。Double frexp(num, exp); double num; int *exp; 将num分为数字部分（尾数）x和以2位的指数部分n，即num=x*2n，指数n存放在exp指向的变量中，返回x。D
开发一个类的流程 dcj3sjt126com 开发
本人近日根据自己的开发经验总结了一个类的开发流程。这个流程适用于单独开发的构件，并不适用于对一个项目中的系统对象开发。开发出的类可以存入私人类库，供以后复用。以下是开发流程： 1. 明确类的功能，抽象出类的大概结构 2. 初步设想类的接口 3. 类名设计（驼峰式命名） 4. 属性设置(权限设置) 判断某些变量是否有必要作为成员属
java 并发 shuizhaosi888 java 并发
能够写出高伸缩性的并发是一门艺术在JAVA SE5中新增了3个包 java.util.concurrent java.util.concurrent.atomic java.util.concurrent.locks 在java的内存模型中，类的实例字段、静态字段和构成数组的对象元素都会被多个线程所共享，局部变量与方法参数都是线程私有的，不会被共享。
Spring Security（11）——匿名认证 234390216 Spring Security ROLE_ANNOYMOUS 匿名
匿名认证目录 1.1 配置 1.2 AuthenticationTrustResolver 对于匿名访问的用户，Spring Security支持为其建立一个匿名的AnonymousAuthenticat
NODEJS项目实践0.2[ express,ajax通信...] 逐行分析JS源代码 Ajax nodejs express
一、前言通过上节学习，我们已经 ubuntu系统搭建了一个可以访问的nodejs系统，并做了nginx转发。本节原要做web端服务及 mongodb的存取，但写着写着，web端就
在Struts2 的Action中怎样获取表单提交上来的多个checkbox的值 lhbthanks java html struts checkbox
第一种方法：获取结果String类型在 Action 中获得的是一个 String 型数据，每一个被选中的 checkbox 的 value 被拼接在一起，每个值之间以逗号隔开(,)。所以在 Action 中定义一个跟 checkbox 的 name 同名的属性来接收这些被选中的 checkbox 的 value 即可。以下是实现的代码：前台 HTML 代码：
003.Kafka基本概念 nweiren hadoop kafka
Kafka基本概念：Topic、Partition、Message、Producer、Broker、Consumer。 Topic：消息源（Message）的分类。 Partition： Topic物理上的分组，一
Linux环境下安装JDK roadrunners jdk linux
1、准备工作创建JDK的安装目录： mkdir -p /usr/java/ 下载JDK，找到适合自己系统的JDK版本进行下载： http://www.oracle.com/technetwork/java/javase/downloads/index.html 把JDK安装包下载到/usr/java/目录，然后进行解压： tar -zxvf jre-7
Linux忘记root密码的解决思路 tomcat_oracle linux
1：使用同版本的linux启动系统，chroot到忘记密码的根分区passwd改密码　　2：grub启动菜单中加入init=/bin/bash进入系统，不过这时挂载的是只读分区。根据系统的分区情况进一步判断. 　　3: grub启动菜单中加入 single以单用户进入系统. 　　4:用以上方法mount到根分区把/etc/passwd中的root密码去除　　例如: 　　ro
跨浏览器 HTML5 postMessage 方法以及 message 事件模拟实现 xueyou jsonp jquery 框架 UI html5
postMessage 是 HTML5 新方法，它可以实现跨域窗口之间通讯。到目前为止，只有 IE8+, Firefox 3, Opera 9, Chrome 3和 Safari 4 支持，而本篇文章主要讲述 postMessage 方法与 message 事件跨浏览器实现。postMessage 方法 JSONP 技术不一样，前者是前端擅长跨域文档数据即时通讯，后者擅长针对跨域服务端数据通讯，p