1. 启动Tomcat后, 在哪里接收Request?
启动Tomcat时,部署完webapp 后,就会启动connector ,启动这个连接器,也就意味着会启动一个线程来接收请求,
具体涉及的类:
Http11Protocol
org.apach.tomcat.uitl.net ,
JIoEndPoint , WorkStack (pool), Acceptor(Runnable)
首先,启动Http11Protocol会调用JIoEndpoint中的start();JIO会new监听器线程,监控连接;
public void start()
throws Exception {
// Initialize socket if not done before
if (!initialized) {
init();
}
if (!running) {
running = true;
paused = false;
// Create worker collection
if (executor == null) {
workers = new WorkerStack(maxThreads);
}
// Start acceptor threads
for (int i = 0; i < acceptorThreadCount; i++) {
Thread acceptorThread = new Thread(new Acceptor(), getName() + "-Acceptor-" + i);
acceptorThread.setPriority(threadPriority);
acceptorThread.setDaemon(daemon);
acceptorThread.start();
}
}
}
Acceptor(实现Runnable接口) 的 run() :启动http11Protocol ,就会阻塞在acceptSocket()上,直到有连接传入,得到Socket , 传递给Processor
/**
* The background thread that listens for incoming TCP/IP connections and
* hands them off to an appropriate processor.
* 监控连接,并把他们交给processor处理
*/
public void run() {
// Loop until we receive a shutdown command
// 只要不是shutdown 命令 他就一直在运行 等候请求传入
while (running) {
// Loop if endpoint is paused
while (paused) {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
// Ignore
}
}
// Accept the next incoming connection from the server socket
try { // 阻塞在这个地方 直到有连接传入
Socket socket = serverSocketFactory.acceptSocket(serverSocket);
serverSocketFactory.initSocket(socket);
// Hand this socket off to an appropriate processor
if (!processSocket(socket)) { // 处理socket
// Close socket right away
try {
socket.close();
} catch (IOException e) {
// Ignore
}
}
}catch ( IOException x ) {
if ( running ) log.error(sm.getString("endpoint.accept.fail"), x);
} catch (Throwable t) {
log.error(sm.getString("endpoint.accept.fail"), t);
}
// The processor will recycle itself when it finishes
}
}
}
processSocket() : 取得线程,处理Socket
/**
* Process given socket.
*/
protected boolean processSocket(Socket socket) {
try {
if (executor == null) { // exector是线程池
getWorkerThread().assign(socket);
} else {
executor.execute(new SocketProcessor(socket));// SocketProcess 实现了Runnable接口 ,process处理!
}
} catch (Throwable t) {
// This means we got an OOM or similar creating a thread, or that
// the pool and its queue are full
log.error(sm.getString("endpoint.process.fail"), t);
return false;
}
return true;
}
可能你会举得到这里,如果不通过线程池处理,那么是怎么把request传递给servlet的了?
通过分析下面的源码,好像getWorkThread().assign(socket) 并没有调用处理socket的方法?
注意createWorkThread()中的“newWorkerThread() ” , 通过这个方法,我们会创建一个线程,并且会启动,Work类的源代码 它是实现了Runnable接口的!
所以,总结Tomcat接收一个请求的过程 :
Tomcat启动,会启动一个Acceptor线程来监听请求 , 请求传入了时,得到相应的Socket,然后通过workStack 或者 Executor的方式,产生一个新的线程来处理,
在通过workStack 产生线程到处理的过程 : getWorkerThread() 调用createWorkerThread() 调用 newWorkerThread会产生一个Work thread , 并且start,但是
因为socket = await() , avaliable = false , 会阻塞,通过调用 assign() , 使得available = true 把最新的socket传递进去, run()方法运行,处理socket , 这就是assign()的作用。
但是 , 为什么要这么做了,直接new 出线程,然后run就是,就像executor一样!为什么这中间要添加这些额外的操作了?
为了保证线程得到的是最新的socket!!
newWorkerThread() :
/**
* Create and return a new processor suitable for processing HTTP
* requests and returning the corresponding responses.
*/
protected Worker newWorkerThread() {
Worker workerThread = new Worker();
workerThread.start(); //注意这里!!!!
return (workerThread);
}
getWrokThread() : // 不通过线程池的方式取得线程,将线程放在一个workStack中
/**
* Return a new worker thread, and block while to worker is available.
*/
protected Worker getWorkerThread() {
// Allocate a new worker thread
synchronized (workers) { // 注意同步
Worker workerThread;
while ((workerThread = createWorkerThread()) == null) {
try {
workers.wait(); // 如果不能取的线程,wait,因为你在server.xml中配置了maxThread;
} catch (InterruptedException e) {
// Ignore
}
}
return workerThread;
}
}
Work内部类: // 一个处理rquest的线程就是一个worker!
里面两个特别重要的方法,assign() 和 await() 都是同步
assgin 传递最新的socket!
而 await 则是在等候最新的socket!
protected class Worker implements Runnable {
protected Thread thread = null;
protected boolean available = false;
protected Socket socket = null;
// 将availabe 置为 true , 并唤醒所有等待的线程我知道了,assign的作用就是把最新的socket传递进来
synchronized void assign(Socket socket) {
// Wait for the Processor to get the previous Socket
while (available) {
try {
wait();
} catch (InterruptedException e) {
}
}
// Store the newly available Socket and notify our thread
this.socket = socket;
available = true;
notifyAll();
}
// 等候最新的socket
private synchronized Socket await() {
// Wait for the Connector to provide a new Socket
while (!available) {
try {
wait();
} catch (InterruptedException e) {
}
}
// Notify the Connector that we have received this Socket
Socket socket = this.socket;
available = false; // 将available置为false!
notifyAll();
return (socket);
}
// run方法
public void run() {
// Process requests until we receive a shutdown signal
while (running) {
// Wait for the next socket to be assigned
Socket socket = await(); // 调用这个方法时,除非调用assign()方法使的available为true,否则就会一直等待!而且现在锁已经加上来了,其他线程是不能够进来了!
if (socket == null) //
continue;
// Process the request from this socket
if (!setSocketOptions(socket) || !handler.process(socket)) { // 这两个方法跟线程池处理的一样
// Close socket
try {
socket.close();
} catch (IOException e) {
}
}
// Finish up this request
socket = null;
recycleWorkerThread(this);
}
}
public void start() {
thread = new Thread(this);
thread.setName(getName() + "-" + (++curThreads));
thread.setDaemon(true);
thread.start();
}
}
createWorkThread() ; 创建一个新的线程,调用newWorkerThread() 启动线程
/**
* Create (or allocate) and return an available processor for use in
* processing a specific HTTP request, if possible. If the maximum
* allowed processors have already been created and are in use, return
* <code>null</code> instead.
*/
protected Worker createWorkerThread() {
synchronized (workers) {
if (workers.size() > 0) { // 线程栈,可用的线程
curThreadsBusy++;
return workers.pop();
}
if ((maxThreads > 0) && (curThreads < maxThreads)) {
curThreadsBusy++;
if (curThreadsBusy == maxThreads) {
log.info(sm.getString("endpoint.info.maxThreads",
Integer.toString(maxThreads), address,
Integer.toString(port)));
}
return (newWorkerThread()); // 注意这个方法!!
} else {
if (maxThreads < 0) {
curThreadsBusy++;
return (newWorkerThread());
} else {
return (null);
}
}
}
}
SocketProcess的Run() :// 处理socket ,
public void run() {
// Process the request from this socket
if (!setSocketOptions(socket) || !handler.process(socket)) { // handler 处理socket 通过这个方法就会将request传递给servlet
// Close socket
try {
socket.close();
} catch (IOException e) {
}
}
// Finish up this request
socket = null;
}
2. 接收请求后,是怎么传递给相应的servlet处理的?
通过调用org.apache.coyote.http11.http11Protocol.process(socket) 方法!!