AIO

原創 清风日 2018-08-30 16:32

AIO編程

    NIO 2.0引入了新的異步通道的概念，並提供了異步文件通道和異步套接字通道的實現。

    異步的套接字通道時真正的異步非阻塞I/O，對應於UNIX網絡編程中的事件驅動I/O（AIO）。他不需要過多的Selector對註冊的通道進行輪詢即可實現異步讀寫，從而簡化了NIO的編程模型。

    直接上代碼吧。

3.1、Server端代碼

    Server：

package com.anxpp.io.calculator.aio.server;
/**
 * AIO服務端
 * @author yangtao__anxpp.com
 * @version 1.0
 */
public class Server {
    private static int DEFAULT_PORT = 12345;
    private static AsyncServerHandler serverHandle;
    public volatile static long clientCount = 0;
    public static void start(){
        start(DEFAULT_PORT);
    }
    public static synchronized void start(int port){
        if(serverHandle!=null)
            return;
        serverHandle = new AsyncServerHandler(port);
        new Thread(serverHandle,"Server").start();
    }
    public static void main(String[] args){
        Server.start();
    }

}

AsyncServerHandler：

package com.anxpp.io.calculator.aio.server;
import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.channels.AsynchronousServerSocketChannel;
import java.util.concurrent.CountDownLatch;
public class AsyncServerHandler implements Runnable {
    public CountDownLatch latch;
    public AsynchronousServerSocketChannel channel;
    public AsyncServerHandler(int port) {
        try {
            //創建服務端通道
            channel = AsynchronousServerSocketChannel.open();
            //綁定端口
            channel.bind(new InetSocketAddress(port));
            System.out.println("服務器已啓動，端口號：" + port);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    @Override
    public void run() {
        //CountDownLatch初始化
        //它的作用：在完成一組正在執行的操作之前，允許當前的現場一直阻塞
        //此處，讓現場在此阻塞，防止服務端執行完成後退出
        //也可以使用while(true)+sleep
        //生成環境就不需要擔心這個問題，以爲服務端是不會退出的
        latch = new CountDownLatch(1);
        //用於接收客戶端的連接
        channel.accept(this,new AcceptHandler());
        try {
            latch.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

}

  AcceptHandler：

package com.anxpp.io.calculator.aio.server;
import java.nio.ByteBuffer;
import java.nio.channels.AsynchronousSocketChannel;
import java.nio.channels.CompletionHandler;
//作爲handler接收客戶端連接
public class AcceptHandler implements CompletionHandler<AsynchronousSocketChannel, AsyncServerHandler> {
    @Override
    public void completed(AsynchronousSocketChannel channel,AsyncServerHandler serverHandler) {
        //繼續接受其他客戶端的請求
        Server.clientCount++;
        System.out.println("連接的客戶端數：" + Server.clientCount);
        serverHandler.channel.accept(serverHandler, this);
        //創建新的Buffer
        ByteBuffer buffer = ByteBuffer.allocate(1024);
        //異步讀  第三個參數爲接收消息回調的業務Handler
        channel.read(buffer, buffer, new ReadHandler(channel));
    }
    @Override
    public void failed(Throwable exc, AsyncServerHandler serverHandler) {
        exc.printStackTrace();
        serverHandler.latch.countDown();
    }
}


ReadHandler：


  1. package com.anxpp.io.calculator.aio.server;
    import java.io.IOException;
    import java.io.UnsupportedEncodingException;
    import java.nio.ByteBuffer;
    import java.nio.channels.AsynchronousSocketChannel;
    import java.nio.channels.CompletionHandler;
    import com.anxpp.io.utils.Calculator;
    public class ReadHandler implements CompletionHandler<Integer, ByteBuffer> {
        //用於讀取半包消息和發送應答
        private AsynchronousSocketChannel channel;
        public ReadHandler(AsynchronousSocketChannel channel) {
                this.channel = channel;
        }
        //讀取到消息後的處理
        @Override
        public void completed(Integer result, ByteBuffer attachment) {
            //flip操作
            attachment.flip();
            //根據
            byte[] message = new byte[attachment.remaining()];
            attachment.get(message);
            try {
                String expression = new String(message, "UTF-8");
                System.out.println("服務器收到消息: " + expression);
                String calrResult = null;
                try{
                    calrResult = Calculator.cal(expression).toString();
                }catch(Exception e){
                    calrResult = "計算錯誤：" + e.getMessage();
                }
                //向客戶端發送消息
                doWrite(calrResult);
            } catch (UnsupportedEncodingException e) {
                e.printStackTrace();
            }
        }
        //發送消息
        private void doWrite(String result) {
            byte[] bytes = result.getBytes();
            ByteBuffer writeBuffer = ByteBuffer.allocate(bytes.length);
            writeBuffer.put(bytes);
            writeBuffer.flip();
            //異步寫數據 參數與前面的read一樣
            channel.write(writeBuffer, writeBuffer,new CompletionHandler<Integer, ByteBuffer>() {
                @Override
                public void completed(Integer result, ByteBuffer buffer) {
                    //如果沒有發送完，就繼續發送直到完成
                    if (buffer.hasRemaining())
                        channel.write(buffer, buffer, this);
                    else{
                        //創建新的Buffer
                        ByteBuffer readBuffer = ByteBuffer.allocate(1024);
                        //異步讀  第三個參數爲接收消息回調的業務Handler
                        channel.read(readBuffer, readBuffer, new ReadHandler(channel));
                    }
                }
                @Override
                public void failed(Throwable exc, ByteBuffer attachment) {
                    try {
                        channel.close();
                    } catch (IOException e) {
                    }
                }
            });
        }
        @Override
        public void failed(Throwable exc, ByteBuffer attachment) {
            try {
                this.channel.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

}

OK，這樣就已經完成了，其實說起來也簡單，雖然代碼感覺很多，但是API比NIO的使用起來真的簡單多了，主要就是監聽、讀、寫等各種CompletionHandler。此處本應有一個WriteHandler的，確實，我們在ReadHandler中，以一個匿名內部類實現了它。

    下面看客戶端代碼。

3.2、Client端代碼

    Client：

package com.anxpp.io.calculator.aio.client;
import java.util.Scanner;
public class Client {
    private static String DEFAULT_HOST = "127.0.0.1";
    private static int DEFAULT_PORT = 12345;
    private static AsyncClientHandler clientHandle;
    public static void start(){
        start(DEFAULT_HOST,DEFAULT_PORT);
    }
    public static synchronized void start(String ip,int port){
        if(clientHandle!=null)
            return;
        clientHandle = new AsyncClientHandler(ip,port);
        new Thread(clientHandle,"Client").start();
    }
    //向服務器發送消息
    public static boolean sendMsg(String msg) throws Exception{
        if(msg.equals("q")) return false;
        clientHandle.sendMsg(msg);
        return true;
    }
    @SuppressWarnings("resource")
    public static void main(String[] args) throws Exception{
        Client.start();
        System.out.println("請輸入請求消息：");
        Scanner scanner = new Scanner(System.in);
        while(Client.sendMsg(scanner.nextLine()));
    }

}

AsyncClientHandler：

package com.anxpp.io.calculator.aio.client;
import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.AsynchronousSocketChannel;
import java.nio.channels.CompletionHandler;
import java.util.concurrent.CountDownLatch;
public class AsyncClientHandler implements CompletionHandler<Void, AsyncClientHandler>, Runnable {
    private AsynchronousSocketChannel clientChannel;
    private String host;
    private int port;
    private CountDownLatch latch;
    public AsyncClientHandler(String host, int port) {
        this.host = host;
        this.port = port;
        try {
            //創建異步的客戶端通道
            clientChannel = AsynchronousSocketChannel.open();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    @Override
    public void run() {
        //創建CountDownLatch等待
        latch = new CountDownLatch(1);
        //發起異步連接操作，回調參數就是這個類本身，如果連接成功會回調completed方法
        clientChannel.connect(new InetSocketAddress(host, port), this, this);
        try {
            latch.await();
        } catch (InterruptedException e1) {
            e1.printStackTrace();
        }
        try {
            clientChannel.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    //連接服務器成功
    //意味着TCP三次握手完成
    @Override
    public void completed(Void result, AsyncClientHandler attachment) {
        System.out.println("客戶端成功連接到服務器...");
    }
    //連接服務器失敗
    @Override
    public void failed(Throwable exc, AsyncClientHandler attachment) {
        System.err.println("連接服務器失敗...");
        exc.printStackTrace();
        try {
            clientChannel.close();
            latch.countDown();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    //向服務器發送消息
    public void sendMsg(String msg){
        byte[] req = msg.getBytes();
        ByteBuffer writeBuffer = ByteBuffer.allocate(req.length);
        writeBuffer.put(req);
        writeBuffer.flip();
        //異步寫
        clientChannel.write(writeBuffer, writeBuffer,new WriteHandler(clientChannel, latch));
    }

}

 WriteHandler：

package com.anxpp.io.calculator.aio.client;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.AsynchronousSocketChannel;
import java.nio.channels.CompletionHandler;
import java.util.concurrent.CountDownLatch;
public class WriteHandler implements CompletionHandler<Integer, ByteBuffer> {
    private AsynchronousSocketChannel clientChannel;
    private CountDownLatch latch;
    public WriteHandler(AsynchronousSocketChannel clientChannel,CountDownLatch latch) {
        this.clientChannel = clientChannel;
        this.latch = latch;
    }
    @Override
    public void completed(Integer result, ByteBuffer buffer) {
        //完成全部數據的寫入
        if (buffer.hasRemaining()) {
            clientChannel.write(buffer, buffer, this);
        }
        else {
            //讀取數據
            ByteBuffer readBuffer = ByteBuffer.allocate(1024);
            clientChannel.read(readBuffer,readBuffer,new ReadHandler(clientChannel, latch));
        }
    }
    @Override
    public void failed(Throwable exc, ByteBuffer attachment) {
        System.err.println("數據發送失敗...");
        try {
            clientChannel.close();
            latch.countDown();
        } catch (IOException e) {
        }
    }

}

這個API使用起來真的是很順手。

    3.3、測試

    Test：

package com.anxpp.io.calculator.aio;
import java.util.Scanner;
import com.anxpp.io.calculator.aio.client.Client;
import com.anxpp.io.calculator.aio.server.Server;
/**
 * 測試方法
 * @author yangtao__anxpp.com
 * @version 1.0
 */
public class Test {
    //測試主方法
    @SuppressWarnings("resource")
    public static void main(String[] args) throws Exception{
        //運行服務器
        Server.start();
        //避免客戶端先於服務器啓動前執行代碼
        Thread.sleep(100);
        //運行客戶端
        Client.start();
        System.out.println("請輸入請求消息：");
        Scanner scanner = new Scanner(System.in);
        while(Client.sendMsg(scanner.nextLine()));
    }

}

我們可以在控制檯輸入我們需要計算的算數字符串，服務器就會返回結果，當然，我們也可以運行大量的客戶端，都是沒有問題的，以爲此處設計爲單例客戶端，所以也就沒有演示大量客戶端併發。

    讀者可以自己修改Client類，然後開闢大量線程，並使用構造方法創建很多的客戶端測試。

    下面是其中一次參數的輸出：

下面是其中一次參數的輸出：
  1. 服務器已啓動，端口號：12345
  2. 請輸入請求消息：
  3. 客戶端成功連接到服務器...
  4. 連接的客戶端數：1
  5. 123456+789+456
  6. 服務器收到消息: 123456+789+456
  7. 客戶端收到結果:124701
  8. 9526*56
  9. 服務器收到消息: 9526*56
  10. 客戶端收到結果:533456
  11. ...
    AIO是真正的異步非阻塞的，所以，在面對超級大量的客戶端，更能得心應手。
    下面就比較一下，幾種I/O編程的優缺點。



















    





發表評論














所有評論



還沒有人評論，想成為第一個評論的人麼? 請在上方評論欄輸入並且點擊發布.







相關文章








nginx截斷後端返回數據處理 13: Permission denied) while reading upstream






有個報表需求需要後端返回大量的數據，後端正常返回，但是頁面不出來，看瀏覽器的調用，
看提示是數據被截斷了。然後查看nginx的error log,在log中果然看到了具體的錯誤信息。
如下：
2019/11/12 12:27:33 [cr






 高尚10

2020-07-01 16:44:58









Java中垃圾回收機制的原理






ava中垃圾回收機制的原理
推薦一篇文章：
對高性能JAVA代碼之內存管理
更甚者你寫的代碼，GC根本就回收不了，直接系統掛掉。GC是一段程序，不是智能，他只回收他認爲的垃圾，而不是回收你認爲的垃圾。
GC垃圾回收：
Grabag






 高尚10

2020-07-01 16:44:58









第一章第一篇、深入ArrayList源碼分析






ArrayList簡介
概念
ArrayList是一個容量能夠動態增長的動態數組。和java的數組相比，它的容量能夠動態增長。它繼承了AbstractList,實現了List、RandomAccess、Cloneable、ja






 曲中散

2020-06-30 14:30:43









spring boot+mybatis+mysql簡單項目搭建






啥也不說，上代碼和部分解釋（本文使用idea開發工具）
創建spring boot項目非常簡單
1.
2.
 
3.
4.
直接next，改好你的存儲空間後，finish即可
因爲spring boot自己引入了maven依賴  ，所以需






 a_66666666666666

2020-06-27 07:50:48









解決Tomcat內存溢出pergmen






-Xms256m -Xmx512m -XX:PermSize=128M -XX:MaxNewSize=256m -XX:MaxPermSize=256m






 a_66666666666666

2020-06-27 07:50:48









手把手教你JavaEE的分頁查詢、分頁展示，有了這個，你的項目又多了一個談資






前言：
我們在寫項目的時候，往往有一些項目的信息展示。而展示的數據量往往是很大的，這時候，加入一個分頁的功能往往是最理想的選擇。
先簡單描述一下功能：
根據你的數據量和指定的頁面展示數據條數，進行查詢不同的數據，通過“首頁”、






 中冬廿九

2020-06-23 07:30:36









伍六七帶你學算法——棧的使用






大家都知道棧這種數據結構，它有非常多的應用場景。但如果我們不經常接觸這些應用場景的話，就可能不太熟悉棧的用法。
目錄smd1.棧的創建和使用JAVA Stack類：2.棧的實際應用示範解題如下👇
1.棧的創建和使用
JAVA






 中冬廿九

2020-06-23 07:30:33









javaEE實現分頁查詢






 中冬廿九

2020-04-25 12:18:38









簡單兩步，spring aop上手即用即會






 中冬廿九

2020-04-14 10:31:13









Window.open詳解






 xshf12345

2020-02-26 05:34:51









用JSP-Servlet構建三層式管理信息系統






 xshf12345

2020-02-26 05:34:51









java讀取excel所需jar包及代碼實現






 lewis_zhou

2020-02-25 14:53:55









IDEA超詳細使用介紹之一idea下載安裝及項目構造






 流一&

2020-02-23 21:33:46









java註解






 清风日

2020-02-23 08:45:59









java之動態代理






 清风日

2020-02-23 08:45:59