秒杀系统高并发

最新推荐文章于 2024-05-16 09:23:57 发布
最新推荐文章于 2024-05-16 09:23:57 发布
阅读量511 收藏 2
点赞数
分类专栏： java 文章标签： nginx redis tomcat
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41024497/article/details/103877890
版权

Java电商秒杀系统深度优化

Tomcat瓶颈

不优化前，tomcat最大线程数阻碍了系统的最大并发
1. 使用spring Boot内置的Tomcat 在 application.yml中添加
* server.tomcat.accpt-count :等待队列长度，默认100
* server.tomcat.max-connections:最大可连接数，默认10000
* server.tomcat.max-threads:最大工作线程数，默认200
* server.tomcat.min-spare-threads: 最小工作线程数，默认10
- 默认配置下，连接超过10000后会出现拒绝连接情况
- 默认配置下，触发的请求超过200 + 100后会拒绝处理
2. 使用外挂Tomcat
keepAlive 是在http 1.1 中 使用长连接，可能会被黑客利用
keepAliveTimeOut:多少秒后不响应的断开keepalive
maxKeepAliveRequests:多少次请求后keepalive断开失效
使用WebServerFactoryCustomizer < ConfigurableServletWebServerFactory > 定制化内嵌tomcat配置


import org.apache.catalina.connector.Connector;
import org.apache.coyote.http11.Http11NioProtocol;
import org.springframework.boot.web.embedded.tomcat.TomcatConnectorCustomizer;
import org.springframework.boot.web.embedded.tomcat.TomcatServletWebServerFactory;
import org.springframework.boot.web.server.ConfigurableWebServerFactory;
import org.springframework.boot.web.server.WebServerFactoryCustomizer;
import org.springframework.stereotype.Component;

//当spring 容器中没有tomcatEmaeddedServletContainerFactory 这个bean时，会把此bean加载进spring
@Component
public class WebServerConfiguration implements WebServerFactoryCustomizer<ConfigurableWebServerFactory> {


    @Override
    public void customize(ConfigurableWebServerFactory factory) {
//使用对应工厂类提供给我们的接口定制化我们的Tomcat connector


        ( (TomcatServletWebServerFactory)factory ).addConnectorCustomizers(new TomcatConnectorCustomizer() {
            @Override
            public void customize(Connector connector) {
              Http11NioProtocol protocol = (Http11NioProtocol) connector.getProtocolHandler();
//                定制化keepalivetimeout  这是30秒内没有请求则服务器自动断开keepalive链接
              protocol.setKeepAliveTimeout(3000);
//              当客户端发送超过10000个请求 ，则自动断开keepalive
              protocol.setMaxKeepAliveRequests(1000);
         
            }
        });
    }
}
  1. 单web容器上限
  线程数量 ： 4核Cpu 8G内存单进程调度数800-1000以上即花费巨大的时间在cpu调度上
  等待队列长度 ： 队列做缓冲池用，但也不能无限长，消耗内存，出对，入队也耗cpu
  1. mysql 数据库
    mysql数据库QPS容量问题
    主键查询： 千万级别数据 = 1-10毫秒
    唯一索引查询：千万级别数据 = 10-100毫秒
    非唯一索引查询： 千万级别数据 = 100-1000毫秒
    无索引：百万条数据 = 1000毫秒+

分布式扩展

nginx
1.  单机容量问题 ，水平扩展
表象：单机cpu使用率增高，memory占用增加，网络带宽使用增加
CPU us ：用户空间的cpu使用情况（用户层代码）
cpu  sy ：内核空间的cpu使用情况 系统调用
load avarage ：1,5,15 分钟load平均值，跟着核数系数，0代表通常 ，代表打满 1+代表等待阻塞
memory ： free 空闲内存 used 使用内存

在这里插入图片描述

2.  nginx web服务器
location 节点path : 指定url映射key
location 节点内容： root 指定location path后对应的跟路径，index 指定默认的访问页
sbin/nginx -c conf/nginx.conf启动
修改配置后直接sbin/nginx -s reload无缝重启 
3.  nginx 做反向代理服务器
  设置upstream  server
  设置动态请求location为proxy pass 路径
  开启tomcat access log 验证
   设置 nginx 与tomcat keepAlive为长连接 ：
    *   keepalive_timeout 60 ;
    *   proxy_http_version 1.1;
    * proxy_set_header Connection "";

4 . nginx 高性能原因 
	1. epoll 多路复用
	 * java bio 模型，阻塞进程式
	 * linux select模型，变更触发轮训查找，有1024数量上限
		-  java server监听客户端链接，如果某个连接有变化，遍历所有的链接，找到发送变化的一个或者多个，然后执行read操作
	 * epoll模型，变更触发回调直接读取，理论上无上限
    	- java server 监听客户端链接，是否有变化，设置回调函数，若有变化则直接唤醒自己并执行回调函数
	2. master worker 进程模式
	3. 协程机制
	* 依附于线程的内存模型，切换开销小
	* 遇阻塞及归还执行权，代码同步
	* 无需加锁
会话管理

基于cookie 传输sessionid ：java tomcat容器session实现迁移到redis
基于token传输类似sessionid :java 代码ssession 实现迁移到redis

查询优化之多级缓存

缓存设计

多级缓存
  1. redis 缓存
    redis sentinal redis 哨兵机制
    在这里插入图片描述
    集群cluster模式
    在这里插入图片描述
    任何一台redis服务器都知道其他redis服务器的状态，当我的 集群中有超过一半的节点存活的话，我对应的集群就任然是可以工作的，项目只需要连接集群中的任意一台服务器就可以知道其他服务器的状态。
    当集群发生变化，其中一台服务器崩溃了，所有的内部分片会全部调整，都保持最新的状态，项目按照错误的列表发送给对应节点，如果发现不是调整之后的数据，会直接返回一个reask请求拉取最新的状态
    jedis中已经集成了
  • 商品详情动态内容实现
    使用redis将数据进行缓存，将key和value使用自己的方式进行序列化。
import org.springframework.context.annotation.Bean;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;
import org.springframework.session.data.redis.config.annotation.web.http.EnableRedisHttpSession;
import org.springframework.stereotype.Component;

@Component
@EnableRedisHttpSession(maxInactiveIntervalInSeconds = 3600)
public class RedisConfig {

    @Bean
    public RedisTemplate redisTemplate(RedisConnectionFactory redisConnectionFactory) {
        RedisTemplate redisTemplate = new RedisTemplate();
        redisTemplate.setConnectionFactory(redisConnectionFactory);
//    修改redis序列化方式
//    首先解决key 的序列化方式
        StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
        redisTemplate.setKeySerializer(stringRedisSerializer);
//解决value的序列化方式
        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
        redisTemplate.setValueSerializer(jackson2JsonRedisSerializer);
        return redisTemplate;
    }
}
  1. 热点内存本地缓存
    热点数据
    脏读非常不敏感
    内存可控
    • Guava cache
      • 可控制大小和超时时间
      • 可配置的lru策略
      • 线程安全
import com.google.common.cache.Cache;
import com.google.common.cache.CacheBuilder;
import com.imooc.miaoshaproject.service.CachService;
import org.springframework.stereotype.Service;

import javax.annotation.PostConstruct;
import java.util.concurrent.TimeUnit;

@Service
public class CachServiceImpl implements CachService {
    private Cache<String, Object> commonCache = null;

    @PostConstruct
    public void init() {
//    设置缓存容器的初始容量为10
        commonCache = CacheBuilder.newBuilder()
                .initialCapacity(10)
                .maximumSize(100)//设置缓存中最大可以存储100个key，超过100个之后会按照LRU的策略移除缓存项目
//设置写缓存后多少秒过期
                .expireAfterWrite(60, TimeUnit.SECONDS)
                .build();
    }

    @Override
    public void serCommonCache(String key, Object value) {
        commonCache.put(key,value);
    }
    @Override
    public Object getFromCommonCache(String key) {
       return commonCache.getIfPresent(key);

    }
}
  1. nginx proxy cache缓存

nginx反向代理前置
依靠文件系统存索引级的文件
依靠内存缓存文件地址
申明一个cache缓存节点的内容

proxy_cache_path /usr/local/openresty/nginx/tem_cache levels=1:2 keys_zone=tmp_cache:100m inactive=7d max_size=10g;
proxy_cache tem_cache;
proxy_cache_key $uri;
proxy_cache_valid 200 206 304 7d;
数据是从本地磁盘中读取，不如内存中快，并不推荐
6. nginx lua缓存
lua协程机制

function foo(a)
    print("foo 函数输出", a)
    return coroutine.yield(2 * a) -- 返回2*a的值
end

co = coroutine.create(function(a, b)
    print("第一次协同程序输出", a, b)
    local r = foo(a + 1)
    print("第二次协同程序输出", r)
    local r, s = coroutine.yield(a + b, a - b) --a ,b 的值为第一次调用协同程序是传入
    print("第三次协同程序输出", r, s) -- b的值为第二次调用协同程序时传入
    return b, "结束协同程序"
end)

print("main",coroutine.resume(co,1,10))
print("------------------")
print("main",coroutine.resume(co,"r"))
print("------------------")
print("main",coroutine.resume(co,"x","y"))
print("------------------")
print("main",coroutine.resume(co,"x","y"))

nginx协程机制

  1. ngixn 的每个worker进程都只在epoll或kqueue这种时间模型之上，封装成协程。
  2. 每个请求都有一个协程进行处理
  3. 即使ngx_lua需要运行lua，相对c有一定的开销，但依旧能保证高并发能力
  • nginx每个工作进程创建一个lua虚拟机
  • 工作进程内的所有协程共享一个vm
  • 每个外部请求由一个lua协程处理，之间数据隔离
  • lua代码调用io等异步接口时，协程被挂起，上下文数据
  • 自动保存，不阻塞工作进程
  • io异步操作完成后还原协程上下文，代码继续执行

  1. nginx 处理阶段

1） ngx_http_post_read_phase：

接收到完整的http头部后处理的阶段，它位于uri重写之前，实际上很少有模块会注册在该阶段，默认的情况下，该阶段被跳过。

2）ngx_http_server_rewrite_phase：

uri与location匹配前，修改uri的阶段，用于重定向，也就是该阶段执行处于server块内，location块外的重写指令，在读取请求头的过程中nginx会根据host及端口找到对应的虚拟主机配置。

3）ngx_http_find_config_phase：

根据uri寻找匹配的location块配置项阶段，该阶段使用重写之后的uri来查找对应的location，值得注意的是该阶段可能会被执行多次，因为也可能有location级别的重写指令。

4）ngx_http_rewrite_phase：

上一阶段找到location块后再修改uri，location级别的uri重写阶段，该阶段执行location基本的重写指令，也可能会被执行多次。

5）ngx_http_post_rewrite_phase：

防止重写url后导致的死循环，location级别重写的后一阶段，用来检查上阶段是否有uri重写，并根据结果跳转到合适的阶段。

6）ngx_http_preaccess_phase：

下一阶段之前的准备，访问权限控制的前一阶段，该阶段在权限控制阶段之前，一般也用于访问控制，比如限制访问频率，链接数等。

7）ngx_http_access_phase：

让http模块判断是否允许这个请求进入nginx服务器，访问权限控制阶段，比如基于ip黑白名单的权限控制，基于用户名密码的权限控制等。

8）ngx_http_post_access_phase：

访问权限控制的后一阶段，该阶段根据权限控制阶段的执行结果进行相应处理，向用户发送拒绝服务的错误码，用来响应上一阶段的拒绝。

9）ngx_http_try_files_phase：

为访问静态文件资源而设置，try_files指令的处理阶段，如果没有配置try_files指令，则该阶段被跳过。

10）ngx_http_content_phase：

处理http请求内容的阶段，大部分http模块介入这个阶段，内容生成阶段，该阶段产生响应，并发送到客户端。

11）ngx_http_log_phase：

处理完请求后的日志记录阶段，该阶段记录访问日志。
http无法介入的阶段有4个：

3）ngx_http_find_config_phase

5）ngx_http_post_rewrite_phase

8）ngx_http_post_access_phase

9）ngx_http_try_files_phase

剩余的7个阶段，http模块均能介入，每个阶段可介入模块的个数也是没有限制的，多个http模块可同时介入同一阶段并作用于同一请求。

nginx lua 插载点

init_by_lua: 系统启动时调用
init_worker_by_lua: worker 进程启动时调用
set_by_lua ： nginx变量用复杂lua return
rewrite_by_lua: 重写url规则
access_by_lua: 权限验证阶段
content_by_lua: 内容输出节点
使用lua脚本返回数据
location /miaosha/get{
default_type “text/html”
content_by_lua_file …/lua/staticitem.lua;
}
staticitem.lua

ngx.say("hello static item lua")

openResty

  1. openResty由Nginx核心加很多第三方模块组成，默认集成了lua开发环境，是的nginx可以作为一个 Web Server使用。
  2. 借助于Nginx的时间驱动模型和非阻塞IO，可以实现高性能的Web应用程序。
  3. OpenResty 提供了大量组件如Mysql 、Redis、Memcached等等、使在Nginx上开发Web应用更简单方便。

OpenResty 实践

function get_from_cache(key)

    local cache_ngx = ngx.shared.my_cache
    local value = cache_ngx:get(key)
    return value
end
function set_to_cache(key, value, exptime)

    if not exptimed then
        exptime = 0
    end
    local cache_ngx = ngx.shared.my_cache
    local succ, err, forcible = cache_ngx:set(key, value, exptime)
    return succ
end

local args = ngx.req.get_uri_args();
local id = args["id"]
local item_model = get_from_cache("item_" .. id)
if item_model == nil then
    local resp = ngx.location.capture("/item/get?id="..id)
    item_model = resp.body
    set_to_cache("item_"..id,item_model,1*60)
end
ngx.say(item_model)

使用openresty中的redis模块连接redis

local args = ngx.req.get_uri_args()
local id = args["id"]
local redis = require "resty.redis"
local cache = redis:new()
local ok, err = cache:connect("11.11.11.11", 6379)
local item_model = cache:get("item" .. id)
if item_model == ngx.null or item_model == nil then
   local resp = ngx.location.capture("/item/get?id=" .. id)
   item_model = resp.body
   
end
ngx.say(item_model)

CDN

DNS 用CNAME解析到源站
回源缓存设置
强推失效

全页面静态化

定义:在服务端完成html，css，甚至js的load渲染成纯html 文件后直接以静态资源的方式部署到cdn上
phantomjs

交易优化技术之缓存库存

在这里插入图片描述

交易验证优化

  1. 用户风控策略优化：策略缓存模型化
  2. 活动校验策略优化：映入活动发布流程，模型缓存化，紧急下线能力

扣减库存缓存化
方案：

  1. 活动发布同步库存进缓存
  2. 下单交易减缓存库缓存
  3. 异步消息扣减数据库内库存
  • 问题
  1. 数据库记录不一致

流量削峰技术

  1. 抛缺陷
    • 秒杀下单接口会被脚本不停的刷
    • 秒杀验证逻辑和秒杀下单接口强关联，代码冗余度高
  2. 秒杀令牌原理
    • 秒杀接口需要依靠令牌才能进入
    • 秒杀的令牌由活动模块负责生产
    • 秒杀活动模块对秒杀令牌生产全权处理，逻辑收口
  3. 秒杀大闸原理
    1. 依靠秒杀令牌的授权原理定制化发牌逻辑，做到大闸功能
    2. 根据秒杀商品初始库存颁发对应数量的令牌，控制大闸流量
    3. 用户风控策略前置到秒杀令牌发放中
    4. 库存售尽判断前置到秒杀令牌发放中
    5. 缺陷：
      浪涌流量涌入后系统无法应对
      多库存，多商品等令牌限制能力弱
  4. 队列泄洪原理
    1. 排队有些时候比并发更高效（列如redis单线程模型，innodb mutex key 等待）
    2. 依靠排队去限制并发流量
    3. 依靠排队和下游拥塞窗口程度调整队列释放流量大小
    4. 支付宝银行网关队列举例

防刷限流技术

  1. 掌握验证码生成与验证技术
    1. 包装秒杀令牌前置，需要验证码来错峰
    2. 数学公式验证码生成器
	import java.awt.Color;
import java.awt.Font;
import java.awt.Graphics;
import java.awt.image.BufferedImage;
import java.awt.image.RenderedImage;
import java.io.FileOutputStream;
import java.io.OutputStream;
import java.util.HashMap;
import java.util.Map;
import java.util.Random;

import javax.imageio.ImageIO;

public class CodeUtil {
    private static int width = 90;// 定义图片的width
    private static int height = 20;// 定义图片的height
    private static int codeCount = 4;// 定义图片上显示验证码的个数
    private static int xx = 15;
    private static int fontHeight = 18;
    private static  int codeY = 16;
    private static char[] codeSequence = { 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R',
            'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9' };

    /**
     * 生成一个map集合
     * code为生成的验证码
     * codePic为生成的验证码BufferedImage对象
     * @return
     */
    public static Map<String,Object> generateCodeAndPic() {
        // 定义图像buffer
        BufferedImage buffImg = new BufferedImage(width, height, BufferedImage.TYPE_INT_RGB);
        // Graphics2D gd = buffImg.createGraphics();
        // Graphics2D gd = (Graphics2D) buffImg.getGraphics();
        Graphics gd = buffImg.getGraphics();
        // 创建一个随机数生成器类
        Random random = new Random();
        // 将图像填充为白色
        gd.setColor(Color.WHITE);
        gd.fillRect(0, 0, width, height);

        // 创建字体，字体的大小应该根据图片的高度来定。
        Font font = new Font("Fixedsys", Font.BOLD, fontHeight);
        // 设置字体。
        gd.setFont(font);

        // 画边框。
        gd.setColor(Color.BLACK);
        gd.drawRect(0, 0, width - 1, height - 1);

        // 随机产生40条干扰线，使图象中的认证码不易被其它程序探测到。
        gd.setColor(Color.BLACK);
        for (int i = 0; i < 30; i++) {
            int x = random.nextInt(width);
            int y = random.nextInt(height);
            int xl = random.nextInt(12);
            int yl = random.nextInt(12);
            gd.drawLine(x, y, x + xl, y + yl);
        }

        // randomCode用于保存随机产生的验证码，以便用户登录后进行验证。
        StringBuffer randomCode = new StringBuffer();
        int red = 0, green = 0, blue = 0;

        // 随机产生codeCount数字的验证码。
        for (int i = 0; i < codeCount; i++) {
            // 得到随机产生的验证码数字。
            String code = String.valueOf(codeSequence[random.nextInt(36)]);
            // 产生随机的颜色分量来构造颜色值，这样输出的每位数字的颜色值都将不同。
            red = random.nextInt(255);
            green = random.nextInt(255);
            blue = random.nextInt(255);

            // 用随机产生的颜色将验证码绘制到图像中。
            gd.setColor(new Color(red, green, blue));
            gd.drawString(code, (i + 1) * xx, codeY);

            // 将产生的四个随机数组合在一起。
            randomCode.append(code);
        }
        Map<String,Object> map  =new HashMap<String,Object>();
        //存放验证码
        map.put("code", randomCode);
        //存放生成的验证码BufferedImage对象
        map.put("codePic", buffImg);
        return map;
    }

    public static void main(String[] args) throws Exception {
        //创建文件输出流对象
        OutputStream out = new FileOutputStream("/Users/hzllb/Desktop/javaworkspace/miaoshaStable/"+System.currentTimeMillis()+".jpg");
        Map<String,Object> map = CodeUtil.generateCodeAndPic();
        ImageIO.write((RenderedImage) map.get("codePic"), "jpeg", out);
        System.out.println("验证码的值为："+map.get("code"));
    }
}
  1. 限流原理与实现
    1. 流量远比你想要的多
    2. 系统活着比挂了要好
    3. 宁愿只让少数人能用，也不要让所有人不用
    4. 限流方案
      1. 限并发
      2. 令牌桶算法
      private ExecutorService executorService;
private RateLimiter orderCreateRateLimiter;
@PostConstruct
public void init(){
executorService = Executors.newFixedThreadPool(20);
orderCreateRateLimiter = RateLimiter.create(300);
}




 if(orderCreateRateLimiter.acquire() <= 0){
    throw new BusinessException(EmBusinessError.RATELIMIT);
}
      1. 漏桶算法
      2. 集群限流：依赖redis或其他中间件技术锁统一计数器，往往会产生性能瓶颈
      3. 单机限流：负载均衡的前提下单机平均限流效果更好
  2. 防黄牛技术
我找点事
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
PHP秒杀系统 高并发高性能的极致挑战-
11-07
秒杀系统在各种网站和应用中经常会用到。本课程从基本的系统设计和基础功能开始教导大家用PHP来设计和实现秒杀系统，并且为海量并发提供更高级的技术方案和实现手段。
PHP秒杀系统 高并发高性能的极致挑战完整版的-可以解压的
11-18
PHP秒杀系统 高并发高性能的极致挑战完整版的，分享给大家，一起学习
实现高并发秒杀的七种方式
最新发布
Wewe的博客
05-16 346
高并发场景在现场的日常工作中很常见，特别是在互联网公司中，这篇文章就来通过秒杀商品来模拟高并发的场景。文章末尾会附上文章的所有代码、脚本和测试用例。Jmeter减库存->创建订单->模拟支付。
PHP秒杀系统 高并发高性能的极致挑战（完整版）-解压不需要解压密码
04-28
PHP秒杀系统 高并发高性能的极致挑战（完整版）- 解压不需要解压密码 带项目源码
服务器上CPU飚高怎么办？
cleble的专栏
06-16 107
记一次服务器CPU高,内存高的解决
球球的博客
12-09 799
一 后台服务器问题排查步骤 java后台服务故障排除网络与硬件故障外;可能出现以下问题: 1)，CPU过高：例如gc频繁,代码循环逻辑,高并发; 2)，内存过高：例如频繁创建对象,内存泄露等这里会有俩种情况,一种报oom,一种导致系统卡,访问等待. 3)，IO过高：例如持续磁盘读写,这种情况目前还没有发生过; 4), 硬盘空间满了,这种情况一般系统访问不了;好排查; 针对以上情况我们有以下定位问题步骤 二 cpu过高 CPU过高一般是有gc频繁或代码里有循环逻辑导致; 第一步: top命令定位进程确认是哪个
PHP 高级课程 商品秒杀系统 高并发高性能
08-14
PHP商品秒杀系统 高并发高性能的极致挑战 完整视频+源码 深入基础技能 Linux / Nginx / Mysql / Redis 基础平台工具，搭配PHP原生代码 不在局限框架选择 掌握系统设计与方法 从需求分析、数据结构创建 到基础功能...
PHP秒杀系统 高并发高性能的极致挑战.txt
02-03
### PHP秒杀系统高并发高性能的极致挑战 #### 一、引言 随着互联网技术的发展，各类线上活动如秒杀、抢购等越来越受到商家和用户的欢迎。这些活动往往会在短时间内吸引大量的用户参与，这就对系统的并发处理能力...
PHP秒杀系统 高并发高性能的极致挑战（完整版）
08-03
PHP秒杀系统 高并发高性能的极致挑战（完整版） 带项目源码
秒杀系统企业级实战应用（真实工业界案例）90-91 90、秒杀系统高并发之redis集群1 92、秒杀系统高并发之redis集群
03-25
90、秒杀系统高并发之redis集群1： 这部分内容可能会涵盖Redis集群的基础知识，包括数据分片、故障转移和读写分离等关键概念。Redis集群通过将数据分散到多个节点上，实现了数据的并行处理，从而提高了处理速度。...
高并发秒杀系统
02-18
总结，这个项目展示了如何运用SSM框架和前端技术构建一个高并发的秒杀系统，涉及了从后端架构设计、数据库交互、高并发处理策略到前端用户体验等多个层面的技术要点。通过学习和实践，开发者可以提升在大型项目中的...
linux nginx+redis+tomcat分布式负载均衡生产环境部署完成
05-31
linux nginx+redis+tomcat分布式负载均衡生产环境部署完成 技术：reids集群 nginx部署 tomcat负载均衡 说明包含： nginx+redis+tomcat分布式负载均衡文档 session共享资料 安装程序 nginx+redis+tomcat分布式负载均衡部署帮助文档 nginx+redis+tomcat分布式负载均衡使用帮助文档 nginx+redis+tomcat分布式负载均衡遇到问题解决文档 linux内网环境使用；文档比较清晰，按照步骤安装即可；
Tomcat优化方案
12-10
根据jvm规范的规定，进行对tomcat的各个方面调优，希望能帮到大家。
高并发大流量秒杀方案思路
weixin_39218464的博客
06-06 623
秒杀场景一般会在电商网站举行一些活动或者节假日在12306网站上抢票时遇到。对于网站中一些稀缺或者特价的产品，电商网站一般会在约定的时间对其进行限量销售，因为这些产品的特殊性，会吸引大量用户前来抢购，并且会在约定时间同时在秒杀页面进行抢购。1）秒杀时大量用户会在同一时间同时进行抢购，网站瞬时访问量激增。 2）秒杀一般是访问请求数量远远大于库存数量，只有少部分用户能够秒杀成功 3）秒杀业务流程比较简单，一般就是下订单减库存。限流： 鉴于只有少部分用户能够秒杀成功，所以要限制部分流量，只允许少部分流量进入服务器
【项目实战】秒杀系统深度优化四(Nginx高性能的原因)
wssjdysf1的专栏
06-16 627
【高并发】高并发秒杀系统架构解密，不是所有的秒杀都是秒杀！
冰河的专栏
04-08 5661
网上很多的文章和帖子中在介绍秒杀系统时，说是在下单时使用异步削峰来进行一些限流操作，那都是在扯淡！ 因为下单操作在整个秒杀系统的流程中属于比较靠后的操作了，限流操作一定要前置处理，在秒杀业务后面的流程中做限流操作是没啥卵用的。
秒杀业务架构优化之路
码农之道
03-24 3010
一、秒杀业务为什么难做 im系统，例如qq或者微博，每个人都读自己的数据（好友列表、群列表、个人信息）；微博系统，每个人读你关注的人的数据，一个人读多个人的数据；秒杀系统，库存只有一份，所有人会在集中的时间读和写这些数据，多个人读一个数据。   例如小米手机每周二的秒杀，可能手机只有1万部，但瞬时进入的流量可能是几百几千万。又例如12306抢票，票是有限的，库存一份，
nginx+tomcat服务器配置（秒杀安全扫描）
ERIZHU的博客
04-17 1508
nginx配置修改1.解决配置limit_conn_zone来限制并发连接数      在http处添加      limit_conn_zone $binary_remote_addr zone=perip:10m;      limit_conn_zone $server_name zone=perserver:10m;2.解决 Slow HTTP POST vulnerability（150...
【高并发】秒杀系统架构解密，不是所有的秒杀都是秒杀（升级版）！！
冰河的专栏
10-14 2485
我再次升级了秒杀系统架构，学习高并发秒杀系统架构，看这一篇就够了！！
Dubbo框架下的秒杀系统设计与实现解析
论文探讨了如何利用Dubbo框架构建能够应对高并发场景的秒杀系统，以满足互联网电商企业在进行秒杀活动时对系统稳定性和性能的需求。" 在互联网电商行业中，秒杀活动是一种非常有效的吸引客户流量的策略。然而，这种...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值