一区二区三区在线-一区二区三区亚洲视频-一区二区三区亚洲-一区二区三区午夜-一区二区三区四区在线视频-一区二区三区四区在线免费观看

服務器之家：專注于服務器技術及軟件下載分享
分類導航

PHP教程|ASP.NET教程|Java教程|ASP教程|編程技術|正則表達式|C/C++|IOS|C#|Swift|Android|VB|R語言|JavaScript|易語言|vb.net|

服務器之家 - 編程語言 - Java教程 - java中BIO、NIO、AIO都有啥區別

java中BIO、NIO、AIO都有啥區別

2021-09-08 10:56Java面試一問一答（公眾號 Java教程

這篇文章主要介紹了java中BIO、NIO、AIO都有啥區別,IO模型就是說用什么樣的通道進行數據的發送和接收,Java共支持3種網絡編程IO模式：BIO，NIO，AIO,文中有非常詳細的代碼示例,對正在學習java的小伙伴們有非常好的幫助,需要的朋友可以

一、BIO(Blocking IO，也被稱作old IO)

同步阻塞模型，一個客戶端連接對應一個處理線程

對于每一個新的網絡連接都會分配給一個線程，每隔線程都獨立處理自己負責的輸入和輸出, 也被稱為Connection Per Thread模式

java中BIO、NIO、AIO都有啥區別

缺點：

1、IO代碼里read操作是阻塞操作，如果連接不做數據讀寫操作會導致線程阻塞，浪費資源

2、如果線程很多，會導致服務器線程太多，壓力太大，比如C10K問題

所謂c10k問題，指的是服務器同時支持成千上萬個客戶端的問題，也就是concurrent 10 000 connection

應用場景： BIO 方式適用于連接數目比較小且固定的架構， 這種方式對服務器資源要求比較高， 但程序簡單易理解。

示例代碼如下：

Bio服務端

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;
 
/**
 * @Title：BIO的服務端
 * @Author：wangchenggong
 * @Date 2021/4/13 9:41
 * @Description
 * @Version
 */
public class SocketServer {
 
    public static void main(String[] args) throws IOException {
        ServerSocket serverSocket = new ServerSocket(9000);
        while (true){
            System.out.println("等待連接...");
            Socket clientSocket = serverSocket.accept();
            System.out.println("客戶端"+clientSocket.getRemoteSocketAddress()+"連接了！");
 
            handle(clientSocket);
        }
 
    }
 
    private static void handle(Socket clientSocket)  throws IOException{
        byte[] bytes = new byte[1024];
        int read = clientSocket.getInputStream().read(bytes);
        System.out.println("read 客戶端"+clientSocket.getRemoteSocketAddress()+"數據完畢");
        if(read != -1){
            System.out.println("接收到客戶端的數據：" + new String(bytes, 0, read));
        }
        clientSocket.getOutputStream().write("HelloClient".getBytes());
        clientSocket.getOutputStream().flush();
    }
 
}

Bio客戶端

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
import java.io.IOException;
import java.net.Socket;
 
/**
 * @Title：BIO的客戶端
 * @Author：wangchenggong
 * @Date 2021/4/13 9:49
 * @Description
 * @Version
 */
public class SocketClient {
 
    public static void main(String[] args) throws IOException {
 
        Socket socket = new Socket("localhost", 9000);
        //向服務端發送數據
        socket.getOutputStream().write("HelloServer".getBytes());
        socket.getOutputStream().flush();
        System.out.println("向服務端發送數據結束");
 
        byte[] bytes = new byte[1024];
        //接收服務端回傳的數據
        socket.getInputStream().read(bytes);
 
        System.out.println("接收到服務端的數據：" + new String(bytes));
        socket.close();
    }
}

二、NIO(Non Blocking IO，本意也作new IO)

同步非阻塞，服務器實現模式為 一個線程可以處理多個連接請求（連接），客戶端發送的連接請求都會注冊到多路復用器selector上，多路復用器輪詢到連接有IO請求就進行處理，是在JDK1.4開始引入的。

應用場景：NIO方式適合連接數目多且連接比較短（輕操作）的架構，比如聊天服務器、彈幕系統、服務器之間通訊，編程相對復雜。

java中BIO、NIO、AIO都有啥區別

NIO 有三大核心組件： Channel(通道)， Buffer(緩沖區)，Selector(多路復用器)

1.channel類似于流，每個channel對應一個buffer緩沖區，buffer底層就是個數組

2.channel 會注冊到selector上，由selector根據channel讀寫事件的發生將其交由某個空閑的線程處理

3.NIO的Buffer和Channel都是可讀也可寫的。

NIO的代碼示例有兩個

沒有引入多路復用器的NIO

服務端

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
 
/**
 * @Title：Nio服務端
 * @Author：wangchenggong
 * @Date 2021/4/14 11:04
 * @Description
 * @Version
 */
public class NioServer {
 
    /**
     * 保存客戶端連接
     */
    static List<SocketChannel> channelList = new ArrayList<>();
 
    public static void main(String[] args) throws IOException {
        //創建Nio ServerSocketChannel
        ServerSocketChannel serverSocket = ServerSocketChannel.open();
        serverSocket.socket().bind(new InetSocketAddress(9000));
        //設置ServerSocketChannel為非阻塞
        serverSocket.configureBlocking(false);
        System.out.println("Nio服務啟動成功");
 
        while(true){
            //非阻塞模式accept方法不會阻塞
            /// NIO的非阻塞是由操作系統內部實現的，底層調用了linux內核的accept函數
            SocketChannel socketChannel = serverSocket.accept();
            if(socketChannel != null){
                System.out.println("連接成功");
                socketChannel.configureBlocking(false);
                channelList.add(socketChannel);
            }
 
            Iterator<SocketChannel> iterator = channelList.iterator();
            while(iterator.hasNext()){
                SocketChannel sc = iterator.next();
                ByteBuffer byteBuffer = ByteBuffer.allocate(128);
                //非阻塞模式read方法不會阻塞
                int len = sc.read(byteBuffer);
 
                if(len > 0){
                    System.out.println("接收到消息:" + new String(byteBuffer.array()));
                }else if(len == -1){
                    iterator.remove();
                    System.out.println("客戶端斷開連接");
                }
            }
 
        }
    }
}

客戶端

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.SocketChannel;
 
/**
 * @Title：Nio客戶端
 * @Author：wangchenggong
 * @Date 2021/4/14 11:36
 * @Description
 * @Version
 */
public class NioClient {
 
    public static void main(String[] args) throws IOException {
 
        SocketChannel socketChannel=SocketChannel.open(new InetSocketAddress("localhost", 9000));
        socketChannel.configureBlocking(false);
 
 
        ByteBuffer writeBuffer=ByteBuffer.wrap("HelloServer1".getBytes());
        socketChannel.write(writeBuffer);
        System.out.println("向服務端發送數據1結束");
 
        writeBuffer = ByteBuffer.wrap("HelloServer2".getBytes());
        socketChannel.write(writeBuffer);
        System.out.println("向服務端發送數據2結束");
 
        writeBuffer = ByteBuffer.wrap("HelloServer3".getBytes());
        socketChannel.write(writeBuffer);
        System.out.println("向服務端發送數據3結束");
    }
 
 
}

引入了多路復用器的NIO

服務端

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.*;
import java.util.Iterator;
import java.util.Set;
 
/**
 * @Title：引入多路復用器后的NIO服務端
 * @Author：wangchenggong
 * @Date 2021/4/14 13:57
 * @Description
 * SelectionKey.OP_ACCEPT —— 接收連接繼續事件，表示服務器監聽到了客戶連接，服務器可以接收這個連接了
 * SelectionKey.OP_CONNECT —— 連接就緒事件，表示客戶與服務器的連接已經建立成功
 * SelectionKey.OP_READ —— 讀就緒事件，表示通道中已經有了可讀的數據，可以執行讀操作了（通道目前有數據，可以進行讀操作了）
 * SelectionKey.OP_WRITE —— 寫就緒事件，表示已經可以向通道寫數據了（通道目前可以用于寫操作）
 *
 * 1.當向通道中注冊SelectionKey.OP_READ事件后，如果客戶端有向緩存中write數據，下次輪詢時，則會 isReadable()=true；
 *
 * 2.當向通道中注冊SelectionKey.OP_WRITE事件后，這時你會發現當前輪詢線程中isWritable()一直為true，如果不設置為其他事件
 * @Version
 */
public class NioSelectorServer {
 
    public static void main(String[] args) throws IOException {
 
        /**
         * 創建server端，并且向多路復用器注冊，讓多路復用器監聽連接事件
         */
        //創建ServerSocketChannel
        ServerSocketChannel serverSocket = ServerSocketChannel.open();
        serverSocket.socket().bind(new InetSocketAddress(9000));
        //設置ServerSocketChannel為非阻塞
        serverSocket.configureBlocking(false);
        //打開selector處理channel,即創建epoll
        Selector selector = Selector.open();
        //把ServerSocketChannel注冊到selector上，并且selector對客戶端的accept連接操作感興趣
        serverSocket.register(selector, SelectionKey.OP_ACCEPT);
        System.out.println("NioSelectorServer服務啟動成功");
 
 
        while(true){
            //阻塞等待需要處理的事件發生
            selector.select();
 
            //獲取selector中注冊的全部事件的SelectionKey實例
            Set<SelectionKey> selectionKeys = selector.selectedKeys();
            Iterator<SelectionKey> iterator = selectionKeys.iterator();
 
            //遍歷selectionKeys,對事件進行處理
            while (iterator.hasNext()){
                SelectionKey key = iterator.next();
                //如果是OP_ACCEPT事件，則進行連接和事件注冊
                if(key.isAcceptable()){
                    ServerSocketChannel serverSocketChannel = (ServerSocketChannel) key.channel();
                    //接受客戶端的連接
                    SocketChannel socketChannel = serverSocketChannel.accept();
                    socketChannel.configureBlocking(false);
                    //把SocketChannel注冊到selector上，并且selector對客戶端的read操作(即讀取來自客戶端的消息)感興趣
                    socketChannel.register(selector, SelectionKey.OP_READ);
                    System.out.println("客戶端"+socketChannel.getRemoteAddress()+"連接成功!");
 
                }else if(key.isReadable()){
                    SocketChannel socketChannel = (SocketChannel) key.channel();
                    ByteBuffer byteBuffer = ByteBuffer.allocate(128);
                    int len = socketChannel.read(byteBuffer);
                    if(len > 0){
                        System.out.println("接收到客戶端"+socketChannel.getRemoteAddress()+"發來的消息，消息內容為:"+new String(byteBuffer.array()));
                    }else if(len == -1){
                        System.out.println("客戶端斷開連接");
                        //關閉該客戶端
                        socketChannel.close();
                    }
                }
                //從事件集合里刪除本次處理的key，防止下次select重復處理
                iterator.remove();
            }
 
        }
 
        /**
         * NioSelectorServer服務啟動成功
         * 客戶端/127.0.0.1:57070連接成功!
         * 接收到客戶端/127.0.0.1:57070發來的消息，消息內容為:HelloServer
         * 客戶端/127.0.0.1:57121連接成功!
         * 接收到客戶端/127.0.0.1:57121發來的消息，消息內容為:HelloServer
         */
 
    }
}

客戶端

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.SocketChannel;
import java.util.Iterator;
import java.util.Set;
 
/**
 * @Title：引入多路復用器后的NIO客戶端
 * @Author：wangchenggong
 * @Date 2021/4/14 14:39
 * @Description
 * @Version
 */
public class NioSelectorClient {
 
    public static void main(String[] args) throws IOException {
 
        SocketChannel socketChannel = SocketChannel.open();
        socketChannel.configureBlocking(false);
        Selector selector = Selector.open();
        //要先向多路復用器注冊，然后才可以跟服務端進行連接
        socketChannel.register(selector, SelectionKey.OP_CONNECT);
        socketChannel.connect(new InetSocketAddress("localhost", 9000));
 
        while (true){
            selector.select();
            Set<SelectionKey> keys = selector.selectedKeys();
            Iterator<SelectionKey> iterator = keys.iterator();
            while (iterator.hasNext()){
                SelectionKey key = iterator.next();
                iterator.remove();
                if (key.isConnectable()){
                    SocketChannel sc = (SocketChannel) key.channel();
                    if (sc.finishConnect()){
                        System.out.println("服務器連接成功");
 
                        ByteBuffer writeBuffer=ByteBuffer.wrap("HelloServer".getBytes());
                        sc.write(writeBuffer);
                        System.out.println("向服務端發送數據結束");
                    }
                }
            }
        }
 
        /**
         * 服務器連接成功
         * 向服務端發送數據結束
         */
 
    }
}

三、AIO(Asynchronous IO) 即NIO2.0

異步非阻塞，由操作系統完成后回調通知服務端程序啟動線程去處理，一般適用于連接數較多且連接時間較長的應用。

應用場景：AIO方式適用于連接數目多且連接時間較長（重操作）的架構（應用），JDK7開始支持。

著名的異步網絡通訊框架netty之所以廢棄了AIO,原因是：在Linux系統上，NIO的底層實現使用了Epoll，而AIO的底層實現仍使用Epoll，沒有很好實現AIO，因此在性能上沒有明顯的優勢，而且被JDK封裝了一層不容易深度優 化，Linux上AIO還不夠成熟

AIO示例代碼如下：

服務端

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.AsynchronousServerSocketChannel;
import java.nio.channels.AsynchronousSocketChannel;
import java.nio.channels.CompletionHandler;
 
/**
 * @Title：Aio服務端
 * @Author：wangchenggong
 * @Date 2021/4/14 17:05
 * @Description
 * @Version
 */
public class AioServer {
 
    public static void main(String[] args) throws Exception {
        final AsynchronousServerSocketChannel serverChannel = AsynchronousServerSocketChannel.open().bind(new InetSocketAddress(9000));
        serverChannel.accept(null, new CompletionHandler<AsynchronousSocketChannel, Object>() {
            @Override
            public void completed(AsynchronousSocketChannel socketChannel, Object attachment) {
                try{
                    System.out.println("2--"+Thread.currentThread().getName());
                    //接收客戶端連接
                    serverChannel.accept(attachment,this);
                    System.out.println("客戶端"+socketChannel.getRemoteAddress()+"已連接");
 
                    ByteBuffer buffer = ByteBuffer.allocate(128);
                    socketChannel.read(buffer, null, new CompletionHandler<Integer, Object>() {
                        @Override
                        public void completed(Integer result, Object attachment) {
                            System.out.println("3--"+Thread.currentThread().getName());
                            //flip方法將Buffer從寫模式切換到讀模式
                            //如果沒有，就是從文件最后開始讀取的，當然讀出來的都是byte=0時候的字符。通過buffer.flip();這個語句，就能把buffer的當前位置更改為buffer緩沖區的第一個位置
                            buffer.flip();
                            System.out.println(new String(buffer.array(), 0, result));
                            socketChannel.write(ByteBuffer.wrap("hello Aio Client!".getBytes()));
                        }
 
                        @Override
                        public void failed(Throwable exc, Object attachment) {
                            exc.printStackTrace();
                        }
                    });
 
                }catch(Exception e){
                    e.printStackTrace();
                }
            }
 
            @Override
            public void failed(Throwable exc, Object attachment) {
 
            }
        });
 
        System.out.println("1‐‐main"+Thread.currentThread().getName());
        Thread.sleep(Integer.MAX_VALUE);
    }
    /**
     * 1‐‐mainmain
     * 2--Thread-9
     * 客戶端/127.0.0.1:54821已連接
     * 3--Thread-8
     * hello AIO server ！
     * 2--Thread-9
     * 客戶端/127.0.0.1:54942已連接
     * 3--Thread-7
     * hello AIO server ！
     */
 
}

客戶端

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.AsynchronousSocketChannel;
 
/**
 * @Title：Aio客戶端
 * @Author：wangchenggong
 * @Date 2021/4/14 16:56
 * @Description
 * @Version
 */
public class AioClient {
 
    public static void main(String[] args) throws Exception {
 
        //創建Aio客戶端
        AsynchronousSocketChannel socketChannel = AsynchronousSocketChannel.open();
        socketChannel.connect(new InetSocketAddress("localhost", 9000)).get();
        //發送消息
        socketChannel.write(ByteBuffer.wrap("hello AIO server ！".getBytes()));
        //接收消息
        ByteBuffer buffer = ByteBuffer.allocate(128);
        Integer len = socketChannel.read(buffer).get();
        if(len != -1){
            //客戶端收到消息:hello Aio Client!
            System.out.println("客戶端收到消息:"+new String(buffer.array(), 0, len));
        }
    }
 
 
}

四、總結

  BIO NIO AIO
IO模型 同步阻塞 同步非阻塞 異步非阻塞
編程難度 簡單 復雜 復雜
可靠性 好 差 好 好
吞吐量 低 高 高

到此這篇關于java中BIO、NIO、AIO都有啥區別的文章就介紹到這了,更多相關java中BIO、NIO、AIO的區別內容請搜索服務器之家以前的文章或繼續瀏覽下面的相關文章希望大家以后多多支持服務器之家！

原文鏈接：https://blog.csdn.net/wangchenggong88/article/details/115490767

延伸 · 閱讀

精彩推薦
  • Java教程20個非常實用的Java程序代碼片段

    20個非常實用的Java程序代碼片段

    這篇文章主要為大家分享了20個非常實用的Java程序片段，對java開發項目有所幫助，感興趣的小伙伴們可以參考一下 ...

    lijiao5352020-04-06
  • Java教程xml與Java對象的轉換詳解

    xml與Java對象的轉換詳解

    這篇文章主要介紹了xml與Java對象的轉換詳解的相關資料,需要的朋友可以參考下...

    Java教程網2942020-09-17
  • Java教程升級IDEA后Lombok不能使用的解決方法

    升級IDEA后Lombok不能使用的解決方法

    最近看到提示IDEA提示升級，尋思已經有好久沒有升過級了。升級完畢重啟之后，突然發現好多錯誤，本文就來介紹一下如何解決，感興趣的可以了解一下...

    程序猿DD9332021-10-08
  • Java教程Java8中Stream使用的一個注意事項

    Java8中Stream使用的一個注意事項

    最近在工作中發現了對于集合操作轉換的神器，java8新特性 stream，但在使用中遇到了一個非常重要的注意點，所以這篇文章主要給大家介紹了關于Java8中S...

    阿杜7472021-02-04
  • Java教程小米推送Java代碼

    小米推送Java代碼

    今天小編就為大家分享一篇關于小米推送Java代碼，小編覺得內容挺不錯的，現在分享給大家，具有很好的參考價值，需要的朋友一起跟隨小編來看看吧...

    富貴穩中求8032021-07-12
  • Java教程Java實現搶紅包功能

    Java實現搶紅包功能

    這篇文章主要為大家詳細介紹了Java實現搶紅包功能，采用多線程模擬多人同時搶紅包，文中示例代碼介紹的非常詳細，具有一定的參考價值，感興趣的小伙...

    littleschemer13532021-05-16
  • Java教程Java使用SAX解析xml的示例

    Java使用SAX解析xml的示例

    這篇文章主要介紹了Java使用SAX解析xml的示例，幫助大家更好的理解和學習使用Java，感興趣的朋友可以了解下...

    大行者10067412021-08-30
  • Java教程Java BufferWriter寫文件寫不進去或缺失數據的解決

    Java BufferWriter寫文件寫不進去或缺失數據的解決

    這篇文章主要介紹了Java BufferWriter寫文件寫不進去或缺失數據的解決方案，具有很好的參考價值，希望對大家有所幫助。如有錯誤或未考慮完全的地方，望...

    spcoder14552021-10-18
主站蜘蛛池模板： 色综合网亚洲精品久久 | 亚洲春色综合另类网蜜桃 | 免费国产高清视频 | 日本乱人伦中文在线播放 | 传说之下羊妈挤羊奶网站 | 国产成人精品s8sp视频 | 我们日本在线观看免费动漫下载 | 丝袜足控免费网站xx动漫漫画 | 亚洲免费在线观看视频 | 无人区乱码1区2区3区网站 | 国产精品亚洲精品日韩已满 | 国产精品国语自产拍在线观看 | 大胆暴露亚洲美女xxxx | 亚洲天堂网站在线 | 桃乃木香奈ipx在线播放 | 日韩一品在线播放视频一品免费 | 日日爽日日操 | 秋霞一级成人欧美理论 | 桥本有菜在线四虎福利网 | 校花被老头夺去第一次动图 | 1024免费永久福利视频 | 日韩精品免费一级视频 | 国产成人高清精品免费5388密 | jux539原千岁在线播放 | 国产在线观看人成激情视频 | 闺蜜的样子小说安沁在线阅读 | 日韩精品欧美 | 日韩一卡2卡3卡新区网站 | 青青在线国产视频 | 国产麻豆视频 | 视频一区国产精戏刘婷30 | 国内视频一区二区三区 | 国产精品一区二区在线观看完整版 | 国产精品免费一级在线观看 | 日本成人黄色片 | 歪歪视频在线播放无遮挡 | 男gay男gay男gay野外 | 午夜影院免费体验 | a级毛片毛片免费观看永久 a级黄色片免费 | 精品欧美小视频在线观看 | 午夜理论片日本中文在线 |