本文首發個人博客：貓叔的博客 | MySelf
GitHub項目地址
一個輕量級、高效率的支持多端（應用與硬件Iot）的異步網絡應用通訊框架
前言
本文預設讀者已經了解了一定的Netty基礎知識，并能夠自己構建一個Netty的通信服務（包括客戶端與服務端）。那么你一定使用到了Channel，這是Netty對傳統JavaIO、NIO的鏈接封裝實例。
那么接下來讓我們來了解一下關于Channel的數據沖刷與線程安全吧。
數據沖刷的步驟
1、獲取一個鏈接實例
@Override
public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
//獲取鏈接實例
Channel channel = ctx.channel();
}
我將案例放在初學者最熟悉的channelRead方法中，這是一個數據接收的方法，我們自實現Netty的消息處理接口時需要重寫的方法。即客戶端發送消息后，這個方法會被觸發調用，所以我們在這個方法中進行本次內容的講解。
由上一段代碼，其實目前還是很簡單，我們借助ChannelHandlerContext（這是一個ChannelHandler與ChannelPipeline相交互并對接的一個對象。如下是源碼的解釋）來獲取目前的鏈接實例Channel。
/* Enables a {@link ChannelHandler} to interact with its {@link ChannelPipeline}
* and other handlers. Among other things a handler can notify the next {@link ChannelHandler} in the
* {@link ChannelPipeline} as well as modify the {@link ChannelPipeline} it belongs to dynamically.
*/
public interface ChannelHandlerContext extends AttributeMap, ChannelInboundInvoker, ChannelOutboundInvoker {
//......
}
2、創建一個持有數據的ByteBuf
@Override
public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
//獲取鏈接實例
Channel channel = ctx.channel();
//創建一個持有數據的ByteBuf
ByteBuf buf = Unpooled.copiedBuffer("data", CharsetUtil.UTF_8);
}
ByteBuf又是什么呢？
它是Netty框架自己封裝的一個字符底層對象，是一個對 byte[] 和 ByteBuffer NIO 的抽象類，更官網的說就是“零個或多個字節的隨機和順序可訪問的序列?！?，如下是源碼的解釋
/**
* A random and sequential accessible sequence of zero or more bytes (octets).
* This interface provides an abstract view for one or more primitive byte
* arrays ({@code byte[]}) and {@linkplain ByteBuffer NIO buffers}.
*/
public abstract class ByteBuf implements ReferenceCounted, Comparable<ByteBuf> {
//......
}
由上一段源碼可以看出，ByteBuf是一個抽象類，所以我們不能通過 new 的形式來創建一個新的ByteBuf對象。那么我們可以通過Netty提供的一個 final 的工具類 Unpooled（你將其看作是一個創建ByteBuf的工具類就好了）。
/**
* Creates a new {@link ByteBuf} by allocating new space or by wrapping
* or copying existing byte arrays, byte buffers and a string.
*/
public final class Unpooled {
//......
}
這真是一個有趣的過程，那么接下來我們僅需要再看看 copiedBuffer 這個方法了。這個方法相對簡單，就是我們將創建一個新的緩沖區，其內容是我們指定的 UTF-8字符集 編碼指定的 “data” ，同時這個新的緩沖區的讀索引和寫索引分別是0和字符串的長度。
3、沖刷數據
@Override
public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
//獲取鏈接實例
Channel channel = ctx.channel();
//創建一個持有數據的ByteBuf
ByteBuf buf = Unpooled.copiedBuffer("data", CharsetUtil.UTF_8);
//數據沖刷
channel.writeAndFlush(buf);
}
我相信大部分人都是直接這么寫的，因為我們經常理所當然的啟動測試，并在客戶端接受到了這個 “data” 消息。那么我們是否應該注意一下，這個數據沖刷會返回一個什么值，我們要如何才能在服務端知道，這次數據沖刷是成功還是失敗呢？
那么其實Netty框架已經考慮到了這個點，本次數據沖刷我們將得到一個 ChannelFuture 。
@Override
public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
//獲取鏈接實例
Channel channel = ctx.channel();
//創建一個持有數據的ByteBuf
ByteBuf buf = Unpooled.copiedBuffer("data", CharsetUtil.UTF_8);
//數據沖刷
ChannelFuture cf = channel.writeAndFlush(buf);
}
是的，他就是 Channel 異步IO操作的結果，它是一個接口，并繼承了Future<V>。（如下為源碼的解釋）
/**
* The result of an asynchronous {@link Channel} I/O operation.
*/
public interface ChannelFuture extends Future<Void> {
//......
}
既然如此，那么我們可以明顯的知道我們可以對其添加對應的監聽。
4、異步回調結果監聽
@Override
public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
//獲取鏈接實例
Channel channel = ctx.channel();
//創建一個持有數據的ByteBuf
ByteBuf buf = Unpooled.copiedBuffer("data", CharsetUtil.UTF_8);
//數據沖刷
ChannelFuture cf = channel.writeAndFlush(buf);
//添加ChannelFutureListener以便在寫操作完成后接收通知
cf.addListener(new ChannelFutureListener() {
@Override
public void operationComplete(ChannelFuture future) throws Exception {
//寫操作完成，并沒有錯誤發生
if (future.isSuccess()){
System.out.println("successful");
}else{
//記錄錯誤
System.out.println("error");
future.cause().printStackTrace();
}
}
});
}
好的，我們可以簡單的從代碼理解到，我們將通過對異步IO的結果監聽，得到本次運行的結果。我想這才是一個相對完整的 數據沖刷（writeAndFlush）。
測試線程安全的流程
對于線程安全的測試，我們將模擬多個線程去執行數據沖刷操作，我們可以用到 Executor 。
我們可以這樣理解 Executor ，是一種省略了線程啟用與調度的方式，你只需要傳遞一個 Runnable 給它即可，你不再需要去 start 一個線程。（如下是源碼的解釋）
/**
* An object that executes submitted {@link Runnable} tasks. This
* interface provides a way of decoupling task submission from the
* mechanics of how each task will be run, including details of thread
* use, scheduling, etc. An {@code Executor} is normally used
* instead of explicitly creating threads. For example, rather than
* invoking {@code new Thread(new(RunnableTask())).start()} for each
* of a set of tasks, you might use:...
*/
public interface Executor {
//......
}
那么我們的測試代碼，大致是這樣的。
final Channel channel = ctx.channel();
//創建要寫數據的ByteBuf
final ByteBuf buf = Unpooled.copiedBuffer("data",CharsetUtil.UTF_8).retain();
//創建將數據寫到Channel的Runnable
Runnable writer = new Runnable() {
@Override
public void run() {
ChannelFuture cf = channel.writeAndFlush(buf.duplicate());
cf.addListener(new ChannelFutureListener() {
@Override
public void operationComplete(ChannelFuture future) throws Exception {
//寫操作完成，并沒有錯誤發生
if (future.isSuccess()){
System.out.println("successful");
}else{
//記錄錯誤
System.out.println("error");
future.cause().printStackTrace();
}
}
});
}
};
//獲取到線程池的Executor的引用
Executor executor = Executors.newCachedThreadPool();
//提交到某個線程中執行
executor.execute(writer);
//提交到另一個線程中執行
executor.execute(writer);
這里，我們需要注意的是：
創建 ByteBuf 的時候，我們使用了 retain 這個方法，他是將我們生成的這個 ByteBuf 進行保留操作。
在 ByteBuf 中有這樣的一種區域： 非保留和保留派生緩沖區。
這里有點復雜，我們可以簡單的理解，如果調用了 retain 那么數據就存在派生緩沖區中，如果沒有調用，則會在調用后，移除這一個字符數據。（如下是 ByteBuf 源碼的解釋）
/*<h4>Non-retained and retained derived buffers</h4>
*
* Note that the {@link #duplicate()}, {@link #slice()}, {@link #slice(int, int)} and {@link #readSlice(int)} does NOT
* call {@link #retain()} on the returned derived buffer, and thus its reference count will NOT be increased. If you
* need to create a derived buffer with increased reference count, consider using {@link #retainedDuplicate()},
* {@link #retainedSlice()}, {@link #retainedSlice(int, int)} and {@link #readRetainedSlice(int)} which may return
* a buffer implementation that produces less garbage.
*/
好的，我想你可以自己動手去測試一下，最好再看看源碼，加深一下實現的原理印象。
這里的線程池并不是現實線程安全，而是用來做測試多線程的，Netty的Channel實現是線程安全的，所以我們可以存儲一個到Channel的引用，并且每當我們需要向遠程節點寫數據時，都可以使用它，即使當時許多線程都在使用它，消息也會被保證按順序發送的。
結語
最后，介紹一下，個人的一個基于Netty的開源項目：InChat
一個輕量級、高效率的支持多端（應用與硬件Iot）的異步網絡應用通訊框架
參考資料： 《Netty實戰》
