Java Se : Java NIO（服务端）与BIO（客户端）通信

最新推荐文章于 2022-08-29 17:13:25 发布
最新推荐文章于 2022-08-29 17:13:25 发布
阅读量385 收藏 1
点赞数
文章标签： 运维 netty 操作系统
原文链接：http://www.cnblogs.com/f1194361820/p/4019575.html
版权

 

Java目前有三种IO相关的API了,下面简单的说一下:

BIO，阻塞IO，最常用的Java IO API，提供一般的流的读写功能。相信学习Java的人，都用过。

NIO，非阻塞IO，在JDK1.4中开始出现，大量应用与服务器端编程，用于提高并发访问的性能，常用的NIO框架有Netty，Mina。

AIO，异步IO，在JDK1.7开始出现。还没有了解过，等以后了解了再说。

 

阻塞、非阻塞，同步、异步

在写这篇文章前，在网上了解了一下，其中争议最的问题要数阻塞、非阻塞怎么理解，异步、同步怎么理解。

       由于每个人想法的不同，很难达到一个一致的答案，又没有真正的大牛出来给这一个准确的定义。这里也简单的说一下，我对这两组名词的理解。

 

1）阻塞、非阻塞

       我认为，BIO，NIO没有大家想的那么复杂，就是底层实现中进行数据的读写（IO）采取的两种方案，只不过非阻塞读写要比阻塞IO读写更快一些。

bio中的InputStream#read()是一个block方法。

 

2）同步、异步

       同步与异步，我认为说的并不是IO本身，我认为说的是程序采用的编程模型，也就是说采用的是同步的编程模型还是异步的编程模型。

      

       BIO、NIO，他们的区别是操作系统读写数据采用的方式，他们是Java中的概念，在Java领域，他们的底层实现采用的是同步的编程模型。所以说BIO、NIO都是同步的。

       AIO的底层实现应当是异步的编程模型，所以说它是异步IO。

 

这里我只是阐述了我对它们的理解，没有与大家争论到底怎么去理解他们。也许我没有大家想的那么深远，毕竟我只是学习了NIO不到一天时间而已。

 

 

 

 

针对BIO、NIO，服务器编程如何提高性能

       一个程序运行的快慢，一般有会受到两个因素的影响：1）程序代码是否高效，2）IO读写是否高效。曾经看过这么一幅图，大致内容是：一帮不同角色的人（程序员、运维、项目经理等角色的人）在一起讨论一个应用程序效率地下的问题。

程序员说的是：给我3个月时间，我能够让程序运行效率提高，当然了，我要调整代码的整体结构…

       运维说：…

       项目经理说：换用读写更快的硬件设备解决这个问题。

 

       故事我已经无法还原，但是这个故事说的内容就是程序优化带来的效率的提升远不及提高IO速度带来的提升。

 

相比于BIO，NIO就是从读写来提升效率的。性能对于服务器来说尤为重要，服务器端编程并不是都采用了NIO编程。

      

       Tomcat服务器内部，就有BIO、NIO两种方式。

 

1）BIO如何提高并发访问

 

BIO，是一种阻塞IO，服务器端使用BIO进行数据读写时，一般都是采用了一个Socket请求对应一个Thread的方式来提高性能的。

       但是一台服务器上，可以跑的线程数量也是有限制的：线程不是越多越好，毕竟线程间的切换，也是有不小的开销。也不是越少越好，线程太少，极端情况下一个线程，如果用一个线程来解决用户的并发访问，服务器接收一个客户的请求时，其他人都要处于等待状态。你访问网页，多数情况下超过5秒，估计你就关掉它了吧。

　　或者采用线程池方案。

 

2）采用NIO编程时 如何提高并发访问

采用选择器轮询可用通道，读写数据。具体的怎么做的就不说了，网上一大坨一大坨的，虽然网上大家写的大多是copy别人的。下面给会出一个例子，所以这里就不多说了，不知道的可以网上找相关的文章。

 

一个Thread下开一个Selector，一个Selector处理多个Socket通道（也就是多个用于请求），这样就是一个Thread线程可以同时处理多个用户请求。

 

 

孰优孰劣

       假若说，服务器设置同时处理1000个用户请求（也就是1000个处理用户请求的线程）。假若有10000个人来发请求。

如果采用BIO API编程，那么就同时只能为1000个人服务，其他的9000人就处于等待状态。

如果采用NIO API编程，也开启1000个线程，因为一个Thread可以同时处理多个用户请求，咱不说让它处理太多了，就处理10个吧，这样算下来，这个10000个用户请求，就都可以处理了。

 

BIO（客户端）与NIO（服务端）通信

       今天学习了NIO，就用NIO来处理浏览器用户请求吧。浏览器发送的肯定不是采用NIO API发送Socket请求的，肯定是使用了阻塞式IO，也就是对应于Java中的BIO了。

 

package com.fjn.other.nio.socket;

 

import java.io.IOException;

import java.io.InputStream;

import java.io.OutputStream;

import java.net.InetSocketAddress;

import java.net.ServerSocket;

import java.net.Socket;

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.util.ArrayList;

import java.util.Collection;

import java.util.Iterator;

import java.util.concurrent.Callable;

import java.util.concurrent.ExecutorService;

import java.util.concurrent.Executors;

 

@SuppressWarnings({ "unchecked" })

public class NioServer {

       ServerSocketChannel serverChannel;

       ServerSocket serverSocket;

       public final int port;

       private Selector selector;

       ByteBuffer buffer = ByteBuffer.allocate(1024);

 

       NioServer(final int port) {

              this.port = port;

       }

 

       void init() throws Exception {

 

              // 创建 ServerSocketChannel、ServerSocket

              serverChannel = ServerSocketChannel.open();

              serverSocket = serverChannel.socket();

              serverSocket.bind(new InetSocketAddress(port));

 

              // 设置通道为非阻塞模式

              serverChannel.configureBlocking(false);

 

              // 开启通道选择器，并注册 ServerSocketChannel

              selector = Selector.open();

              serverChannel.register(selector, SelectionKey.OP_ACCEPT);

       }

 

       void go() throws Exception {

              while (true) {

                     int num = selector.select();

                     if (num <= 0)

                            continue;

                     Iterator<SelectionKey> keyIter = selector.selectedKeys().iterator();

 

                     while (keyIter.hasNext()) {

                            final SelectionKey key = keyIter.next();

 

                            // 接收一个Socket连接

                            // key.isAcceptable（）如果为true，说明channnel支持accept（）,也就是说明是一个ServerSocketChannel

                            if (key.isAcceptable()) {

                                   SocketChannel clientChannel = serverChannel.accept();

                                   if (clientChannel != null) {

                                          clientChannel.configureBlocking(false);

                                          clientChannel.register(selector, SelectionKey.OP_READ

                                                        | SelectionKey.OP_WRITE);

                                   }

 

                            }

                            // 如果isReadable()为true,说明是一个SocketChannel

                            if (key.isReadable()) {

                                   String requestContent = read(key);

                                   // 业务处理

                                   // responseContent=doSomthing(requestContent);

                                   write(key, "ok" /* responseContent */);

                            }

 

                            keyIter.remove();

                     }

              }

       }

 

       // 从通道读取数据

       String read(SelectionKey key) throws Exception {

              SocketChannel socketChannel = (SocketChannel) key.channel();

              buffer.clear();// 这一步必须有

              int len = 0;

              StringBuffer str=new StringBuffer();

              while ((len = socketChannel.read(buffer)) > 0) {

                     byte[] bs = buffer.array();

                     String block=new String(bs, 0, len);

                     System.out.println("Server read: " + block);

                     str.append(block);

              }

              buffer.clear();

              return str.toString();

       }

 

       // 写数据到通道

       void write(SelectionKey key, String str) throws Exception {

              SocketChannel socketChannel = (SocketChannel) key.channel();

              buffer.clear();

              buffer.put(str.getBytes());

              buffer.flip();// 这一步必须有

              socketChannel.write(buffer);

       }

 

 

       public static void main(String[] args) throws Exception {

              final int port = 10000;

              NioServer server = new NioServer(port);

              server.init();

///========================================================

              // 接下来模拟3个Client并发访问服务器

              int poolsize = 3;

 

              ExecutorService pool = Executors.newFixedThreadPool(poolsize);

              Collection<Callable> tasks = new ArrayList<Callable>(10);

              final String clientname="clientThread";

              for (int i = 0; i < poolsize; i++) {

                     final int n = i;

 

                     // 若每一个Client都保持使用BIO方式发送数据到Server，并读取数据。

                     tasks.add(new Callable() {

 

                            @Override

                            public Object call() throws Exception {

 

                                   Socket socket = new Socket("127.0.0.1", port);

                                   final InputStream input = socket.getInputStream();

                                   final OutputStream out = socket.getOutputStream();

                                   final String clientname_n = clientname + "_" + n;

 

                                   // BIO读取数据线程

                                   new Thread(clientname_n + "_read") {

                                          @Override

                                          public void run() {

                                                 byte[] bs = new byte[1024];

                                                 while (true) {

                                                        try {

                                                               Thread.sleep(1000);

                                                        } catch (InterruptedException e) {

                                                               e.printStackTrace();

                                                        }

                                                        int len = 0;

                                                        try {

                                                               while ((len = input.read(bs)) != -1) {

                                                                      System.out.println("Clinet thread "

                                                                                    + Thread.currentThread()

                                                                                                  .getName() + " read: "

                                                                                    + new String(bs, 0, len));

                                                               }

                                                        } catch (IOException e) {

                                                               e.printStackTrace();

                                                        }

                                                 }

                                          }

                                   }.start();

 

                                   // BIO写数据线程

                                   new Thread(clientname_n + "_write") {

                                          @Override

                                          public void run() {

                                                 int a = 0;

                                                 while (true) {

 

                                                        try {

                                                               Thread.sleep(100);

                                                        } catch (InterruptedException e) {

                                                               e.printStackTrace();

                                                        }

                                                        String str = Thread.currentThread().getName()

                                                                      + " hello, " + a;

                                                        try {

                                                               out.write(str.getBytes());

                                                               a++;

                                                        } catch (IOException e) {

                                                               e.printStackTrace();

                                                        }

                                                 }

                                          }

                                   }.start();

 

                                   return null;

                            }

 

                     });

              }

              pool.invokeAll((Collection<? extends Callable<Object>>) tasks);

 

              server.go();

 

       }

}
View Code

上面的测试的是3个Client采用BIO API不断的并发的发送Socket 请求到Server端。Server采用NIO API处理Client的请求并作出响应，然后Client接收响应。

 

转载于:https://www.cnblogs.com/f1194361820/p/4019575.html

antui1957
关注
netty案例，netty4.1基础入门篇零《初入JavaIO之门BIO、NIO、AIO实战练习》
bugstack虫洞栈
10-06 2447
前言介绍 在Java中，提供了一些关于使用IO的API，可以供开发者来读写外部数据和文件，我们称这些API为Java IO。IO是Java中比较重要知识点，且比较难学习的知识点。并且随着Java的发展为提供更好的数据传输性能，目前有三种IO共存；分别是BIO、NIO和AIO。 Java BIO[Blocking I/O] | 同步阻塞I/O模式 BIO 全称Block-IO 是一种同步且阻塞...
Java网络编程进化史：从IO到NIO再到Netty
qq_30593663的博客
01-06 297
Java网络编程进化史：从IO到NIO再到Netty一、相关介绍（一）同步阻塞模式（Blocking IO）（二）同步非阻塞的模型（Non-Blocking IO）（三）Netty二、IO实例三、NIO实例四、Netty实例参考 一、相关介绍 （一）同步阻塞模式（Blocking IO） 1.传统的阻塞式通信流程 早期的 Java 网络相关的 API(java.net包) 使用 Socket(套接字)进行网络通信，不过只支持阻塞函数使用。 要通过互联网进行通信，至少需要一对套接字： 运行于服务器端的 Se
分别使用 BIO 和 NIO 的实现简易群聊系统
泡泡的博客
08-29 264
下面是BIO和NIO的原理结构图，可以看出使用BIO时，每个客户端都会独占一个线程，而使用NIO时，一个Selector选择器独占一个线程，一个选择器下面可以连接多个客户端，然后Selector开始轮询下面的每一个客户端，这就提高了线程的复用，所以叫非阻塞IO以上是 JDK 的原生 BIO 和 NIO 的使用 demo，代码的意思在注释里面基本都有写，但是写的不是很详细，因为我也没有完全弄懂，这东西要慢慢自己断点调试来研究，接下来会写 NIO 的框架——Netty。
java BIO,NIO在单服务器，多客户端通信上的应用
weixin_30794491的博客
07-19 118
1.BIO，即传统的阻塞式io方式 下面是具体的例子： server： package 多线程实现socket阻塞式通信; import java.io.DataInputStream; import java.io.DataOutputStream; import java.io.IOException; imp...
java nio 客户端_Java Se : Java NIO（服务端）与BIO（客户端）通信
weixin_39945445的博客
02-20 187
Java目前有三种IO相关的API了,下面简单的说一下:BIO，阻塞IO，最常用的Java IO API，提供一般的流的读写功能。相信学习Java的人，都用过。NIO，非阻塞IO，在JDK1.4中开始出现，大量应用与服务器端编程，用于提高并发访问的性能，常用的NIO框架有Netty，Mina。AIO，异步IO，在JDK1.7开始出现。还没有了解过，等以后了解了再说。阻塞、非阻塞，同步、异步在写这篇...
Java NIO学习笔记(三) 使用Selector客户端与服务器的通信
不能说的秘密的博客
05-11 1万+
之前在写一个即使通讯软件的时候使用了阻塞式IO来完成通讯，在服务器对于没一个客户端的链接，服务器都要启动一个线程来维持客户端的阻塞。虽然我使用了线程池来优化线程的开销，但难免还是有性能上的瓶颈
Java SE
纯小白私人博客
07-14 271
Java SE 基础知识、面试
（完整版）2022大厂Java八股文面试题库｜附答案
热门推荐
uuqaz的博客
05-05 1万+
Java基础 说下面向对象四大特性 Java语言有些特点 什么是Java程序的主类？应用程序和小程序的主类有何不同？ 访问修饰符public,private,protected,以及不写（默认）时的区别？ float f=3.4;是否正确？ Java有没有goto？ &和&&的区别？ Math.round(11.5) 等于多少？Math.round(-11.5)等于多少？ 用最有效率的方法计算2乘以8？ 什么是Java注释 Java有哪些数据类型 final
Java知识点概览
qq_48403611的博客
08-03 3482
java后端开发常见面试题总结
java Socket 客户端服务端对接正确写法（BIO）
weixin_30300523的博客
06-04 618
之前在工作中写过一些Socket客户端与服务端的代码，但是当时没有时间仔细研究，只能不报错先过的态度，对其细节了解不深，写的代码有各种问题也浑然不知，只是业务量级以及对接方对接代码没有出现出格的情况所以问题不得暴露。 首先通过单线程Socket做服务端是一种BIO的做法，这种做法会导致服务端只能同时接收一笔请求，性能非常差 下面我把BIO的代码帖一下，有需要的同学可以参考 服务端 pu...
Java BIO--实现服务端和客户端通信
昔木的博客
06-21 870
Java BIO--实现服务端和客户端连接前言 前言 第一次面试挂在了sSocket（我太菜），所以要补一下Io/socket的知识。 java中有三种Io：BIO、NIO、AIO 今天分享一下BIO吧，BIO全称 block input output ，它是一种阻塞的IO流 ...
java NIO 服务器与多客户端双向通信 非阻塞
MR.WU
05-25 1703
服务端代码： import java.io.BufferedReader; import java.io.IOException; import java.io.InputStreamReader; import java.net.InetSocketAddress; import java.nio.ByteBuffer; import java.nio.channels.SelectionKe
JAVA BIO 服务器与客户端实现示例
weixin_33766805的博客
11-17 243
代码只兼容JAVA 7及以上版本。 服务器端代码： 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 ...
BIO 实现Client与Server的通信
LoganMaaa的博客
08-14 721
    看了一篇BIO（同步阻塞）NIO（同步非阻塞）AIO（异步非阻塞）的文章，就是非阻塞IO，大家都知道，Java中的通信是通过流进行操作的。这样就会提出几个名词。阻塞，非阻塞，同步，异步。 同步 - 是针对通信机制而言的，同步是指当我发送一个请求后，我代码就要等待响应，否则不能执行接来下的代码。 异步 - 也是针对通信机制而言的，异步是指当我发送请求后，此时我还可以去做其他的事情，当有结...
Java 基于bio实现一个服务端/客户端程序
DRB321的博客
05-01 904
使用了线程池，N客户端--M线程，N可以大于M 利弊：这个虽然使用了线程池，比原始的bio（一个客户端《----》一个线程）更进一步，但是当客户端请求过多时，请求会被放到线程池的队列中，有可能会造成任务阻塞。 Client端代码 package CS.f2; import java.io.BufferedReader; import java.io.IOException; import...
NIO实现的简单的客户端与服务端通信(非阻塞)
清涵
05-07 1434
利用NIO的ServerSocketChannel实现的客户端与服务端通信基础知识一、使用 NIO 完成网络通信的三个核心： 通道（Channel）：负责连接 java.nio.channels.Channel 接口： |–SelectableChannel |–SocketChannel |–ServerSocketC
bio（sockect）或java的nio或netty实现的简单服务器
远行的博客
12-22 231
客户端 public class Client { public static void main(String args[]){ try { Socket client = new Socket("localhost",8080); OutputStream os=client.getOutputStream(); ...
什么是 NIO？ NIO 和 BIO、AIO 之间的区别是什么？NIO主要用来解决什么问题？面试问题？
weixin_41563161的博客
02-09 6519
什么是 NIO？ NIO 和 BIO、AIO 之间的区别是什么？NIO主要用来解决什么问题？面试问题？ 1 BIO，NIO，AIO都有什么区别，NIO的原理是什么？ BIO BIO：传统的网络通讯模型，就是BIO，同步阻塞IO， 其实就是服务端创建一个ServerSocket， 然后就是客户端用一个Socket去连接服务端的那个ServerSocket， ServerSocket接收到了一个...
Java NIO Socket编程：客户端与服务端消息通信示例
在Java NIO中，服务端和客户端的通信模型与传统IO有所不同。服务端需要创建一个ServerSocketChannel，配置为非阻塞模式，并绑定到一个端口上监听连接请求。当客户端的SocketChannel尝试连接时，服务端需要接受连接并...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值