2. 程式人生 > >Java NIO簡單例項（入門）

Java NIO簡單例項（入門）

阿新 • • 發佈：2018-12-25

 最近學習了一下Java NIO的開發，剛開始接觸selector，覺得有點繞，弄的有點暈，所以在這裡寫幾個簡單的例子，記錄一下，也與大家分享一下，對剛開始學習NIO的同學，希望有一些幫忙。大神就請多指點了。
 開發穩定NIO對工程師的要求很高，NIO本身也存在很多的BUG，本文的例子只簡單的幫助簡單NIO的一些概念，對於一些例如TCP粘包/拆包等問題，不予以考慮。
 對於NIO的一些概念什麼的，就不在這裡闡述了，給大家推薦幾個文章，可以參考一下，裡面有詳細的解釋。
 Java NIO基本概念：
     （1） http://ifeve.com/java-nio-all/
     （2）

http://blog.csdn.net/jeffleo/article/details/54695959?locationNum=6
 Java NIO開發的注意事項：
     （1）http://blog.csdn.net/martin_liang/article/details/41224503

例項一：不使用selector實現埠通訊

import org.apache.log4j.Logger;

import java.io.IOException;
import java.net.InetSocketAddress;
import java.net.ServerSocket;
import java.nio.ByteBuffer;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.text.SimpleDateFormat;
import java.util.Date;

public
 
 class SocketTimePrint {
    private static final Logger logger = Logger.getLogger(SocketTimePrint.class);

    public static void main(String[] args) throws Exception{
        Thread server = new Thread(new ServerMsgNoselector());
        Thread client = new Thread(new ClientMsg());

        logger.info("Beginning to start the server for message"
 
);
        server.start();
        Thread.sleep(100);
        logger.info("Beginning to start the client for message");
        client.start();
    }
}

class ClientMsg implements Runnable {
    private static final Logger logger = Logger.getLogger(ClientMsg.class);

    @Override
    public void run() {
        try {
            SocketChannel socket = SocketChannel.open();
            socket.connect(new InetSocketAddress("127.0.0.1", 9999));
            socket.configureBlocking(false);
            SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            while (true) {
                String datestr = format.format(new Date());
                ByteBuffer buff = ByteBuffer.wrap(datestr.getBytes());
                socket.write(buff);
                Thread.sleep(2000);
            }
        } catch (IOException | InterruptedException ie) {
            ie.printStackTrace();
        }
    }
}

class ServerMsgNoselector implements Runnable {
    private static final Logger logger = Logger.getLogger(ServerMsgNoselector.class);

    @Override
    public void run() {
        try {
            ServerSocketChannel serverChannel = ServerSocketChannel.open();
            ServerSocket socket = serverChannel.socket();
            socket.bind(new InetSocketAddress(9999));
            serverChannel.configureBlocking(true);

            SocketChannel client = serverChannel.accept();
            client.configureBlocking(true);
            ByteBuffer buffer = ByteBuffer.allocate(1024);
            while(true) {
                int len = client.read(buffer);
                if (len > 0 && buffer.hasArray()) {
                    String msg = new String(buffer.array(), 0, len);
                    logger.info("The recvicing message is " + msg);
                } else {
                    logger.info("Waiting for message ...");
                }
                buffer.clear();
            }
        }catch(Exception ie) {
            ie.printStackTrace();
        }
    }
}

 例子很簡單，分別在兩個程序中啟動一個client與一個server，通過9999埠進行通訊。服務端的channel都設定為了阻塞模式。該例子中，只有一個客戶端與一個server，而當在實際應用時，client會有很多連線，我可能也不只監聽一個埠，這時就會出現各種問題（可能看一下《Netty權威指南》裡面對IO的基本概念及Java IO的演進有一個大致的介紹），而selector就是為了解決這些問題，以達到更高的效能。

例項二：基於selector實現的通訊

import org.apache.log4j.Logger;

import java.io.IOException;
import java.net.InetSocketAddress;
import java.net.ServerSocket;
import java.nio.ByteBuffer;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Iterator;

public class SocketSCMode {
    private static final Logger logger = Logger.getLogger(SocketSCMode.class);

    public static void main(String[] args) throws Exception{
        SocketSCMode leo = new SocketSCMode();
        leo.exe();
    }

    public void exe() throws InterruptedException{
        Thread server = new Thread(new ServerMsg());
        Thread client = new Thread(new ClientMsg());

        logger.info("Beginning to start the server for message");
        server.start();
        Thread.sleep(100);
        logger.info("Beginning to start the client for message");
        client.start();
    }

    class ClientMsg implements Runnable {
        @Override
        public void run() {
            try {
                SocketChannel socket = SocketChannel.open();
                socket.connect(new InetSocketAddress("127.0.0.1", 9999));
                socket.configureBlocking(false);
                SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
                while (true) {
                    String datestr = format.format(new Date());
                    ByteBuffer buff = ByteBuffer.wrap(datestr.getBytes());
                    //logger.info("Sending the message " + datestr);
                    socket.write(buff);
                    Thread.sleep(2000);
                }
            } catch (IOException | InterruptedException ie) {
                ie.printStackTrace();
            }
        }
    }

    class ServerMsg implements Runnable {
        @Override
        public void run() {
            logger.info("Enter the server thread");
            try {
                ServerSocketChannel serverChannel = ServerSocketChannel.open();
                ServerSocket socket = serverChannel.socket();
                socket.bind(new InetSocketAddress(9999));
                serverChannel.configureBlocking(false);
                Selector selector = Selector.open();
                SelectionKey serverKey = serverChannel.register(selector, SelectionKey.OP_ACCEPT);
                long flag = 1L;

                while (true) {
                    int count = selector.select();
                    if (count > 0) {
                        Iterator<SelectionKey> iter = selector.selectedKeys().iterator();
                        while (iter.hasNext()) {
                            SelectionKey key = iter.next();
                            logger.info("Flag-->" + flag + "   The interest is " + key.interestOps());
                            if (key.isAcceptable()) {
                                logger.info("Flag-->" + flag + "   The server accept one requesting");
                                iter.remove();
                                ServerSocketChannel server = (ServerSocketChannel) key.channel();
                                SocketChannel client = server.accept();
                                client.configureBlocking(false);
                                client.register(selector, SelectionKey.OP_READ);
                            } else if (key.isReadable()) {
                                iter.remove();
                                logger.info("Flag-->" + flag + "   Reading the mesage");
                                SocketChannel client = (SocketChannel) key.channel();
                                ByteBuffer buff = ByteBuffer.allocate(1024);
                                int len = client.read(buff);
                                if (len > 0 && buff.hasArray()) {
                                    byte[] arr = buff.array();
                                    String msg = new String(arr, 0, len);
                                    logger.info("Flag-->" + flag + "   The recevied message is " + msg);
                                }
                            }
                        }
                    }
                    flag++;
                }
            } catch (IOException ie) {
                ie.printStackTrace();
            }
        }
    }
}

 邏輯上與第一個例子完全一樣，要注意的是iter.remove()這個操作。
 在該例子中，把if (key.isAcceptable())下的remove操作去掉，會報一個空指標異常。過程如下：
 1、把ServerSocketChannel註冊到selector上，啟動client
 2、第一次select，發現ServerSocketChannel是acceptable的，即有已選擇的鍵（不然程序會阻塞在select方法上），因些，返回遍歷SelectionKey的iter（已選擇鍵的集合）
 3、進入if (key.isAcceptable())下的程式碼塊，通過accept返回一個SocketChannel與client進行通訊，並把這個SocketChannel註冊到selector上。遍歷結束
 4、此時server端接收了client的連線，client開發傳送資料。server再執行select方法，發現SocketChannel是Readable，再次返回已選擇鍵的集合
 5、由於第一次遍歷，ServerSocketChannel沒有從已選擇鍵的集合去掉，並且，selector不會更新已選擇鍵的集合中鍵的read集合，因此，遍歷iter時，會再次進入if (key.isAcceptable())，而此時，沒有client進行連線請求，因些，accept方法返回的是一下null，也就出現了空指標異常。

 如果我們去掉程式中的第二個remove會發生什麼？程序會一直阻塞在select方法中，因為select方法是增量的，已在已選擇鍵的集合中的channel，不會去再處理。也就是說，select方法，只有當已選擇鍵的集合有新元素新增時才會返回（這麼理解有點不準確。。。）

例項三：多人聊天室

 這個例子是參照別人的程式碼寫的，當然，沒人家寫的好，修修補補的，總算能按大概的意思運行了，提供給大家做反面教材吧（-_-!!!）

import org.apache.log4j.Level;
import org.apache.log4j.Logger;

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.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.text.SimpleDateFormat;
import java.util.*;

public class MultiplayerChat {

    static {
        Logger.getLogger(ServerMsgRoom.class).setLevel(Level.ERROR);
        Logger.getLogger(ClientMsgRoom.class).setLevel(Level.INFO);
    }

    public static void main(String[] args) throws Exception{
        Thread client1 = new Thread(new ClientMsgRoom(true), "leo");
        Thread client2 = new Thread(new ClientMsgRoom(true), "Makukin");
        Thread client3 = new Thread(new ClientMsgRoom(true), "Forrestleo");

        Thread server = new Thread(new ServerMsgRoom(), "ServerRoom");

        System.out.println("Start server ...");
        server.start();
        Thread.sleep(100);
        System.out.println("Start client");
        client1.start();
        client2.start();
        client3.start();
        server.join();
    }

    public static boolean canReadable(SocketChannel channel) {
        return (channel.validOps() & SelectionKey.OP_READ) == SelectionKey.OP_READ;
    }

    public static boolean canWriteable(SocketChannel channel) {
        return (channel.validOps() & SelectionKey.OP_WRITE) == SelectionKey.OP_WRITE;
    }
}

class ClientMsgRoom implements Runnable{
    private static final Logger logger = Logger.getLogger(ClientMsgRoom.class);
    private static final SimpleDateFormat format = new SimpleDateFormat("HH:mm:ss");

    private String name;
    private String HOST;
    private int PORT;
    private ByteBuffer buff;
    private boolean pringFlag;

    public ClientMsgRoom(boolean flag) {
        HOST = "127.0.0.1";
        PORT = 9999;
        buff = ByteBuffer.allocate(1024);
        pringFlag = flag;
    }

    @Override
    public void run() {
        name = Thread.currentThread().getName();
        try {
            SocketChannel client = SocketChannel.open();
            client.connect(new InetSocketAddress(HOST, PORT));
            client.configureBlocking(false);

            String headMsg = "Register : " + name + "\n";
            logger.info(headMsg);
            buff.put(headMsg.getBytes());
            buff.flip();
            while(buff.hasRemaining()) {
                client.write(buff);
            }
            logger.info("Register the client ... ");
            while(true) {
                boolean flag = false;
                if(MultiplayerChat.canReadable(client)){
                    int len = 0;
                    buff.clear();
                    while((len = client.read(buff)) > 0) {
                        String msg = new String(buff.array(), 0, len);
                        if(pringFlag)
                            System.out.println(name + "-->\n" + msg);
                        flag = true;
                    }
                }

                if(flag && MultiplayerChat.canWriteable(client)) {
                    String reMsg = name + "'s time is " + format.format(new Date()) + "\n";
                    //logger.info("Sending message  " + reMsg);
                    buff.clear();
                    buff.put(reMsg.getBytes());
                    buff.flip();
                    while(buff.hasRemaining()) {
                        client.write(buff);
                    }
                }
                Thread.sleep(5000);
            }
        }catch(IOException | InterruptedException ie) {
            ie.printStackTrace();
        }
    }
}

class ServerMsgRoom implements Runnable {
    private static final Logger logger = Logger.getLogger(ServerMsgRoom.class);

    private int PORT;
    private ByteBuffer buff;
    private Vector<SelectionKey> chaters;

    public ServerMsgRoom() {
        PORT = 9999;
        buff = ByteBuffer.allocate(1024);
        chaters = new Vector<>();
    }

    @Override
    public void run() {
        try {
            ServerSocketChannel server = ServerSocketChannel.open();
            server.configureBlocking(false);
            server.socket().bind(new InetSocketAddress(PORT));
            Selector selector = Selector.open();
            server.register(selector, SelectionKey.OP_ACCEPT);

            while(true) {
                int count = selector.select();
                if(count <= 0)
                    continue;

                logger.info("Begin to ack the keys and iter's size is " + count);
                Iterator<SelectionKey> iter = selector.selectedKeys().iterator();
                while(iter.hasNext()) {
                    SelectionKey key = iter.next();
                    if(key.isAcceptable()) {
                        ServerSocketChannel serverChannel = (ServerSocketChannel)key.channel();
                        SocketChannel socket = serverChannel.accept();
                        logger.info("Add one register");
                        socket.configureBlocking(false);
                        SelectionKey rkey = socket.register(selector, SelectionKey.OP_READ);
                        chaters.add(rkey);
                    }else if(key.isValid() && key.isReadable()) {
                        SocketChannel clientChannel = (SocketChannel)key.channel();
                        int len = 0;
                        StringBuilder builder = new StringBuilder();
                        buff.clear();
                        while((len = clientChannel.read(buff)) > 0) {
                            String msg = new String(buff.array(), 0 , len);
                            builder.append(msg);
                        }
                        logger.info("PrintMessage " + builder.toString());
                        Iterator<SelectionKey> iterWriter = chaters.iterator();
                        while(iterWriter.hasNext()) {
                            SelectionKey keyWriter = iterWriter.next();
                            List<String> list = (List<String>) keyWriter.attachment();
                            if (list == null) {
                                list = new ArrayList<>();
                                keyWriter.attach(list);
                            }
                            list.add(builder.toString());
                        }
                        key.interestOps(key.interestOps() | SelectionKey.OP_WRITE);
                    }else if(key.isValid() && key.isWritable()) {
                        List<String> list = (List<String>) key.attachment();
                        SocketChannel writer = (SocketChannel) key.channel();
                        if(list != null) {
                            logger.info("The attaching list is " + list.toString());
                            Iterator<String> iterReader = list.iterator();
                            while(iterReader.hasNext()) {
                                String message = iterReader.next();
                                buff.clear();
                                buff.put(message.getBytes());
                                buff.flip();
                                while(buff.hasRemaining()) {
                                    writer.write(buff);
                                }
                                logger.info("Writing message is " + message);
                                iterReader.remove();
                            }
                        }else{
                            logger.warn("The list is null");
                        }
                        key.interestOps(SelectionKey.OP_READ);
                    }
                    iter.remove();
                }
            }
        }catch(IOException ie) {
            ie.printStackTrace();
        }

    }
}

相關推薦

Java NIO簡單例項（入門）

 最近學習了一下Java NIO的開發，剛開始接觸selector，覺得有點繞，弄的有點暈，所以在這裡寫幾個簡單的例子，記錄一下，也與大家分享一下，對剛開始學習NIO的同學，希望有一些幫忙。大神就請多指點了。  開發穩定NIO對工程師的要求很高，NIO本身也

Linux下C++呼叫Java簡單例項（jni）

假設工作目錄為/home1. Java端1)  mkdir leixf && cd leixf2) 建立SubClass.java檔案，內容如下：package leixf;public class SubClass {private String name

差分約束系統簡單介紹（入門）

難點 兩個 技術 最短 短路徑 裏的 http 最大值 image 一直不知道差分約束是什麽類型題目，最近在寫最短路問題就順帶看了下，原來就是給出一些形如x-y<=b不等式的約束，問你是否滿足有解的問題 好神奇的是這類問題竟然可以轉換成圖論裏的最短路徑問題，下面開始詳

負載均衡演算法---Java的簡單實現（1）

最近，大夥常在談論什麼負載均衡，什麼伺服器的，而自己對於這一塊也是不太理解深入模糊，然後就去看書學習，印證自己的想法。下面是自己的一些總結吧：   比較常用的負載均衡演算法，有下面的這一些： （1）輪詢（其實就是迴圈） （2）隨機 （3）hash （4）加權輪詢

Java NIO Scatter/Gather（五）

有關 tar 圖片 http tutorials 動態 data 取數據 cat 原文鏈接：http://tutorials.jenkov.com/java-nio/scatter-gather.html，如有侵權，立刪 Java NIO Scatter/Gather S

Java NIO 學習筆記（一）----概述，Channel/Buffer

Java NIO （來自 Java 1.4）可以替代標準 IO 和 Java Networking API ，NIO 提供了與標準 IO 不同的使用方式。學習 NIO 之前建議先掌握標準 IO 和 Java 網路程式設計，推薦教程： 系統學習 Java IO----目錄，概覽 初步接觸 Java

Java NIO 學習筆記（二）----聚集和分散，通道到通道

目錄： Java NIO 學習筆記（一）----概述，Channel/Buffer Java NIO 學習筆記（二）----聚集和分散，通道到通道 Scatter / Gather 通道的聚集和分散操作 NIO 具有內建的 scatter/gather 支援，用於描述讀取和寫入通道的操作。 分散（

Java NIO 學習筆記（三）----Selector

目錄： Java NIO 學習筆記（一）----概述，Channel/Buffer Java NIO 學習筆記（二）----聚集和分散，通道到通道 Java NIO 學習筆記（三）----Selector 選擇器是一個 NIO 元件，它可以檢測一個或多個 NIO 通道，並確定哪些通道可以用於讀或寫了。 這樣

Java NIO 學習筆記（四）----檔案通道和網路通道

目錄： Java NIO 學習筆記（一）----概述，Channel/Buffer Java NIO 學習筆記（二）----聚集和分散，通道到通道 Java NIO 學習筆記（三）----Selector Java NIO 學習筆記（四）----檔案通道和網路通道 FileChannel 檔案通道 Fil

基於《仙劍奇俠傳柔情版》利用Java的簡單實現（一）

基於《仙劍奇俠傳柔情版》利用Java的簡單實現（一） 2018-12-01 23:55:36   by Louis  一，新建一個類GameFrame.class，具體程式碼如下： package firstDemo; import javax.swing.JF

Java NIO 學習筆記（六）----非同步檔案通道 AsynchronousFileChannel

目錄： Java NIO 學習筆記（一）----概述，Channel/Buffer Java NIO 學習筆記（二）----聚集和分散，通道到通道 Java NIO 學習筆記（三）----Selector Java NIO 學習筆記（四）----檔案通道和網路通道 Java NIO 學習筆記（五）----路徑

Java NIO 學習筆記（五）----路徑、檔案和管道 Path/Files/Pipe

目錄： Java NIO 學習筆記（一）----概述，Channel/Buffer Java NIO 學習筆記（二）----聚集和分散，通道到通道 Java NIO 學習筆記（三）----Selector Java NIO 學習筆記（四）----檔案通道和網路通道 Java NIO 學習筆記（五）----路徑

《仙劍奇俠傳柔情版》Java的簡單實現（二）

基於《仙劍奇俠傳柔情版》Java的簡單實現（二） 2018-12-02 by louis     需要上次的GameFrame.class中視窗框架承載：https://www.cnblogs.com/louis6575/p/10051873.html 當時沒有學過JButt

Java修煉之路（入門）——集合

集合概念介紹 同陣列一樣，集合是用來儲存資料的，就好比容器，陣列的長度是固定不可變的，是在建立時就要定義好的，而集合與陣列相比最顯著的一個特點就是它的長度是可變的，在儲存資料時根據實際儲存的容量自動擴充套件容量，而且集合操作簡便，但根據對資料操作的不同需求

Java NIO 詳解（一）

一、基本概念描述 1.1 I/O簡介 I/O即輸入輸出，是計算機與外界世界的一個藉口。IO操作的實際主題是作業系統。在java程式設計中，一般使用流的方式來處理IO，所有的IO都被視作是單個位元組的移動，通過stream物件一次移動一個位元組。流IO負責把物件轉換為位元組

Java NIO 詳解（二）

在我的上一篇文章JavaNIO詳解（一）中介紹了關於標準輸入輸出NIO相關知識， 本篇將重點介紹基於網路程式設計NIO（非同步IO）。 非同步IO 非同步 I/O 是一種沒有阻塞地讀寫資料的方法。通常，在程式碼進行 read() 呼叫時，程式碼會阻塞直至有可供讀取的資料。

Java NIO系列教程（一） Java NIO 概述

Java NIO 由以下幾個核心部分組成： Channels Buffers Selectors 雖然Java NIO 中除此之外還有很多類和元件，但在我看來，Channel，Buffer 和 Selector 構成了核心的API。其它元件，如P

Java NIO系列教程（二） Channel

Java NIO的通道類似流，但又有些不同： 既可以從通道中讀取資料，又可以寫資料到通道。但流的讀寫通常是單向的。 通道可以非同步地讀寫。 通道中的資料總是要先讀到一個Buffer，或者總是要從一個Buffer中寫入。 正如上面所說，從通道讀取資

Java NIO系列教程（四） Scatter/Gather

作者：Jakob Jenkov   譯者：郭蕾    Java NIO開始支援scatter/gather，scatter/gather用於描述從Channel（譯者注：Channel在中文經常翻譯為通道）中讀取或者寫入到Channel的操作。 分散（scatter）從Channel中讀取是

Java NIO系列教程（七） FileChannel

原文連結     作者：Jakob Jenkov     譯者：周泰      校對：丁一 Java NIO中的FileChannel是一個連線到檔案的通道。可以通過檔案通道讀寫檔案。 FileChannel無法設定為非阻塞模式，它總是執行在阻塞模式下。 開啟FileChannel 在使用F