KestrelServer是基于Libuv开发的高性能web服务器，那我们现在就来看一下它是如何工作的。在上一篇文章中提到了Program的Main方法，在这个方法里Build了一个WebHost，我们再来看一下代码：
public static void Main(string[] args)
{
var host = new WebHostBuilder()
.UseKestrel()
.UseContentRoot(Directory.GetCurrentDirectory())
.UseIISIntegration()
.UseStartup<Startup>()
.Build(); host.Run();
}
里面有一个UseKestrel方法调用，这个方法的作用就是使用KestrelServer作为web server来提供web服务。在WebHost启动的时候，调用了IServer的Start方法启动服务，由于我们使用KestrelServer作为web server，自然这里调用的就是KestrelServer.Start方法，那我们来看下KestrelServer的Start方法里主要代码：
首先，我们发现在Start方法里创建了一个KestrelEngine对象，具体代码如下：
var engine = new KestrelEngine(new ServiceContext
{
FrameFactory = context =>
{
return new Frame<TContext>(application, context);
},
AppLifetime = _applicationLifetime,
Log = trace,
ThreadPool = new LoggingThreadPool(trace),
DateHeaderValueManager = dateHeaderValueManager,
ServerOptions = Options
});
KestrelEngine构造方法接受一个ServiceContext对象参数，ServiceContext里包含一个FrameFactory，从名称上很好理解，就是Frame得工厂，Frame是什么？Frame是http请求处理对象，每个请求过来后，都会交给一个Frame对象进行受理，我们这里先记住它的作用，后面还会看到它是怎么实例化的。除了这个外，还有一个是AppLiftTime，它是一个IApplicationLifetime对象，它是整个应用生命周期的管理对象，前面没有说到，这里补充上。
public interface IApplicationLifetime
{
/// <summary>
/// Triggered when the application host has fully started and is about to wait
/// for a graceful shutdown.
/// </summary>
CancellationToken ApplicationStarted { get; } /// <summary>
/// Triggered when the application host is performing a graceful shutdown.
/// Requests may still be in flight. Shutdown will block until this event completes.
/// </summary>
CancellationToken ApplicationStopping { get; } /// <summary>
/// Triggered when the application host is performing a graceful shutdown.
/// All requests should be complete at this point. Shutdown will block
/// until this event completes.
/// </summary>
CancellationToken ApplicationStopped { get; } /// <summary>
/// Requests termination the current application.
/// </summary>
void StopApplication();
}
IApplicationLifetime中提供了三个时间点，
1，ApplicationStarted：应用程序已启动
2，ApplicationStopping：应用程序正在停止
3，ApplicationStopped：应用程序已停止
我们可以通过CancellationToken.Register方法注册回调方法，在上面说到的三个时间点，执行我们特定的业务逻辑。IApplicationLifetime是在WebHost的Start方法里创建的，如果想在我们自己的应用程序获取这个对象，我们可以直接通过依赖注入的方式获取即可。
我们继续回到ServiceContext对象，这里面还包含了Log对象，用于跟踪日志，一般我们是用来看程序执行的过程，并可以通过它发现程序执行出现问题的地方。还包含一个ServerOptions，它是一个KestrelServerOptions，里面包含跟服务相关的配置参数：
1，ThreadCount：服务线程数，表示服务启动后，要开启多少个服务线程，因为每个请求都会使用一个线程来进行处理，多线程会提高吞吐量，但是并不一定线程数越多越好，在系统里默认值是跟CPU内核数相等。
2，ShutdownTimeout：The amount of time after the server begins shutting down before connections will be forcefully closed（在应用程序开始停止到强制关闭当前请求连接所等待的时间，在这个时间段内，应用程序会等待请求处理完，如果还没处理完，将强制关闭）
3，Limits：KestrelServerLimits对象，里面包含了服务限制参数，比如MaxRequestBufferSize，MaxResponseBufferSize
其他参数就不再一个一个说明了。
KestrelEngine对象创建好后，通过调用 engine.Start(threadCount)，根据配置的threadcount进行服务线程KestrelThread实例化，代码如下：
public void Start(int count)
{
for (var index = ; index < count; index++)
{
Threads.Add(new KestrelThread(this));
} foreach (var thread in Threads)
{
thread.StartAsync().Wait();
}
}
上面的代码会创建指定数量的Thread对象，然后开始等待任务处理。KestrelThread是对libuv线程处理的封装。
这些工作都准备好后，就开始启动监听服务了
foreach (var endPoint in listenOptions)
{
try
{
_disposables.Push(engine.CreateServer(endPoint));
}
catch (AggregateException ex)
{
if ((ex.InnerException as UvException)?.StatusCode == Constants.EADDRINUSE)
{
throw new IOException($"Failed to bind to address {endPoint}: address already in use.", ex);
} throw;
} // If requested port was "0", replace with assigned dynamic port.
_serverAddresses.Addresses.Add(endPoint.ToString());
}
上面红色字体代码，就是创建监听服务的方法，我们再详细看下里面的详细情况：
public IDisposable CreateServer(ListenOptions listenOptions)
{
var listeners = new List<IAsyncDisposable>(); try
{
//如果前面创建的线程数量为1，直接创建listener对象，启动监听
if (Threads.Count == 1)
{
var listener = new Listener(ServiceContext);
listeners.Add(listener);
listener.StartAsync(listenOptions, Threads[0]).Wait();
}
else
{
//如果线程数不为1的时候
var pipeName = (Libuv.IsWindows ? @"\\.\pipe\kestrel_" : "/tmp/kestrel_") + Guid.NewGuid().ToString("n");
var pipeMessage = Guid.NewGuid().ToByteArray();
//先创建一个主监听对象，这个Listenerprimary就是一个Listener，监听socket就是在这里面创建的
var listenerPrimary = new ListenerPrimary(ServiceContext);
listeners.Add(listenerPrimary);
//启动监听
listenerPrimary.StartAsync(pipeName, pipeMessage, listenOptions, Threads[0]).Wait();
//为剩余的每个服务线程关联一个ListenerSecondary对象，这个对象使用命名Pipe与主监听对象通信，在主监听对象接收到请求后，通过pipe把接受的socket对象发送给特定的线程处理
foreach (var thread in Threads.Skip(1))
{
var listenerSecondary = new ListenerSecondary(ServiceContext);
listeners.Add(listenerSecondary);
listenerSecondary.StartAsync(pipeName, pipeMessage, listenOptions, thread).Wait();
}
} return new Disposable(() =>
{
DisposeListeners(listeners);
});
}
catch
{
DisposeListeners(listeners);
throw;
}
}
这个时候服务就开始接受http请求了，我们前面说到了，监听socket在listener类中创建（ListenerPrimary也是一个Listener），下面是listener的start方法
public Task StartAsync(
ListenOptions listenOptions,
KestrelThread thread)
{
ListenOptions = listenOptions;
Thread = thread; var tcs = new TaskCompletionSource<int>(this); Thread.Post(state =>
{
var tcs2 = (TaskCompletionSource<int>) state;
try
{
var listener = ((Listener) tcs2.Task.AsyncState);
//创建监听socket
listener.ListenSocket = listener.CreateListenSocket();
//开始监听,当有连接请求过来后，触发ConnectionCallback方法
ListenSocket.Listen(Constants.ListenBacklog, ConnectionCallback, this);
tcs2.SetResult(0);
}
catch (Exception ex)
{
tcs2.SetException(ex);
}
}, tcs); return tcs.Task;
}
ConnectionCallback：当连接请求过来后被触发，在回调方法里，进行连接处理分发，连接分发代码如下：
protected virtual void DispatchConnection(UvStreamHandle socket)
{
var connection = new Connection(this, socket);
connection.Start();
}
这个是listener类中的实现，我们前面看到，只有在线程数为1的情况下，才创建Listener对象进行监听，否则创建ListenerPrimary监听，ListenerPrimay里重写了方法，它的实现如下：
protected override void DispatchConnection(UvStreamHandle socket)
{
//这里采用轮询的方式，把连接请求依次分发给不同的线程进行处理
var index = _dispatchIndex++ % (_dispatchPipes.Count + 1);
if (index == _dispatchPipes.Count)
{
//
base.DispatchConnection(socket);
}
else
{
DetachFromIOCP(socket);
var dispatchPipe = _dispatchPipes[index];
//这里就是通过命名pipe，传递socket给特定的线程
var write = new UvWriteReq(Log);
write.Init(Thread.Loop);
write.Write2(
dispatchPipe,
_dummyMessage,
socket,
(write2, status, error, state) =>
{
write2.Dispose();
((UvStreamHandle)state).Dispose();
},
socket);
}
}
好了，连接请求找到处理线程后，后面就可以开始处理工作了。ListenerSecondary里的代码比较复杂，其实最终都会调用下面的代码完成Connection对象的创建
var connection = new Connection(this, socket);
connection.Start();
Connection表示的就是当前连接，下面是它的构造方法
public Connection(ListenerContext context, UvStreamHandle socket) : base(context)
{
_socket = socket;
_connectionAdapters = context.ListenOptions.ConnectionAdapters;
socket.Connection = this;
ConnectionControl = this; ConnectionId = GenerateConnectionId(Interlocked.Increment(ref _lastConnectionId)); if (ServerOptions.Limits.MaxRequestBufferSize.HasValue)
{
_bufferSizeControl = new BufferSizeControl(ServerOptions.Limits.MaxRequestBufferSize.Value, this);
}
//创建输入输出socket流
Input = new SocketInput(Thread.Memory, ThreadPool, _bufferSizeControl);
Output = new SocketOutput(Thread, _socket, this, ConnectionId, Log, ThreadPool); var tcpHandle = _socket as UvTcpHandle;
if (tcpHandle != null)
{
RemoteEndPoint = tcpHandle.GetPeerIPEndPoint();
LocalEndPoint = tcpHandle.GetSockIPEndPoint();
}
//创建处理frame，这里的framefactory就是前面创建KestrelEngine时创建的工厂
_frame = FrameFactory(this);
_lastTimestamp = Thread.Loop.Now();
}
然后调用Connection的Start方法开始进行处理，这里面直接把处理任务交给Frame处理，Start方法实现：
public void Start()
{
Reset();
//启动了异步处理任务开始进行处理
_requestProcessingTask =
Task.Factory.StartNew(
(o) => ((Frame)o).RequestProcessingAsync(),//具体的处理方法
this,
default(CancellationToken),
TaskCreationOptions.DenyChildAttach,
TaskScheduler.Default).Unwrap();
_frameStartedTcs.SetResult(null);
}
RequestProcessingAsync方法里不再详细介绍了，把主要的代码拿出来看一下：
。。。。。
//_application就是上一篇文章提到的HostApplication，首先调用CreateContext创建HttpContext对象
var context = _application.CreateContext(this);
。。。。。。
//进入处理管道
await _application.ProcessRequestAsync(context).ConfigureAwait(false);
。。。。。。
ProcessRequestAsync完成处理后，把结果输出给客户端，好到此介绍完毕。如果有问题，欢迎大家指点。
