Java基础知识——BIO模式

最新推荐文章于 2024-04-18 10:52:39 发布
最新推荐文章于 2024-04-18 10:52:39 发布
阅读量2.7k 收藏 12
点赞数 3
分类专栏： Java学习笔记 文章标签： java 服务器 开发语言 bio
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_46025531/article/details/122619434
版权

文章目录

一、Java的I/O总述

I/O模型：就是用什么样的通道或者通信模式和架构进行数据的传输和接收，很大程度上决定了程序通信的性能，包括BIO、NIO、AIO

1、I/O模型

BIO： 同步并阻塞(传统阻塞型)，服务器实现模式为一个连接一个线程，即用户端有连接请求时服务器就需要启动一个线程进行处理，如果这个连接不做任何事情就会造成不必要的线程开销

在这里插入图片描述
NIO： 同步非阻塞，服务器实现模式为一个线程处理多个请求连接，即客户端发送的连接请求都会注册到多路复用器上，多路复用器轮询连接有I/O请求就进行处理
在这里插入图片描述

AIO： 异步非阻塞，服务器实现模式为一个有效请求一个线程，客户端的I/O请求都是由OS完成了再通知服务器应用去启动线程进行处理，一般适用于连接数较多且连接市场较长的应用

2、应用

BIO： 适用于连接数目较小且固定的架构，这种方式对服务器资源要求比较高，并发局限于应用中
NIO： 连接数目多且连接比较短(轻操作)架构，比如聊天服务器等
AIO： 用于连接数目多连接比较长(重操作)的架构，比如相册服务器

二、BIO模式

1、传统的服务器、客户端通信(一对一)：
package BIO;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.ServerSocket;
import java.net.Socket;

public class Server {
    public static void main(String[] args){
        System.out.println("服务端启动");
        try{
            //定义一个ServerSocket对象进行服务器端口注册
            ServerSocket ss = new ServerSocket(9999);
            //监听客户端的连接请求
            Socket socket = ss.accept();
            //从socket管道中得到一个字节输入流对象
            InputStream is = socket.getInputStream();
            //把字节输入流包装秤一个缓冲字符输入流
            BufferedReader br = new BufferedReader(new InputStreamReader(is));
            String msg;
            while((msg = br.readLine())!=null){
                System.out.println("服务器接收到："+msg);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}



package BIO;

import java.io.IOException;
import java.io.OutputStream;
import java.io.PrintStream;
import java.net.Socket;
import java.util.Scanner;

public class Client {
    public static void main(String[] args) throws IOException {
        //创建socket对象请求服务器的连接
        Socket socket = new Socket("127.0.0.1",9999);
        //从socket对象中获取一个字节输出流
        OutputStream os = socket.getOutputStream();
        //把字节输出流包装成一个打印流
        PrintStream ps = new PrintStream(os);
        Scanner sc = new Scanner(System.in);
        while(true){
            System.out.println("请说");
            String msg = sc.nextLine();
            ps.println(msg);
            ps.flush();
        }
    }
}

运行结果：
在这里插入图片描述
原因：while((msg = br.readLine())!=null){System.out.println(“服务器接到：”+msg); }服务器中要求接受到一行的数据，而客户端 ps.print(“hello world 服务器”);只是输出一堆文字而没有换行，所以服务器还在继续等待，但是客户端发完之后就挂掉了，因此服务端认为还没有接受到一行消息结果客户端就没了，所以才报错

结论：在以上通信中，服务端会一直等待客户端的消息，如果客户端没有进行消息的发送，服务端将一直进入阻塞状态。同时服务端是按照行获取消息的，这就意味着客户端也必须按照行进行消息发送，否则服务端将进入等待消息的阻塞状态

2、服务器和客户端的通信(一对多)

引入线程，一个线程处理一个客户端的请求

package BIO;

import javax.print.DocFlavor;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.ServerSocket;
import java.net.Socket;

public class Server {
    public static void main(String[] args){
        try{
            //注册端口
            ServerSocket ss = new ServerSocket(9999);
            //定义一个死循环，负责不断地接收客户端的socket请求
            while(true){
                Socket socket = ss.accept();
                //注册一个独立的线程来处理这个客户端的请求
                new ServerThreadReader(socket).start();
            }
        }catch (IOException e){
            e.printStackTrace();
        }
    }
}

class ServerThreadReader extends Thread {
    private Socket socket;
    public ServerThreadReader(Socket socket){
        this.socket = socket;
    }

    public void run(){
        try{
            //从socket对象中得到一个字节输入流
            InputStream is = socket.getInputStream();
            //使用缓冲字符输入流包装字节输入流
            BufferedReader br = new BufferedReader(new InputStreamReader(is));
            String msg;
            while((msg = br.readLine())!=null){
                System.out.println(msg);
            }
        }catch (Exception e){
            e.printStackTrace();
        }
    }
}

package BIO;

import java.io.IOException;
import java.io.OutputStream;
import java.io.PrintStream;
import java.net.Socket;  //创建socket对象请求服务器的连接

import java.util.Scanner;

public class Client {
    public static void main(String[] args) throws IOException {
        try{
            //创建socket对象请求服务器的连接
            Socket socket = new Socket("127.0.0.1",9999);
            //从socket对象中获取一个字节输出流
            OutputStream os = socket.getOutputStream();
            //把字节输出流包装成一个打印流
            PrintStream ps = new PrintStream(os);
            Scanner sc = new Scanner(System.in);
            while(true){
                System.out.println("请说");
                String msg = sc.nextLine();
                ps.println(msg);
                ps.flush();
            }
        }catch(IOException e){
            e.printStackTrace();
        }

    }
}
3、伪异步IO编程

在上述案例中：客户端的并发访问增加时。服务器将呈现1:1的线程开销，访问量越大，系统将发生线程栈溢出，线程创建失败，最终导致进程宕机或者僵死，从而不能对外提供服务。

可以采用伪异步IO通信框架，采用线程池的任务队列实现，当客户端接入时，将客户端的Socket封装成一个Task(该任务实现java.lang.Runnable线程任务接口)交给后端的线程池中进行处理。JDK的线程池维护一个消息队列和N个活跃的线程，对消息队列中的Socket任务进行处理，由于线程池可以设置消息队列的大小和最大线程数。因此，它的资源占用是可控的，无论多少个客户端并发访问，都不会导致资源的耗尽和宕机。

服务器端：

package BIO;

import jdk.internal.util.xml.impl.Input;
import sun.reflect.annotation.ExceptionProxy;

import javax.print.DocFlavor;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.ServerSocket;
import java.net.Socket;
import java.nio.Buffer;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import java.util.logging.Handler;

public class Server {
    public static void main(String[] args){
        try{
            ServerSocket ss = new ServerSocket(9999);
            //初始化一个线程池对象
            HandlerSocketServerPool pool = new HandlerSocketServerPool(6,10);
            while(true){
                Socket socket = ss.accept();
                //把socket封装成一个任务对象交给线程池处理
                Runnable target = new ServerRunnableTarget(socket);
                pool.execute(target);
            }
        }catch(Exception e){
            e.printStackTrace();
        }
    }

}

class HandlerSocketServerPool {
    //创建一个线程池的成员变量用于存储一个线程池对象
    private ExecutorService executorService;

    //初始线程池对象
    public HandlerSocketServerPool(int maxThreadNum, int queueSize){
        executorService = new ThreadPoolExecutor(3,maxThreadNum,120, TimeUnit.SECONDS,new ArrayBlockingQueue<Runnable>(queueSize));
    }

    //提供一个方法来提交任务给线程池的任务队列来暂存，等着线程池来处理
    public void execute(Runnable target){
        executorService.execute(target);
    }
}

class ServerRunnableTarget implements Runnable {
    private Socket socket;
    public ServerRunnableTarget(Socket socket){
        this.socket = socket;
    }
    public void run(){
        try{
            InputStream is = socket.getInputStream();
            BufferedReader br = new BufferedReader(new InputStreamReader(is));
            String msg;
            if((msg = br.readLine())!=null){
                System.out.println("服务端接收到："+msg);
            }
        }catch(Exception e){
            e.printStackTrace();
        }
    }
}

package BIO;

import java.io.IOException;
import java.io.OutputStream;
import java.io.PrintStream;
import java.net.Socket;  //创建socket对象请求服务器的连接

import java.util.Scanner;

public class Client {
    public static void main(String[] args) throws IOException {
        try{
            //创建socket对象请求服务器的连接
            Socket socket = new Socket("127.0.0.1",9999);
            //从socket对象中获取一个字节输出流
            OutputStream os = socket.getOutputStream();
            //把字节输出流包装成一个打印流
            PrintStream ps = new PrintStream(os);
            Scanner sc = new Scanner(System.in);
            while(true){
                System.out.println("请说");
                String msg = sc.nextLine();
                ps.println(msg);
                ps.flush();
            }
        }catch(IOException e){
            e.printStackTrace();
        }

    }
}
4、BIO模式下的文件上传

客户端：

package BIO;

import java.io.*;
import java.net.Socket;  //创建socket对象请求服务器的连接

import java.util.Scanner;
/*
    目标：实现客户端上传任意类型的文件数据给服务端保存起来
 */
public class Client {
    public static void main(String[] args) throws IOException {
        try{
            //1、请求与服务器的Socket进行连接
            Socket socket = new Socket("127.0.0.1",8888);
            //2、把字节输出流包装成一个数据输出流
            DataOutputStream dos = new DataOutputStream(socket.getOutputStream());
            //3、先发送上传文件的后缀给服务端
            dos.writeUTF(".png");
            //4、把文件数据发送给服务器进行接收
            InputStream is = new FileInputStream("c:\\d.txt");
            byte[] buffer = new byte[1024];
            int len;
            while((len = is.read(buffer))>0)
                dos.write(buffer,0,len);
            dos.flush();
            socket.shutdownOutput();//通知服务端数据发送完毕
        }catch(IOException e){
            e.printStackTrace();
        }

    }
}

服务器端：

package BIO;

import jdk.internal.util.xml.impl.Input;
import sun.reflect.annotation.ExceptionProxy;

import javax.print.DocFlavor;
import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
import java.nio.Buffer;
import java.util.UUID;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import java.util.logging.Handler;

public class Server {
    public static void main(String[] args){
        try{
            ServerSocket ss = new ServerSocket(8888);
            while(true){
                Socket socket = ss.accept();
                new ServerReaderThread(socket).start();
            }
        }catch(Exception e){
            e.printStackTrace();
        }
    }

}

class ServerReaderThread extends Thread {
    private Socket socket;
    public ServerReaderThread(Socket socket){
        this.socket = socket;
    }

    public void run(){
        try{
            //1、得到一个数据输入流读取客户端发送过来的数据
            DataInputStream dis = new DataInputStream(socket.getInputStream());
            //2、读取客户端发送过来的文件类型
            String suffix = dis.readUTF();
            //3、定义一个字节输出管道负责把客户端发来的文件数据写出去
            OutputStream os = new FileOutputStream("c:\\d.txt"+ UUID.randomUUID().toString()+suffix);
            //4、从数据输入流中读取文件数据，写出到字节输出流中取
            byte[] buffer = new byte[1024];
            int len;
            while((len = dis.read(buffer))>0)
                os.write(buffer,0,len);
        }catch(Exception e){
            e.printStackTrace();
        }
    }
}
Sunny_范
关注
  • 3
    点赞
  • 踩
  • 12
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java BIO Socke示例
11-24
Java BIO Socke示例，从简单socket到采用线程池处理socket
115个Java面试题和答案——终极（下）(1).rar
07-16
文档中的问题涵盖了Java语言的基础知识、进阶特性以及实际开发中的常见问题。下面，我们将对这些知识点进行详细阐述。 1. **Java基础** - **数据类型**：Java有两大类数据类型，包括基本数据类型（如int、char、...
Java面试常考的 BIO，NIO，AIO 总结
最新发布
weixin_45131680的博客
04-18 114
Java 中的 BIO、NIO和 AIO 理解为是 Java 语言对操作系统的各种 IO 模型的封装。程序员在使用这些 API 的时候，不需要关心操作系统层面的知识，也不需要根据不同操作系统编写不同的代码。只需要使用Java的API就可以了。在讲 BIO,NIO,AIO 之前先来回顾一下这样几个概念：同步与异步，阻塞与非阻塞。同步与异步同步就是发起一个调用后，被调用者未处理完请求之前，调用不返回。
BIO~~
m0_53157173的博客
01-15 298
BIO~~第一章 Java的I/O演进之路2.1 I/O 模型基本说明2.2 I/O模型Java BIOJava NIOJava AIO2.3 BIO、NIO、AIO 适用场景分析第三章 JAVA BIO深入剖析3.1 Java BIO 基本介绍3.2 Java BIO 工作机制3.3 传统的BIO编程实例回顾客户端案例如下服务端案例如下小结3.4 BIO模式下多发和多收消息客户端代码如下服务端代码如下小结3.5 BIO模式下接收多个客户端概述客户端案例代码如下服务端案例代码如下小结3.6 伪异步I/O编
BIO、NIO、AIO 介绍和适用场景分析(2)
2401_84413420的博客
04-17 579
总的来说，面试是有套路的，一面基础，二面架构，三面个人。最后，小编这里收集整理了一些资料，其中包括面试题（含答案）、书籍、视频等。希望也能帮助想进大厂的朋友《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取！[外链图片转存中…(img-JId3yDIU-1713308963990)]《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取！
Java网络编程（二）一文读懂BIO
mathGaosi的博客
06-28 147
上一篇文章聊到了linux的五种IO模型，这篇文章将讲解一下Java的BIO模式。
Java | IO 模式之 JavaBIO 应用
为了远大的理想，冲锋！
03-01 663
IO 模式之 JavaBIO
Java I/O大揭秘：BIO、NIO、AIO到底有何区别？
孤芳不自赏
06-22 545
这篇文章你值得一阅！讲技术我觉得应该让外行也能看明白，而不是一堆专业术语堆砌，像在读天书一般，到最后感觉云里雾里。
Java之BIO网络编程
敲代码的小小酥的博客
11-27 472
java BIO理解
java面试——上海-携程-Java高级.zip
09-26
1. **Java基础** - 内存管理：了解Java内存模型（堆、栈、方法区、本地方法栈）以及垃圾回收机制（GC），包括Minor GC、Major GC和Full GC。 - 数据类型：深入理解基本数据类型与引用数据类型的差异，以及自动装箱...
java面试——深圳-商汤科技-Java高级.zip
09-26
1. **Java基础**：Java是一种跨平台的面向对象编程语言，其特性包括封装、继承、多态等。理解类、对象、接口的概念，以及异常处理、集合框架（如ArrayList、LinkedList、HashMap等）的使用是必备的基础知识。 2. **...
java面试——杭州-阿里云-Java中级.zip
09-26
这个压缩包文件“java面试——杭州-阿里云-Java中级.zip”包含了一份详细的PDF文档，它可能涵盖了面试中常遇到的问题、技术要点以及解决策略。以下是基于Java中级工程师面试的一些关键知识点： 1. **基础语法**：...
java面试——杭州-蚂蚁金服-资深工程师.zip
09-26
"java面试——杭州-蚂蚁金服-资深工程师.zip" 这个标题表明这是一份关于Java技术的面试准备资料，特别针对的是在杭州的蚂蚁金服公司应聘资深工程师的职位。这意味着这份压缩包可能包含了针对Java语言、高级编程技巧...
深入探索Java BIO与NIO输入输出模型：基于文件复制和socket通信
码到三十五
02-02 1558
Java BIO和NIO是两种不同的I/O模型，它们在设计、工作原理和使用上有显著的区别。BIO是同步阻塞的I/O模型，它简单直接但性能有限；而NIO是同步非阻塞的I/O模型，它引入了多路复用器和缓冲区的概念，提高了系统的吞吐量和性能。在选择使用哪种模型时，需要根据具体的应用场景和需求进行权衡。如果并发连接数较少且对性能要求不高，可以选择使用BIO；如果并发连接数较多且对性能要求较高，可以选择使用NIO。
【转】I/O 模型
小楠的博客
05-26 179
转自： https://mp.weixin.qq.com/s/m1nK32og0DlWyp1rMhPbiA Java 中常见 I/O 模型有： 同步阻塞 BIO 同步非阻塞 NIO 异步非阻塞 AIO Socket 网络编程 网络编程中有一个重要的概念：Socket。 在网络通信的基本过程中，客户端和服务端通过一个双向的通信连接，实现数据的交换，连接的任意一端都可称为一个 Socket。 总结一下流程，可以简单描述为这四步： 服务端启动，监听指定端口，等待客户端连接 客户端尝试与服务端连接，建立可信
BIO&NIO模型
Crime11的博客
02-17 117
在JDK1.4出来之前，建立网络连接的时候采用BIO模式，也就是阻塞式连接，需要先在服务端启动一个ServerSocket，然后在客户端启动Socket来和服务端进行通信，默认情况下服务端需要等待请求，而客户端发送请求，建立连接后，服务端也需要等待客户端发送数据，完成通信。也就是说，这个时候，已经不是一个连接就要对应一个处理线程了，而是有效的请求，对应一个线程，当连接没有数据时，是没有工作线程来处理的。NIO也就是非阻塞式连接，它的出现解决了客户端需要等待客户端连接，占用CPU的弊端。
java网络编程模型之BIO、NIO、AIO
m0_74229735的博客
10-20 300
java网络编程模型中三种模型AIO、BIO、NIO的介绍与应用
Java -- 什么是BIO
ZeroWdd的博客
05-04 2119
Java – 什么是BIO 1. Java BIO 基本介绍 Java BIO 就是传统的java io编程， 其相关的类和接口在java.io。 BIO：同步阻塞，服务器实现模式为一个连接一个线程，即客户端有连接请求时服务器端就需要启动一个线程进行处理，如果这个连接不做任何事情会造成不必要的线程开销，可以通过线程池机制改善(实现多个客户连接服务器)。 BIO 方式适用于连接数目比较小且固定的架...
Java BIO
了凡
11-24 230
Java BIO Java BIO指的是blocking I/O，同步并阻塞式的IO 同步vs异步 同步和异步关注的是消息通信机制 (synchronous communication/ asynchronous communication) 所谓同步，就是在发出一个调用时，在没有得到结果之前，该调用就不返回。但是一旦调用返回，就得到返回值了。换句话说，就是由调用者主动等待这个调用的结果。 而异步则是相反，调用在发出之后，这个调用就直接返回了，所以没有返回结果。换句话说，当一个异步过程调用发出后，调用者不
java软件开发工程师面试题宝典
04-12
java基础、数据类型、编码、运算符、关键字、流程控制语句,面向对象,变量与方法,重写与重载,Java包,IO流,反射,常用API -String相关,包装类相关,集合,多线程 Java Web、设计模式、Spring/Spring MVC、Spring Boot/Spring Cloud、Hibernate、MyBatis、RabbitMQ、Zookeeper、MySQL、Redis、JVM,

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值