经验首页 前端设计 程序设计 Java相关 移动开发 数据库/运维 软件/图像 大数据/云计算 其他经验
当前位置：技术经验 » 程序设计 » 编程经验 » 查看文章
你们的优雅停机真的优雅吗？
来源：cnblogs　　作者：京东云开发者　　时间：2023/8/16 9:14:59　　对本文有异议

1.前言

emm，又又遇到问题啦，现有业务系统应用上线存在窗口期，不能满足正常任务迭代上线。在非窗口期上线容易导致数据库、mq、jsf等线程中断，进而导致需要手动修单问题。故而通过添加优雅停机功能进行优化，令其在上线前选择优雅停机后，会优先断掉新流量的涌入，并预留一定时间处理现存连接，最后完全下线，可有效扩大上线预留窗口时间并降低上线期间线程中断，进而降低手动修单。可是什么是优雅停机呢？为什么现有的系统技术没有原生的优雅停机机制呢？通过调研整理文章如下。

2.何为优雅停机？

? 优雅停机是指为确保应用关闭时，通知应用进程释放所占用的资源。

? 线程池，shutdown（不接受新任务等待处理完）还是shutdownNow（调用Thread.interrupt进行中断）。

? socket链接，比如：netty、jmq、fmq。（需要着重处理）

? 告知注册中心快速下线，比如jsf。（需要着重处理）

? 清理临时文件。

? 各种堆内堆外内存释放。

总之，进程强行终止会带来数据丢失或者终端无法恢复到正常状态，在分布式环境下可能导致数据不一致的情况。

3.导致优雅停机不优雅的元凶之-kill命令

? kill指令

? kill -15 ：kill指令默认就是-15，知识发送一个SIGTERM信号通知进程终止，由进程自行决定怎么做，即进程不一定终止。一般不直接使用kill -15，不一定能够终止进程。

? kill -9：强制终止进程，进程会被立刻终止。kill -9 过于暴力，往往会出现事务执行、业务处理中断的情况，导致数据库中存在脏数据、系统中存在残留文件等情况。如果要使用kill -9，尽量先使用kill -15给进程一个处理善后的机会。该命令可以模拟一次系统宕机，系统断电等极端情况。

? kill -2：类似Ctrl + C退出，会先保存相关数据再终止进程。kill -2立刻终止正在执行的代码->保存数据->终止进程，只是在进程终止之前会保存相关数据，依然会出现事务执行、业务处理中断的情况，做不到优雅停机。

4.引申问题：jvm如何接受处理linux信号量的？

? 在jvm启动时就加载了自定义SingalHandler，关闭jvm时触发对应的handle。

  1. public interface SignalHandler {
  2.     SignalHandler SIG_DFL = new NativeSignalHandler(0L);
  3.     SignalHandler SIG_IGN = new NativeSignalHandler(1L);
  4.  
  5.     void handle(Signal var1);
  6. }
  7. class Terminator {
  8.     private static SignalHandler handler = null;
  9.  
  10.     Terminator() {
  11.     }
  12.     //jvm设置SignalHandler，在System.initializeSystemClass中触发
  13.     static void setup() {
  14.         if (handler == null) {
  15.             SignalHandler var0 = new SignalHandler() {
  16.                 public void handle(Signal var1) {
  17.                     Shutdown.exit(var1.getNumber() + 128);//调用Shutdown.exit
  18.                 }
  19.             };
  20.             handler = var0;
  21.  
  22.             try {
  23.                 Signal.handle(new Signal("INT"), var0);//中断时
  24.             } catch (IllegalArgumentException var3) {
  25.                 
  26.             }
  27.  
  28.             try {
  29.                 Signal.handle(new Signal("TERM"), var0);//终止时
  30.             } catch (IllegalArgumentException var2) {
  31.                 
  32.             }
  33.  
  34.         }
  35.     }
  36. }

? Runtime.addShutdownHook。在了解Shutdown.exit之前，先看Runtime.getRuntime().addShutdownHook(shutdownHook)；则是为jvm中增加一个关闭的钩子，当jvm关闭的时候调用。

  1. public class Runtime {
  2.     public void addShutdownHook(Thread hook) {
  3.         SecurityManager sm = System.getSecurityManager();
  4.         if (sm != null) {
  5.             sm.checkPermission(new RuntimePermission("shutdownHooks"));
  6.         }
  7.         ApplicationShutdownHooks.add(hook);
  8.     }
  9. }
  10. class ApplicationShutdownHooks {
  11.     /* The set of registered hooks */
  12.     private static IdentityHashMap<Thread, Thread> hooks;
  13.     static synchronized void add(Thread hook) {
  14.         if(hooks == null)
  15.             throw new IllegalStateException("Shutdown in progress");
  16.  
  17.         if (hook.isAlive())
  18.             throw new IllegalArgumentException("Hook already running");
  19.  
  20.         if (hooks.containsKey(hook))
  21.             throw new IllegalArgumentException("Hook previously registered");
  22.  
  23.         hooks.put(hook, hook);
  24.     }
  25. }
  26. //它含数据结构和逻辑管理虚拟机关闭序列
  27. class Shutdown {
  28.     /* Shutdown 系列状态*/
  29.     private static final int RUNNING = 0;
  30.     private static final int HOOKS = 1;
  31.     private static final int FINALIZERS = 2;
  32.     private static int state = RUNNING;
  33.     /* 是否应该运行所以finalizers来exit? */
  34.     private static boolean runFinalizersOnExit = false;
  35.     // 系统关闭钩子注册一个预定义的插槽.
  36.     // 关闭钩子的列表如下:
  37.     // (0) Console restore hook
  38.     // (1) Application hooks
  39.     // (2) DeleteOnExit hook
  40.     private static final int MAX_SYSTEM_HOOKS = 10;
  41.     private static final Runnable[] hooks = new Runnable[MAX_SYSTEM_HOOKS];
  42.     // 当前运行关闭钩子的钩子的索引
  43.     private static int currentRunningHook = 0;
  44.     /* 前面的静态字段由这个锁保护 */
  45.     private static class Lock { };
  46.     private static Object lock = new Lock();
  47.  
  48.     /* 为native halt方法提供锁对象 */
  49.     private static Object haltLock = new Lock();
  50.  
  51.     static void add(int slot, boolean registerShutdownInProgress, Runnable hook) {
  52.         synchronized (lock) {
  53.             if (hooks[slot] != null)
  54.                 throw new InternalError("Shutdown hook at slot " + slot + " already registered");
  55.  
  56.             if (!registerShutdownInProgress) {//执行shutdown过程中不添加hook
  57.                 if (state > RUNNING)//如果已经在执行shutdown操作不能添加hook
  58.                     throw new IllegalStateException("Shutdown in progress");
  59.             } else {//如果hooks已经执行完毕不能再添加hook。如果正在执行hooks时，添加的槽点小于当前执行的槽点位置也不能添加
  60.                 if (state > HOOKS || (state == HOOKS && slot <= currentRunningHook))
  61.                     throw new IllegalStateException("Shutdown in progress");
  62.             }
  63.  
  64.             hooks[slot] = hook;
  65.         }
  66.     }
  67.     /* 执行所有注册的hooks
  68.      */
  69.     private static void runHooks() {
  70.         for (int i=0; i < MAX_SYSTEM_HOOKS; i++) {
  71.             try {
  72.                 Runnable hook;
  73.                 synchronized (lock) {
  74.                     // acquire the lock to make sure the hook registered during
  75.                     // shutdown is visible here.
  76.                     currentRunningHook = i;
  77.                     hook = hooks[i];
  78.                 }
  79.                 if (hook != null) hook.run();
  80.             } catch(Throwable t) {
  81.                 if (t instanceof ThreadDeath) {
  82.                     ThreadDeath td = (ThreadDeath)t;
  83.                     throw td;
  84.                 }
  85.             }
  86.         }
  87.     }
  88.     /* 关闭JVM的操作
  89.      */
  90.     static void halt(int status) {
  91.         synchronized (haltLock) {
  92.             halt0(status);
  93.         }
  94.     }
  95.     //JNI方法
  96.     static native void halt0(int status);
  97.     // shutdown的执行顺序：runHooks > runFinalizersOnExit
  98.     private static void sequence() {
  99.         synchronized (lock) {
  100.             /* Guard against the possibility of a daemon thread invoking exit
  101.              * after DestroyJavaVM initiates the shutdown sequence
  102.              */
  103.             if (state != HOOKS) return;
  104.         }
  105.         runHooks();
  106.         boolean rfoe;
  107.         synchronized (lock) {
  108.             state = FINALIZERS;
  109.             rfoe = runFinalizersOnExit;
  110.         }
  111.         if (rfoe) runAllFinalizers();
  112.     }
  113.     //Runtime.exit时执行，runHooks > runFinalizersOnExit > halt
  114.     static void exit(int status) {
  115.         boolean runMoreFinalizers = false;
  116.         synchronized (lock) {
  117.             if (status != 0) runFinalizersOnExit = false;
  118.             switch (state) {
  119.             case RUNNING:       /* Initiate shutdown */
  120.                 state = HOOKS;
  121.                 break;
  122.             case HOOKS:         /* Stall and halt */
  123.                 break;
  124.             case FINALIZERS:
  125.                 if (status != 0) {
  126.                     /* Halt immediately on nonzero status */
  127.                     halt(status);
  128.                 } else {
  129.                     /* Compatibility with old behavior:
  130.                      * Run more finalizers and then halt
  131.                      */
  132.                     runMoreFinalizers = runFinalizersOnExit;
  133.                 }
  134.                 break;
  135.             }
  136.         }
  137.         if (runMoreFinalizers) {
  138.             runAllFinalizers();
  139.             halt(status);
  140.         }
  141.         synchronized (Shutdown.class) {
  142.             /* Synchronize on the class object, causing any other thread
  143.              * that attempts to initiate shutdown to stall indefinitely
  144.              */
  145.             sequence();
  146.             halt(status);
  147.         }
  148.     }
  149.     //shutdown操作，与exit不同的是不做halt操作(关闭JVM)
  150.     static void shutdown() {
  151.         synchronized (lock) {
  152.             switch (state) {
  153.             case RUNNING:       /* Initiate shutdown */
  154.                 state = HOOKS;
  155.                 break;
  156.             case HOOKS:         /* Stall and then return */
  157.             case FINALIZERS:
  158.                 break;
  159.             }
  160.         }
  161.         synchronized (Shutdown.class) {
  162.             sequence();
  163.         }
  164.     }
  165. }

5.Spring 中是如何实现优雅停机的？

? 以Spring3.2.12在spring中通过ContexClosedEvent事件来触发一些动作，主要通过LifecycleProcessor.onClose来做stopBeans。由此可见spring也基于jvm做了扩展。

  1. public abstract class AbstractApplicationContext extends DefaultResourceLoader {
  2.      public void registerShutdownHook() {
  3.           if (this.shutdownHook == null) {
  4.            // No shutdown hook registered yet.
  5.                this.shutdownHook = new Thread() {
  6.                     @Override
  7.                     public void run() {
  8.                          doClose();
  9.                     }
  10.                };
  11.            Runtime.getRuntime().addShutdownHook(this.shutdownHook);
  12.           }
  13.  }
  14.      protected void doClose() {
  15.           boolean actuallyClose;
  16.           synchronized (this.activeMonitor) {
  17.           actuallyClose = this.active && !this.closed;
  18.           this.closed = true;
  19.           }
  20.  
  21.           if (actuallyClose) {
  22.                if (logger.isInfoEnabled()) {
  23.                     logger.info("Closing " + this);
  24.                }
  25.  
  26.                LiveBeansView.unregisterApplicationContext(this);
  27.  
  28.                try {
  29.     //发布应用内的关闭事件
  30.                     publishEvent(new ContextClosedEvent(this));
  31.                }
  32.                catch (Throwable ex) {
  33.                     logger.warn("Exception thrown from ApplicationListener handling ContextClosedEvent", ex);
  34.                }
  35.  
  36.    // 停止所有的Lifecycle beans.
  37.                try {
  38.                     getLifecycleProcessor().onClose();
  39.                }
  40.                    catch (Throwable ex) {
  41.                 logger.warn("Exception thrown from LifecycleProcessor on context close", ex);
  42.                }
  43.  
  44.    // 销毁spring 的 BeanFactory可能会缓存单例的 Bean.
  45.                destroyBeans();
  46.  
  47.    // 关闭当前应用上下文（BeanFactory）
  48.                closeBeanFactory();
  49.  
  50.    // 执行子类的关闭逻辑
  51.                onClose();
  52.  
  53.                synchronized (this.activeMonitor) {
  54.                     this.active = false;
  55.                }
  56.           }
  57.      } 
  58. }
  59. public interface LifecycleProcessor extends Lifecycle {
  60.  /**
  61.   * Notification of context refresh, e.g. for auto-starting components.
  62.   */
  63.      void onRefresh();
  64.  
  65.  /**
  66.   * Notification of context close phase, e.g. for auto-stopping components.
  67.   */
  68.      void onClose();
  69. }

6.SpringBoot是如何做到优雅停机的？

? 优雅停机是springboot的特性之一，在收到终止信号后，不再接受、处理新请求，但会在终止进程之前预留一小段缓冲时间，已完成正在处理的请求。注：优雅停机需要在tomcat的9.0.33及其之后的版本才支持。

? springboot中有spring-boot-starter-actuator模块提供了一个restful接口，用于优雅停机。执行请求curl -X POST http://127.0.0.1:8088/shutdown。待关闭成功则返回提示。注：线上环境url需要设置权限，可配合spring-security使用火灾nginx限制内网访问``。

  1. #启用shutdown
  2. endpoints.shutdown.enabled=true
  3. #禁用密码验证
  4. endpoints.shutdown.sensitive=false
  5. #可统一指定所有endpoints的路径
  6. management.context-path=/manage
  7. #指定管理端口和IP
  8. management.port=8088
  9. management.address=127.0.0.1
  10.  
  11. #开启shutdown的安全验证（spring-security）
  12. endpoints.shutdown.sensitive=true
  13. #验证用户名
  14. security.user.name=admin
  15. #验证密码
  16. security.user.password=secret
  17. #角色
  18. management.security.role=SUPERUSER

? springboot的shutdown通过调用AbstractApplicationContext.close实现的。

  1. @ConfigurationProperties(
  2.     prefix = "endpoints.shutdown"
  3. )
  4. public class ShutdownMvcEndpoint extends EndpointMvcAdapter {
  5.     public ShutdownMvcEndpoint(ShutdownEndpoint delegate) {
  6.         super(delegate);
  7.     }
  8.     //post请求
  9.     @PostMapping(
  10.         produces = {"application/vnd.spring-boot.actuator.v1+json", "application/json"}
  11.     )
  12.     @ResponseBody
  13.     public Object invoke() {
  14.         return !this.getDelegate().isEnabled() ? new ResponseEntity(Collections.singletonMap("message", "This endpoint is disabled"), HttpStatus.NOT_FOUND) : super.invoke();
  15.     }
  16. }
  17. @ConfigurationProperties(
  18.     prefix = "endpoints.shutdown"
  19. )
  20. public class ShutdownEndpoint extends AbstractEndpoint<Map<String, Object>> implements ApplicationContextAware {
  21.     private static final Map<String, Object> NO_CONTEXT_MESSAGE = Collections.unmodifiableMap(Collections.singletonMap("message", "No context to shutdown."));
  22.     private static final Map<String, Object> SHUTDOWN_MESSAGE = Collections.unmodifiableMap(Collections.singletonMap("message", "Shutting down, bye..."));
  23.     private ConfigurableApplicationContext context;
  24.  
  25.     public ShutdownEndpoint() {
  26.         super("shutdown", true, false);
  27.     }
  28.     //执行关闭
  29.     public Map<String, Object> invoke() {
  30.         if (this.context == null) {
  31.             return NO_CONTEXT_MESSAGE;
  32.         } else {
  33.             boolean var6 = false;
  34.  
  35.             Map var1;
  36.  
  37.             class NamelessClass_1 implements Runnable {
  38.                 NamelessClass_1() {
  39.                 }
  40.  
  41.                 public void run() {
  42.                     try {
  43.                         Thread.sleep(500L);
  44.                     } catch (InterruptedException var2) {
  45.                         Thread.currentThread().interrupt();
  46.                     }
  47.                     //这个调用的就是AbstractApplicationContext.close
  48.                     ShutdownEndpoint.this.context.close();
  49.                 }
  50.             }
  51.  
  52.             try {
  53.                 var6 = true;
  54.                 var1 = SHUTDOWN_MESSAGE;
  55.                 var6 = false;
  56.             } finally {
  57.                 if (var6) {
  58.                     Thread thread = new Thread(new NamelessClass_1());
  59.                     thread.setContextClassLoader(this.getClass().getClassLoader());
  60.                     thread.start();
  61.                 }
  62.             }
  63.  
  64.             Thread thread = new Thread(new NamelessClass_1());
  65.             thread.setContextClassLoader(this.getClass().getClassLoader());
  66.             thread.start();
  67.             return var1;
  68.         }
  69.     }
  70. }

7.知识拓展之Tomcat和Spring的关系？

通过参与云工厂优雅停机重构发现Tomcat和Spring均存在问题，故而查询探究两者之间。

? Tomcat和jettey是HTTP服务器和Servlet容器，负责给类似Spring这种servlet提供一个运行的环境，其中：Http服务器与Servlet容器的功能界限是：可以把HTTP服务器想象成前台的接待，负责网络通信和解析请求，Servlet容器是业务部门，负责处理业务请求。

? Tomcat和Servlet作为Web服务器和Servlet容器的结合，可以接受网络http请求解析为Servlet规范的请求对象和响应对象。比如，HttpServletRequest对象是Tomcat提供的，Servlet是规范，Tomcat是实现规范的Servlet容器，SpringMVC是处理Servlet请求的应用，其中DispatcherServlet实现了Servlet接口，Tomcat负责加载和调用DispatcherServlet。同时，DispatcherServlet有自己的容器（SpringMVC）容器，这个容器负责管理SpringMVC相关的bean，比如Controler和ViewResolver等。同时，Spring中还有其他的Bean比如Service和DAO等，这些由全局的Spring IOC容器管理，因此，Spring有两个IOC容器。

? 如果只是使用spring(不包含springmvc)，那么是tomcat容器解析xml文件，通过反射实例化对应的类，根据这些servlet规范实现类，触发对应的代码处理逻辑，这个时候tomcat负责http报文的解析和servlet调度的工作。

? 如果使用spring mvc，那么tomcat只是解析http报文，然后将其转发给dispatchsetvlet，然后由springmvc根据其配置，实例对应的类，执行对应的逻辑，然后返回结果给dispatchservlet，最后由它转发给tomcat,由tomcat负责构建http报文数据。

8.实战演练

? mq（jmq、fmq）通过添加hook在停机时调用pause先停止该应用的消费，防止出现上线期间mq中线程池的线程中断的情况发生。

  2. /**
  3.  * @ClassName ShutDownHook
  4.  * @Description
  5.  * @Date 2022/10/28 17:47
  6.  **/
  7. @Component
  8. @Slf4j
  9. public class ShutDownHook {
  11.     @Value("${shutdown.waitTime:10}")
  12.     private int waitTime;
  14.     @Resource
  15.     com.jdjr.fmq.client.consumer.MessageConsumer fmqMessageConsumer;
  17.     @Resource
  18.     com.jd.jmq.client.consumer.MessageConsumer jmqMessageConsumer;
  21.     @PreDestroy
  22.     public void destroyHook() {
  23.         try {
  24.             log.info("ShutDownHook destroy");
  26.             jmqMessageConsumer.pause();
  27.             fmqMessageConsumer.pause();
  29.             int i = 0;
  30.             while (i < waitTime) {
  31.                 try {
  32.                     Thread.sleep(1000);
  33.                     log.info("距离服务关停还有{}秒", waitTime - i++);
  34.                 } catch (Throwable e) {
  35.                     log.error("异常", e);
  36.                 }
  37.             }
  39.         } catch (Throwable e) {
  40.             log.error("异常", e);
  41.         }
  43.     }
  44. }

? 在优雅停机时需要先把jsf生产者下线，并预留一定时间消费完毕，行云部署有相关stop.sh脚本，项目中通过在shutdown中编写方法实现。

jsf启停分析：见京东内部cf文档；

  1. @Component
  2. @Lazy(value = false)
  3. public class ShutDown implements ApplicationContextAware {
  4.     private static Logger logger = LoggerFactory.getLogger(ShutDown.class);
  6.     @Value("${shutdown.waitTime:60}")
  7.     private int waitTime;
  9.     @Resource
  10.     com.jdjr.fmq.client.consumer.MessageConsumer fmqMessageConsumer;
  12.     @PostConstruct
  13.     public void init() {
  14.         logger.info("ShutDownHook init");
  15.     }
  17.     private ApplicationContext applicationContext = null;
  19.     @PreDestroy
  20.     public void destroyHook() {
  21.         try {
  22.             logger.info("ShutDownHook destroy");
  23.             destroyJsfProvider();
  24.             fmqMessageConsumer.pause();
  26.             int i = 0;
  27.             while (i < waitTime) {
  28.                 try {
  29.                     Thread.sleep(1000);
  30.                     logger.info("距离服务关停还有{}秒", waitTime - i++);
  31.                 } catch (Throwable e) {
  32.                     logger.error("异常", e);
  33.                 }
  34.             }
  36.         } catch (Throwable e) {
  37.             logger.error("异常", e);
  38.         }
  40.     }
  41.     private void destroyJsfProvider() {
  42.         logger.info("关闭所有JSF生产者");
  43.         if (null != applicationContext) {
  44.             String[] providerBeanNames = applicationContext.getBeanNamesForType(ProviderBean.class);
  45.             for (String name : providerBeanNames) {
  46.                 try {
  47.                     logger.info("尝试关闭JSF生产者" + name);
  48.                     ProviderBean bean=(ProviderBean)applicationContext.getBean(name);
  49.                     bean.destroy();
  50.                     logger.info("关闭JSF生产者" + name + "成功");
  51.                 } catch (BeanCreationNotAllowedException re){
  52.                     logger.error("JSF生产者" + name + "未初始化，忽略");
  53.                 } catch (Exception e) {
  54.                     logger.error("关闭JSF生产者失败", e);
  55.                 }
  56.             }
  57.         }
  58.         logger.info("所有JSF生产者已关闭");
  59.     }
  61.     @Override
  62.     public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
  63.         this.applicationContext = applicationContext;
  64.         ((AbstractApplicationContext)applicationContext).registerShutdownHook();
  65.     }
  67. }

? absfactory-base-custcenter应用优雅停机出现日志无法打印问题，排查定位发现问题如下：通过本地debug发现优雅停机先销毁logback日志打印线程，导致实际倒计时的日志无法打印。

  1.     <!--	fix-程序关停时，logback先销毁的问题-->
  2.     <context-param>
  3.         <param-name>logbackDisableServletContainerInitializer</param-name>
  4.         <param-value>true</param-value>
  5.     </context-param>

9.总结

现有的springboot内置Tomcat能通过配置参数达到优雅停机的效果。但是因为业务系统中的代码中存在多种技术交叉应用，针对Tomcat和springmvc不同的应用确实需要花费时间研究底层原理来编写相关类实现同springboot配置参数托管的效果。

作者：京东科技 宋慧超

来源：京东云开发者社区

原文链接：https://www.cnblogs.com/Jcloud/p/17628171.html

 友情链接：直通硅谷 　点职佳 　北美留学生论坛

编程经验热门文章

  • Prometheus监控之SNMP Exporter介绍和数据展现
  • Intel 82599网卡异常挂死原因
  • 腾讯防水墙的分析识别与破解
  • 桌面应用自动化WinAppDriver入门
  • 文档在线预览（三）使用js前端实现word、excel、pdf、ppt 在线预览
  • 「教程」如何下载AcFun网站上的视频、A站视频下载工具
  • 基于Hi3559AV100的SVP(NNIE)开发整体流程
  • GBDT(梯度提升树)scikit-klearn中的参数说明及简汇
  • antd之RangePicker设置默认值方式
  • 决胜经典算法之插入排序

    • 编程经验推荐文章

  • wifi基础(一)：无线电波与WIFI信号干扰、衰减
  • 甲方扔给两个存在包名与类名均相同的Jar包，要在工程中同时使用怎么办？
  • 《花100块做个摸鱼小网站! 》第三篇—热搜表结构设计和热搜数据存储
  • Fluent Editor：一个基于 Quill 2.0 的富文本编辑器，功能强大、开箱即用！
  • 方法的三种调用形式
  • 《花100块做个摸鱼小网站! 》第二篇—后端应用搭建和完成第一个爬虫
  • 《熬夜整理》保姆级系列教程-玩转Wireshark抓包神器教程(4)-再识Wireshark - 北京-宏哥
  • 《软件性能测试分析与调优实践之路》(第2版) 读书笔记（二）总体介绍（下）-真正从性能分析与调优来看性能测试
  • 架构知识点（三）
  • 《花100块做个摸鱼小网站! 》第一篇—买云服务器和初始化环境

    • 本站QQ群：前端 618073944 | Java 606181507 | Python 626812652 | C/C++ 612253063 | 微信 634508462 | 苹果 692586424 | C#/.net 182808419 | PHP 305140648 | 运维 608723728

    W3xue 的所有内容仅供测试，对任何法律问题及风险不承担任何责任。通过使用本站内容随之而来的风险与本站无关。
    关于我们  |  意见建议  |  捐助我们  |  报错有奖  |  广告合作、友情链接（目前9元/月）请联系QQ：27243702 沸活量
    皖ICP备17017327号-2　皖公网安备34020702000426号