tomcat探究四默认连接器(tomcat4)

说明

由于代码量过多，因此只放简单的图解

连接器

请求对象

响应对象

代码

Connector

public interface Connector {
	
	public void initialize();
}

HttpConnector

public class HttpConnector implements Connector,Runnable {
	
	private ServerSocket serverSocket = null;
	private Stack processors = new Stack(); //processors池
	private int maxProcessor = 10;
	private int minProcessor = 5;
	
	private int curProcessor = 0;
	
	private int port = 8080;
	private int bolckSize = 10;
	
	
	@Override
	public void run() {
		boolean stoped = false;
		while(!stoped) {
			Socket socket = null;
			try {
				socket = serverSocket.accept();
			} catch (Exception e) {
				e.printStackTrace();
				continue;
			}
			HttpProcessor processor = createProcessor();
			if(processor == null) {
				try {
					socket.close();
					System.out.println("当前资源HttpProcessor用尽");
					continue;
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
			processor.assign(socket);
		}
	}
	
	public void start() {
        while (curProcessor < minProcessor) {
        	if ((maxProcessor > 0) && (curProcessor >= maxProcessor))
                break;
        	newProcessor();
        }
	}

	/**
	 * 初始化serverSocket
	 */
	@Override
	public void initialize() {
		serverSocket = open();
	}
	
	private ServerSocket open() {
		try {
			return new ServerSocket(port, bolckSize);
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		return null;
	}
	
	//HttpProcessor对象入栈
	void recycle(HttpProcessor processor) {
        processors.push(processor);
    }
	
	//获取HttpProcessor实例
    private HttpProcessor createProcessor() {
        synchronized (processors) {
            if (processors.size() > 0) {
                return ((HttpProcessor) processors.pop());
            }
            if ((maxProcessor > 0) && (curProcessor < maxProcessor)) {
                return (newProcessor());
            } else {
                if (maxProcessor < 0) { //没有限制的情况下
                    return (newProcessor());
                } else {
                    return (null);
                }
            }
        }
    }
    
    private HttpProcessor newProcessor() {
    	HttpProcessor processor = new HttpProcessor(this);
        recycle(processor);
        curProcessor++;
        return processor;
    }
}

HttpProcessor

public class HttpProcessor implements Runnable{
	
	private HttpConnector connector = null;
	
	private Thread  thread;
	private boolean started = false; //线程是否已经启动
	
	HttpProcessor(HttpConnector connector){
		this.connector = connector;
	}
	
	private boolean stopped = false;
	private boolean available = false; //该对象是否被占用
	private Socket socket = null;
	
	public void process(Socket socket) {
		
	}

	synchronized void assign(Socket socket) {
        while (available) {
            try {
                wait();
            } catch (InterruptedException e) {
            }
        }
        this.socket = socket;
        available = true;
        notifyAll();
    }

	@Override
	public void run() {
		while (!stopped) {
            // Wait for the next socket to be assigned
            Socket socket = await();
            if (socket == null)
                continue;
            try {
                process(socket);
            } catch (Throwable t) {
            }

            // Finish up this request
            connector.recycle(this);

        }
		
	}
	
	private synchronized Socket await() {
        while (!available) {
            try {
                wait();
            } catch (InterruptedException e) {
            }
        }

        available = false;
        notifyAll();

        return (socket);

    }

	
    private void threadStart() {
        thread = new Thread(this);
        thread.setDaemon(true);
        thread.start();

    }
    
    private void threadStop() {
        stopped = true;
        assign(null);
        thread = null;

    }
    
    public void start()  {
        if (started) {
        	System.out.println("alreay start");
        	return;
        }
        started = true;
        threadStart();

    }
    
    public void stop() {
        if (!started) {
        	System.out.println("no start");
        	return;
        }
        started = false;

        threadStop();

    }
}