手写tomcat+手写线程池进行线程管理

最新推荐文章于 2023-05-31 14:27:38 发布
最新推荐文章于 2023-05-31 14:27:38 发布
阅读量361 收藏 3
点赞数
分类专栏： java 文章标签： java tomcat
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_38320702/article/details/108582216
版权

目录

手写tomcat主要分为3个步骤

Maven依赖

MyTomcat

bean

MyRequest

MyResponse

MyUrlMapping

servlet

AbcServlet

 MyServlet

config

MyUrlMappingConfig

手写线程池

ExecutorPool

 

手写tomcat主要分为3个步骤

  1. 提供socket服务
  2. 把请求和响应封装为request/response
  3. 根据请求进行转发

Maven依赖

request解析参数时使用到了json工具类帮助解析json字符串

<!--JSON依赖-->
    <dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>fastjson</artifactId>
        <version>1.2.49</version>
    </dependency>
</dependencies>

 

MyTomcat

主要作用是完成上面所说的手写tomcat的3个步骤，然后使用线程池进行多线程的管理。

package com.siyang.tomcat;

import com.siyang.tomcat.bean.MyRequest;
import com.siyang.tomcat.bean.MyResponse;
import com.siyang.tomcat.bean.MyUrlMapping;
import com.siyang.tomcat.config.MyUrlMappingConfig;
import com.siyang.tomcat.servlet.MyServlet;
import com.siyang.tomcat.thread.ExecutorPool;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.HashMap;
import java.util.Map;

/**
 * @author siyang
 * @create 2020-09-11 15:16
 */
public class MyTomcat {
    private int port = 8088;
    private Map<String,String> urlClazzMap = new HashMap();

    public MyTomcat(int port) {
        this.port = port;

    }

    public void start() throws IOException {
        // 初始化
        init();
        // socket 连接
        ServerSocket socket = new ServerSocket(port);
        ExecutorPool executorPool = new ExecutorPool(5,10,10);
        while(true){
            Socket accept = socket.accept();
            // 使用多线程池避免堵塞
            executorPool.submit(new Runnable() {
                @Override
                public void run() {
                    try {
                        // 获取输入输出流
                        InputStream inputStream  = accept.getInputStream();
                        OutputStream outputStream = accept.getOutputStream();
                        // 将请求和响应封装为request/response
                        MyRequest myRequest = new MyRequest(inputStream);
                        MyResponse myResponse = new MyResponse(outputStream);
                        System.out.println(myRequest.toString());
                        // 进行分发
                        if(myRequest.getUrl() != null){
                            // 分发
                            dispatch(myRequest,myResponse);
                        }
                    } catch (IOException e) {
                        e.printStackTrace();
                    } finally {
                        // 关闭
                        try {
                            accept.close();
                        } catch (IOException e) {
                            e.printStackTrace();
                        }
                    }
                }
            });
        }
    }

    private void init(){
        /**
         * 处理请求路径与文件的映射
         */
        for (MyUrlMapping myUrlMapping : MyUrlMappingConfig.mappingList) {
            urlClazzMap.put(myUrlMapping.getUrl(),myUrlMapping.getClazzPath());
        }

    }

    /**
     * 请求分发
     * @param request
     * @param response
     */
    private void dispatch(MyRequest request,MyResponse response) {

        try {
            if(urlClazzMap.containsKey(request.getUrl())){
                // 根据映射执行servlet
                Class<?> servletClazz = Class.forName(urlClazzMap.get(request.getUrl()));
                MyServlet o = (MyServlet)servletClazz.newInstance();
                o.service(request,response);
            }else{
                // 判断有没有父路径匹配的情况 /xx/*的情况
                String subUrl = request.getUrl();
                while(subUrl.indexOf("/")!= -1){ // 保证url中有 /
                    subUrl = subUrl.substring(0,subUrl.lastIndexOf("/"));
                    String starUrl = subUrl + "/*";
                    if(urlClazzMap.containsKey(starUrl)){
                        // 根据映射执行servlet
                        Class<?> servletClazz = Class.forName(urlClazzMap.get(starUrl));
                        MyServlet o = (MyServlet)servletClazz.newInstance();
                        o.service(request,response);
                        break;
                    }
                }
            }
        } catch (ClassNotFoundException e) {
            System.out.println("映射文件类路径错误");
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (NullPointerException e) {
            System.out.println("没有路径映射");
            e.printStackTrace();
        }
    }

    public static void main(String[] args) throws IOException {
        MyTomcat myTomcat = new MyTomcat(8888);
        myTomcat.start();
    }
}

 

bean

MyRequest

用于解析socket传来的inputStream，从流中解析请求头的信息，从中得到请求路径、请求方式、请求参数等参数。

package com.siyang.tomcat.bean;

import com.alibaba.fastjson.JSON;

import java.io.IOException;
import java.io.InputStream;
import java.util.HashMap;
import java.util.Map;

/**
 * @author siyang
 * @create 2020-09-11 15:16
 */
public class MyRequest {
    private String url;
    private String method;
    private Map<String,Object> param = new HashMap<>();

    public MyRequest(InputStream inputStream) throws IOException {
        String inputInfo  = null;
        byte[] bytes = new byte[1024];
        int len = 0;
        if((len = inputStream.read(bytes)) != -1){
            inputInfo = new String(bytes);
        }
        /**
         *  GET /abc HTTP/1.1
         * Host: localhost:8888
         * Connection: keep-alive
         * Upgrade-Insecure-Requests: 1
         * User-Agent: Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/70.0.3538.25 Safari/537.36 Core/1.70.3775.400 QQBrowser/10.6.4209.400
         * Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,;q = 0.8
         * Accept - Encoding:gzip, deflate, br
         * Accept - Language:zh - CN, zh; q = 0.9
         */
        // 只需要解析第一句话
        if(inputInfo != null ){
            String header = inputInfo.split("\n")[0];
            String[] temp = header.split(" ");

            // 获取请求方式
            this.method = temp[0];
            // 获取路径与参数
            if(this.method.equals("GET")){
                // 判断GET方法是否带有参数
                if(temp[1].contains("?")){
                    // 参数
                    String p = temp[1].substring(temp[1].indexOf("?")+1);
                    String[] ps = p.split("&");
                    for (String s : ps) {
                        String[] kv = s.split("=");
                        this.param.put(kv[0],kv[1]);
                    }
                    // 请求地址
                    String u = temp[1].substring(0,temp[1].indexOf("?"));
                    this. url = u.endsWith("/") ? u.substring(0,u.lastIndexOf("/")): u ;
                }else{
                    // 获取 url
                    this.url = temp[1].endsWith("/") ? temp[1].substring(0,temp[1].lastIndexOf("/")): temp[1] ;
                }
            }else if (this.method.equals("POST")){
                // 获取 url
                this.url = temp[1].endsWith("/") ? temp[1].substring(0,temp[1].lastIndexOf("/")): temp[1] ;
                // 获取参数
                String json = inputInfo.substring(inputInfo.indexOf("\r\n\r\n") + 4).replace("\u0000","");
                try {
                    if(!json.equals("")){ // 参数不为空
                        this.param = (Map<String,Object>)JSON.parse(json);
                    }
                } catch (Exception e) {
                    e.printStackTrace();
                    System.out.println("post请求参数不为json格式");
                }
            }

        }

    }

    public String getUrl() {
        return url;
    }

    public void setUrl(String url) {
        this.url = url;
    }

    public String getMethod() {
        return method;
    }

    public void setMethod(String method) {
        this.method = method;
    }

    public Map<String, Object> getParam() {
        return param;
    }

    public void setParam(Map<String, Object> param) {
        this.param = param;
    }

    @Override
    public String toString() {
        return "MyRequest{" +
                "url='" + url + '\'' +
                ", method='" + method + '\'' +
                ", param=" + param +
                '}';
    }
}

MyResponse

用来响应结果

package com.siyang.tomcat.bean;

import java.io.IOException;
import java.io.OutputStream;

/**
 * @author siyang
 * @create 2020-09-11 15:41
 */
public class MyResponse {
    private OutputStream outputStream;
    private String contentType = "text/html";
    private String charactor = "utf-8";

    public MyResponse(OutputStream outputStream) {
        this.outputStream = outputStream;
    }

    public void write(String content) throws IOException {

        /**
         * HTTP/1.1 200 OK
         * Content-Type: text/html;charset=utf-8
         * <html><body></body></html>
         *
         */
        StringBuffer stringBuffer = new StringBuffer();
        stringBuffer.append("HTTP/1.1 200 OK\n")
                .append("Content-Type: "+contentType+";charset="+charactor+"\n")
                .append("\r\n")
                .append("<html><body>")
                .append(content)
                .append("</body></html>");

        outputStream.write(stringBuffer.toString().getBytes());
        outputStream.close();
    }

    public String getContentType() {
        return contentType;
    }

    public void setContentType(String contentType) {
        this.contentType = contentType;
    }

    public String getCharactor() {
        return charactor;
    }

    public void setCharactor(String charactor) {
        this.charactor = charactor;
    }
}

MyUrlMapping

封装请求与映射servlet的实体类

package com.siyang.tomcat.bean;

/**
 * 封装请求与映射servlet的实体类
 * @author siyang
 * @create 2020-09-11 15:54
 */
public class MyUrlMapping {
    private String url;
    private String name;
    private String clazzPath;

    public MyUrlMapping(String url, String name, String clazzPath) {
        this.url = url;
        this.name = name;
        this.clazzPath = clazzPath;
    }

    public String getUrl() {
        return url;
    }

    public void setUrl(String url) {
        this.url = url;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getClazzPath() {
        return clazzPath;
    }

    public void setClazzPath(String clazzPath) {
        this.clazzPath = clazzPath;
    }
}

servlet

AbcServlet

自定义servlet

package com.siyang.tomcat.servlet;

import com.siyang.tomcat.bean.MyRequest;
import com.siyang.tomcat.bean.MyResponse;

import java.io.IOException;

/**
 * @author siyang
 * @create 2020-09-11 15:57
 */
public class AbcServlet implements MyServlet {
    @Override
    public void doGet(MyRequest myRequest, MyResponse myResponse) {
        this.doPost(myRequest,myResponse);
    }

    @Override
    public void doPost(MyRequest myRequest, MyResponse myResponse) {
        try {
            myResponse.write("牛逼");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

 MyServlet

自定义Servlet接口

package com.siyang.tomcat.servlet;

import com.siyang.tomcat.bean.MyRequest;
import com.siyang.tomcat.bean.MyResponse;

/**
 * @author siyang
 * @create 2020-09-11 15:47
 */
public interface MyServlet {

    public void doGet(MyRequest myRequest, MyResponse myResponse);
    public void doPost(MyRequest myRequest, MyResponse myResponse);

    default void service(MyRequest myRequest, MyResponse myResponse){
        if(myRequest.getMethod().equals("GET")){
            doGet(myRequest,myResponse);
        }else if(myRequest.getMethod().equals("POST")){
            doPost(myRequest,myResponse);
        }
    }

}

config

MyUrlMappingConfig

配置请求路径与响应实体类的映射类

package com.siyang.tomcat.config;

import com.siyang.tomcat.bean.MyUrlMapping;

import java.util.ArrayList;
import java.util.List;

/**
 * 配置请求路径与响应实体类的映射类
 * @author siyang
 * @create 2020-09-11 15:55
 */
public class MyUrlMappingConfig {
    public static List<MyUrlMapping> mappingList = new ArrayList<MyUrlMapping>();

    static {
        mappingList.add(new MyUrlMapping("/*","请求abc","com.siyang.tomcat.servlet.AbcServlet"));
//        mappingList.add(new MyUrlMapping("/abc","请求abc",""));
    }
}

手写线程池

ExecutorPool

自定义线程池，进行线程任务的管理。初始化时指定最大线程数、核心线程数、任务队列数、非核心线程存活时间等参数。

当任务队列满了时，会创建非核心线程进行执行任务。非核心线程如果长时间没有执行任务（存活时间指定），会自动销毁。

这里的非核心线程和核心线程没有本质上的区别，当长时间没有执行任务，存活时间过了后，会按照空闲时间逐渐销毁，只留下核心线程数指定数目 的线程作为核心线程。

package com.siyang.tomcat.thread;

import java.util.List;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.CopyOnWriteArrayList;
import java.util.concurrent.locks.ReentrantLock;

/**
 * 线程池
 * @author siyang
 * @create 2020-09-11 17:24
 */
public class ExecutorPool {
    private  int MAX_THREAD_NUMBER = 10; // 默认最大线程数 ，最大线程数 - 核心线程数 = 可以回收的线程数
    private  int MAIN_THREAD_NUMBER = 3; // 核心线程数
    private  int ALIVE_TIME = 6*1000; // 无任务状态下非核心线程线程存活时间 (ms),默认1分钟
    private  List<Thread> threads  = new CopyOnWriteArrayList<>(); // 线程列表
    private  int MAX_TASK_QUEUE_NUMBER = 10; // 默认最大任务队列数
    private  ArrayBlockingQueue<Runnable> taskQueue ; // 任务队列
    private volatile  int WORK_THREAD_NUMBER = 0; // 工作线程数
    private final ReentrantLock lock  = new ReentrantLock();

    public ExecutorPool(){
        taskQueue = new ArrayBlockingQueue(MAX_TASK_QUEUE_NUMBER);
    }

    /**
     * 
     * @param mainThreadNumber 核心线程数
     * @param maxThreadNumber 最大线程数
     * @param taskQueueNumber 任务队列数
     */
    public ExecutorPool(int mainThreadNumber,int maxThreadNumber,int taskQueueNumber){
        if(mainThreadNumber>maxThreadNumber){
            throw new RuntimeException("核心线程数不能大于最大线程数");
        }
        this.MAIN_THREAD_NUMBER = mainThreadNumber;
        this.MAX_THREAD_NUMBER = maxThreadNumber;
        this.MAX_TASK_QUEUE_NUMBER = taskQueueNumber;
        taskQueue = new ArrayBlockingQueue(MAX_TASK_QUEUE_NUMBER);
    }
    /**
     * 
     * @param mainThreadNumber 核心线程数
     * @param maxThreadNumber 最大线程数
     * @param taskQueueNumber 任务队列数
     * @param aliveTime 非核心线程存活时间
     */
    public ExecutorPool(int mainThreadNumber,int maxThreadNumber,int taskQueueNumber,int aliveTime){
        this.MAIN_THREAD_NUMBER = mainThreadNumber;
        this.MAX_THREAD_NUMBER = maxThreadNumber;
        this.MAX_TASK_QUEUE_NUMBER = taskQueueNumber;
        this.ALIVE_TIME = aliveTime;
        taskQueue = new ArrayBlockingQueue(MAX_TASK_QUEUE_NUMBER);
    }

    /**
     * 提交任务
     * @param runnable
     */
    public void submit(Runnable runnable){
        try {
            // 加锁
            lock.lock();
            // 存入任务队列
            if(!taskQueue.offer(runnable)){
                if(WORK_THREAD_NUMBER < MAX_THREAD_NUMBER){
                    MyThread myThread = new MyThread(runnable);
                    // 添加到线程列表中
                    threads.add(myThread);
                    // 执行任务
                    myThread.start();
                    WORK_THREAD_NUMBER ++;
//                    System.out.println("任务队列已满，创建非核心线程->名字："+myThread.getName());
                }else{
                    System.out.println("任务队列已满，无法创建非核心线程，请扩充任务队列大小");
                }
            }else{
//                System.out.println("存入任务队列");
            }

            if(WORK_THREAD_NUMBER < MAIN_THREAD_NUMBER){
                MyThread myThread = new MyThread(taskQueue.poll());
                // 添加到线程列表中
                threads.add(myThread);
                // 执行任务
                myThread.start();
                WORK_THREAD_NUMBER ++;
//                System.out.println("创建核心线程->名字："+myThread.getName());
            }



        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            // 解锁
            lock.unlock();
        }


    }

    /**
     * 自定义线程类
     */
    class MyThread extends Thread{
        private Runnable task;
        private long aliveTime; // 存活时间
        public MyThread(Runnable runnable) {
            this.task = runnable;
            this.aliveTime = System.currentTimeMillis();
        }

        @Override
        public void run() {
            // 一直循环执行 从队列中获取任务
            while(true){
                if(this.task != null){
                    // 执行任务 不会新建线程
//                    System.out.println("线程名"+ super.getName());
                    this.task.run();
                    // 运行完后重置runnable;
                    this.task = null;
                    // 重置生存时间
                    this.aliveTime = System.currentTimeMillis();
                }else{
                    // 超时删除
                    long date = System.currentTimeMillis();
                    if(date-aliveTime >= ALIVE_TIME){
                        // 核心线程无法删除
                        synchronized (MyThread.class){
                            if(WORK_THREAD_NUMBER > MAIN_THREAD_NUMBER){
                                threads.remove(this);
//                                System.out.println("删除队列"+",删除线程名字"+super.getName());
                                WORK_THREAD_NUMBER --;
                                break;
                            }
                        }

                    }
                    Runnable poll = taskQueue.poll();
                    this.task = poll;
                }

            }
        }
    }


    public static void main(String[] args) throws InterruptedException {
        Runnable r = new Runnable() {
            @Override
            public void run() {
                System.out.println("执行任务");
            }
        };
        ExecutorPool executorPool = new ExecutorPool(10,10,10);
        for(int i =0 ;i<10;i++){
            Thread.sleep(1000);
            executorPool.submit(r);
        }
        Thread.sleep(1000);
        for(int i =0 ;i<100;i++){
            executorPool.submit(r);
        }
    }
}

 

 

 

 

 

 

司杨
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
WPF手写输入+虚拟键盘源码
09-06
手写输入识别，虚拟键盘中\英文输入，两种模式可自行切换，自带记忆功能。可自行二次开发
手写tomcat使用多线程及线程池
xingcsdnboke的博客
03-21 154
1、继承Thread，在run()方法中写业务逻辑。2、使用多线程及线程池。
一次排查线上线程池数量过高的报警经历
IntelliJzzy的博客
01-08 3242
线上jstack查看正常机器和问题机器对比堆栈信息，发现大量的http-nio-1601-exec-线程在等待，查看线上监控发现优惠券接口调用量飙升，中午商家做活动抢券，根据线程名字可以看出是tomcat的线程池被打满了，线上监控显示线程数超过1000，比正常机器线程数超出500左右，对比上图基本确定原因。 进一步需要做tomcat线程池调优，应对每周一的高流量请求，甚至需要机器扩容，...
并发编程学习（十四）：tomcat线程池
weixin_40482816的博客
05-31 1993
Tomcat 的核心功能有两个，分别是负责接收和反馈外部请求的连接器 Connector，和负责处理请求的容器 Container。其中连接器和容器相辅相成，一起构成了基本的 web 服务 Service。每个 Tomcat 服务器可以管理多个 Service。ConnectorContainer由 Engine、Host、Context和Wrapper 四个容器组成ServiceConnector 和 Container 两个核心组件。
手写Tomcat
书生的博客
10-27 3052
tomcat提供的服务： 第一：提供Socket服务 第二：进行请求的分发 第三：需要把请求和响应封装成request/response
手写tomcat 加手写线程池结合
小菜鸟的博客
10-26 777
一 介绍： 前面的介绍copy别人的： 很多初学或将学java web的朋友总是被一系列异于常规java project的流程结构所困惑，搞不清事情的本质，这里就以最简单的方式来让初出茅庐的新手对java web项目有个清晰明了的认识。 学java web的必定先行学过java基础，众所周知，java项目运行于一个public类中的一个pulblic static void main（St
手写windows下c++线程池
01-12
线程池主体由两个线程构成 1、工作线程：不断的从任务队列里读取任务并且...2、管理线程：三秒中查询一次，根据任务和线程数量的比较来杀死线程或者生成线程 然后在需要调用线程池的地方往任务队列里添加函数就可以了。
手写 tomcat nio
01-22
手写 tomcat nio http://knight-black-bob.iteye.com/blog/2408450
手写RPC需求文档基于Bio+线程池
05-19
手写rpc需求文档
MATLAB手写识别+数据增广
07-22
本资源是基于BP神经网络的利用MATLAB实现的手写识别，资源内部固有的数据集是借用Goolge实验室和本人自己制作的，使用者可以自己利用里面的数据增广制作扩充数据集。本资仅供源供学习参考。
手写tomcat(四):实现NIO模型的tomcat
shenshaoming的博客
04-20 382
在手写tomcat（三）中，我实现了基于BIO模型的多线程tomcat，而这次我实现了Nio的多线程模型，下一步打算是通过netty实现，不过目前还在进行中。。。 以下是基于NIO模型监听请求以及开启线程处理收到的请求。 package com.tomcat.core; import com.tomcat.annotations.Servlet; import com.tomcat.bas...
手写tomcat(三):线程池实现bio模型的Tomcat
shenshaoming的博客
09-29 365
在手写tomcat(二):能够访问一个Servlet中,我实现了多线程的bio模型的tomcat,可是开启线程的方式是通过继承Thread实现的,这样的方式没有线程管理.所以我决定通过线程池去管理它.网上的教程很多,可是找到符合阿里规范的线程池还是比较费劲的,所以我把我的实现记录下来: HttpServer.java:负责监听请求,以及开启线程去处理它 package com.tomcat....
手写一个Tomcat服务器
yechengchao的博客
05-15 1879
作为java开发者，都知道Tomcat是一个家户喻晓的Web服务器。手写一个Tomcat对我们理解Tomcat的工作原理，还有servlet的执行流程有很大的帮助，下面是我手写一个简要版Tomcat的总结和收获！ 首先，先还原Tomcat的本质： 相信大家之前在开发的时候，虽然已经能上手开发web程序，但是对于Servlet的执行流程以及项目还会存在很多疑问，下面是我总结的我之前的疑问也给出相应...
自动手写tomcat的实现
海子@幸福人
06-28 3485
声明:该文章为转载的一个泡友的原创,泡友...泡友...泡友........你在那里呀 ??1. tomcat 的基本原理tomcat按以下的步骤对外提供服务定义web.xml文件读取web.xml文件，将配置信息读取到某个地方定义ServerSocket，持续监听服务服务到来后处理请求请求处理完成后返回结果2. 手写Demo2.1 代码结构2.2 定义web.xml 文件为简单起见，使用web....
JAVA手写线程池ThreadPool,带你了解线程池原理，附代码
liuhongya328的博客
11-22 269
JAVA手写线程池ThreadPool,带你了解线程池原理。
java 手写简化版线程池
it小小弟的博客
03-01 196
线程池 第一步：设置线程池基本变量 //给定一个初始池大小 private static int workNum = 5; //完成线程池数量 private static volatile int finished_task = 0; private WorkThread[] workThreads; //用于放置线程的池子 private List&...
手写Java线程池
weixin_34107739的博客
12-19 126
练习手写线程池 import java.util.concurrent.ArrayBlockingQueue; import java.util.concurrent.BlockingQueue; import java.util.concurrent.atomic.AtomicInteger; /** * ... * * @author : l...
Tomcat性能调优：线程设置
leeta的博客
08-03 5632
说明：一般线程与虚拟内存JVM设置同步设置，两者存在对应关系。 1.线程概念说明 maxThreads：此连接器将创建的请求处理线程的最大数量， 即可以处理的同时请求的最大数量，默认值为200。minSpareThreads：终保持运行状态的最小线程数。 这包括活动线程和空闲线程。 如果未指定，则使用默认值10。maxConnections： 服务器在任何给定时间将接受和处理的最大连接数。 对于BIO，除非使用执行程序，否则默认值为maxThreads的值，在这种情况下，默认值为执行程序的maxThre
Tomcat源码分析---后台线程管理
hixiaoxiaoniao的专栏
06-26 581
Tomcat后台管理以前也接触过，比如对普通session，持久session，集群session的超时管理，就是后台线程去做的。在看时序图之前首先看一下后台线程，也就是ContainerBase的内部类ContainerBackgroundProcessor里面的一个重要方法processChildren()，它是由ContainerBackgroundProcessor#run()每隔一定的时...
java手写tomcat
最新发布
08-05
需要注意的是，这只是Tomcat的基本实现思路，实际上Tomcat还包含了很多其他的功能，比如连接池、线程池、Session管理等。如果要完整地手写一个功能完备的Tomcat，需要更详细的实现和考虑更多的细节。 另外，手写...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值