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();
}
}