Java基础知识——BIO模式
文章目录
- 一、Java的I/O总述
-
-
-
- 1、I/O模型
- 2、应用
-
-
- 二、BIO模式
-
-
-
- 1、传统的服务器、客户端通信(一对一)：
- 2、服务器和客户端的通信(一对多)
- 3、伪异步IO编程
- 4、BIO模式下的文件上传
-
-
一、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(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();
}
}
}