Модель связи IO (2) Синхронный неблокирующий режим NIO (NonBlocking IO)

Java задняя часть

Привет, мир :) Поиск WeChat " Программист Аранг«Следуйте за мной как за специалистом по техническим инструментам.подобноПосмотрите еще раз, сила безгранична.

эта статьяGitHub.com/Ниу Мух/Java…а такжеБлог программиста АрангаБыл включен, есть много точек знаний и серии статей.

Синхронный неблокирующий режим (NonBlocking IO)

В неблокирующем режиме вызовите Socket'saccept()а такжеread()Во время работы, если данные в ядре не готовы, оно не блокирует пользовательский процесс, а сразу возвращает сообщение. То есть после того, как процесс инициирует операцию чтения, ему не нужно все время блокироваться и ждать, а он сразу получает результат.

Если окажется, что данные готовы, данные можно считать и скопировать в память пользователя. Если окажется, что данные не готовы, он также вернется, и процесс продолжится.主动询问Готовность данных — это функция неблокирующего режима.多路复用IOПредставление псевдокода выглядит следующим образом:

{
	while(read(socket, buffer) != SUCCESS){    
	}
	process(buffer);
}

Синхронный неблокирующий режим Java

Как упоминалось выше, Socket в Java является типичным приложением режима блокировки. инициацияaccpet()а такжеread()Он будет продолжать блокироваться после запроса, но Java предоставляетsetSoTimeout()Метод устанавливает время тайм-аута, если в течение фиксированного времени не будет получен результат, эта блокировка будет завершена и будет ожидаться следующая ротация блокировки. Это делается для достижения неблокировки на уровне приложения.

Сокет в JavasetSoTimeout()метод:

public synchronized void setSoTimeout(int timeout) throws SocketException {
    if (isClosed())
        throw new SocketException("Socket is closed");
    if (timeout < 0)
        throw new IllegalArgumentException("timeout can't be negative");
    getImpl().setOption(SocketOptions.SO_TIMEOUT, new Integer(timeout));
}

Кодирование в синхронном неблокирующем режиме Java

установивsetSoTimeout()сервер в режиме блокировкиaccpet()а такжеread()Оптимизирован для неблокирующего режима. SocketServerNioListenAndRead.java


import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;
import java.net.SocketException;
import java.net.SocketTimeoutException;

/**
 * <p>
 * 非阻塞IO - 监听非阻塞 - 读取非阻塞
 *
 * @Author niujinpeng
 * @Date 2018/10/15 14:53
 */
public class SocketServerNioListenAndRead {
    /**
     * 日志
     */
    private static final Logger logger = LoggerFactory.getLogger(SocketServerNioListenAndRead.class);
    private static Object xWait = new Object();

    public static void main(String[] args) throws IOException {
        ServerSocket serverSocket = null;

        try {
            serverSocket = new ServerSocket(83);
            serverSocket.setSoTimeout(100);
            while (true) {
                Socket socket = null;
                try {
                    socket = serverSocket.accept();
                } catch (SocketTimeoutException e) {
                    synchronized (SocketServerNioListenAndRead.xWait) {
                        logger.info("没有从底层接收到任务数据报文，等待10ms，，模拟事件X的处理时间");
                        SocketServerNioListenAndRead.xWait.wait(10);
                    }
                    continue;
                }

                InputStream input = socket.getInputStream();
                OutputStream output = socket.getOutputStream();
                Integer sourcePort = socket.getPort();
                int maxLen = 2048;
                byte[] contentBytes = new byte[maxLen];
                int realLen;
                StringBuffer message = new StringBuffer();

                // 接收消息非阻塞实现
                socket.setSoTimeout(10);

                BIORead:
                while (true) {
                    try {
                        // 读取的时候，程序会阻塞，知道系统把网络传过来的数据准备完毕
                        while ((realLen = input.read(contentBytes, 0, maxLen)) != -1) {
                            message.append(new String(contentBytes, 0, realLen));
                            /**
                             * 如果收到over，表示传送完毕
                             */
                            if (message.toString().endsWith("over")) {
                                break BIORead;
                            }
                        }
                    } catch (SocketTimeoutException e) {
                        //===========================================================
                        //      执行到这里，说明本次read没有接收到任何数据流
                        //      主线程在这里又可以做一些事情，记为Y
                        //===========================================================
                        logger.info("这次没有从底层接收到任务数据报文，等待10毫秒，模拟事件Y的处理时间");
                        continue;
                    }

                }

                // 输出信息
                logger.info("服务器收到来自端口" + sourcePort + "的消息：" + message.toString());
                // 响应
                output.write("Done!".getBytes());

                output.close();
                input.close();
                socket.close();
            }
        } catch (SocketException | InterruptedException e) {
            logger.error(e.getMessage(), e);
        } finally {
            if (serverSocket != null) {
                serverSocket.close();
            }
        }
    }

}

Вышеприведенный код может обеспечить неблокирующий мониторинг и чтение данных, но он может обрабатываться только один за другим, и может использоваться многопоточность.稍微改进. сервер сокетов n IO прослушивать thread.Java


import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.io.InputStream;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;
import java.net.SocketTimeoutException;

/**
 * <p>
 * 非阻塞IO - 监听非阻塞 - 读取非阻塞
 * 通过加入线程的概念，让socket server能够在应用层面
 * 通过非阻塞的方式同时处理多个socket套接字
 * <p>
 * 此时可以实现非阻塞的IO，但是因为调用了系统底层的阻塞同步IO，
 * 因此仍然没有从根本上解决问题
 *
 * @Author niujinpeng
 * @Date 2018/10/15 15:23
 */
public class SocketServerNioListenThread {

    private static Object xWait = new Object();

    private static final Logger LOGGER = LoggerFactory.getLogger(SocketServerNioListenThread.class);

    public static void main(String[] args) throws Exception {
        ServerSocket serverSocket = new ServerSocket(83);
        serverSocket.setSoTimeout(100);
        try {
            while (true) {
                Socket socket = null;
                try {
                    socket = serverSocket.accept();
                } catch (SocketTimeoutException e1) {
                    //===========================================================
                    //      执行到这里，说明本次accept没有接收到任何TCP连接
                    //      主线程在这里就可以做一些事情，记为X
                    //===========================================================
                    synchronized (SocketServerNioListenThread.xWait) {
                        LOGGER.info("这次没有从底层接收到任何TCP连接，等待10毫秒，模拟事件X的处理时间");
                        SocketServerNioListenThread.xWait.wait(10);
                    }
                    continue;
                }
                //当然业务处理过程可以交给一个线程（这里可以使用线程池）,并且线程的创建是很耗资源的。
                //最终改变不了.accept()只能一个一个接受socket连接的情况
                SocketServerThread socketServerThread = new SocketServerThread(socket);
                new Thread(socketServerThread).start();
            }
        } catch (Exception e) {
            LOGGER.error(e.getMessage(), e);
        } finally {
            if (serverSocket != null) {
                serverSocket.close();
            }
        }
    }
}

/**
 * 当然，接收到客户端的socket后，业务的处理过程可以交给一个线程来做。
 * 但还是改变不了socket被一个一个的做accept()的情况。
 *
 * @author niujinpeng
 */
class SocketServerThread implements Runnable {

    /**
     * 日志
     */
    private static final Logger LOGGER = LoggerFactory.getLogger(SocketServerThread.class);

    private Socket socket;

    public SocketServerThread(Socket socket) {
        this.socket = socket;
    }

    @Override
    public void run() {
        InputStream in = null;
        OutputStream out = null;
        try {
            in = socket.getInputStream();
            out = socket.getOutputStream();
            Integer sourcePort = socket.getPort();
            int maxLen = 2048;
            byte[] contextBytes = new byte[maxLen];
            int realLen;
            StringBuffer message = new StringBuffer();
            //下面我们收取信息（设置成非阻塞方式，这样read信息的时候，又可以做一些其他事情）
            this.socket.setSoTimeout(10);
            BIORead:
            while (true) {
                try {
                    while ((realLen = in.read(contextBytes, 0, maxLen)) != -1) {
                        message.append(new String(contextBytes, 0, realLen));
                        /*
                         * 我们假设读取到“over”关键字，
                         * 表示客户端的所有信息在经过若干次传送后，完成
                         * */
                        if (message.indexOf("over") != -1) {
                            break BIORead;
                        }
                    }
                } catch (SocketTimeoutException e2) {
                    //===========================================================
                    //      执行到这里，说明本次read没有接收到任何数据流
                    //      主线程在这里又可以做一些事情，记为Y
                    //===========================================================
                    LOGGER.info("这次没有从底层接收到任务数据报文，等待10毫秒，模拟事件Y的处理时间");
                    continue;
                }
            }
            //下面打印信息
            Long threadId = Thread.currentThread().getId();
            LOGGER.info("服务器(线程：" + threadId + ")收到来自于端口：" + sourcePort + "的信息：" + message);

            //下面开始发送信息
            out.write("回发响应信息！".getBytes());

            //关闭
            out.close();
            in.close();
            this.socket.close();
        } catch (Exception e) {
            LOGGER.error(e.getMessage(), e);
        }
    }
}

Сводка синхронного неблокирующего режима

Пользователю необходимо непрерывно вызывать, пытаться считать данные и продолжать обрабатывать полученные данные до тех пор, пока чтение не завершится успешно. В течение всего процесса запроса ввода-вывода, хотя пользовательский поток может возвращаться сразу после инициации каждого запроса ввода-вывода, для ожидания данных ему все равно необходимо непрерывно опрашивать и повторять запрос, что потребляет много ресурсов ЦП. Как правило, эта модель редко используется напрямую, но функция неблокирующего ввода-вывода используется в других моделях ввода-вывода.

По сравнению с блокирующим режимом ввода-вывода сложность разработки выше, и он подходит для разработки сетевых приложений с небольшим параллелизмом и отсутствием необходимости своевременного реагирования.

Источник на гитхабе:GitHub.com/Ниу Мух/Java…
Ссылки на эту статью:Мультиплексирование ввода-вывода, AIO, BIO, NIO, синхронное, асинхронное, блокирующее и неблокирующее
Ссылки на эту статью:6.2 I/O Models

Привет, мир :) Я Аланг, передовой специалист по техническим инструментам, серьезно пишу статьи.

Нравятся комментариивсе ониталант, не только выглядит красивым и симпатичным, но и красиво говорит.

Статья постоянно обновляется, вы можете искать в WeChat " Программист Аранг"или посетите"Блог программиста Аранга"Читал в первый раз.

Ответить【материал】 Я подготовил различные серии знаний и обязательных к просмотру книг.

эта статьяGitHub.com/Ниу Мух/Java…Он был включен, есть много знаний и серии статей, добро пожаловать в Star.

Категории