目录
Java BIO基本介绍
- Java BIO就是传统的java io 编程，其相关的类和接口在java.io
- BlO(blocking I/O)：同步阻塞，服务器实现模式为一个连接一个线程，即客户端有连接请求时服务器就需要启动一个线程进行处理，如果这个连接不做任何事情会造成不必要的线程开销，可以通过线程池机制改善(实现多个客户连接服务器).
Java BIO工作机制
传统的BIO编程实例回顾
网络编程的基本模型是Client/Server模型，也就是两个进程之间进行相互通信，其中服务端提供位置信（绑定IP地址和端口)，客户端通过连接操作向服务端监听的端口地址发起连接请求，基于TCP协议下进行三次握手连接，连接成功后，双方通过网络套接字(Socket)进行通信。
传统的同步阻塞模型开发中，服务端ServerSocket负责绑定IP地址，启动监听端口;客户端Socket负责发起连接操作。连接成功后，双方通过输入和输出流进行同步阻塞式通信。
基于BIO模式下的通信，客户端-服务端是完全同步，完全耦合的。
1、BIO模式下发送和接收消息
服务端
/**
* 服务端接受消息
*/
public class Server {
public static void main(String[] args) {
try {
System.out.println("——服务端启动——");
//定义一个ServerSocket对象进行服务端的端口注册
ServerSocket ss = new ServerSocket(9999);
//监听客户端的socket链接请求
Socket socket = ss.accept();
//从socket管道中得到一个字节输入流对象
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();
}
}
}客户端
/**
* 客户端发送消息
*/
public class Client {
public static void main(String[] args) {
try {
//创建socket对象请求服务端的链接
Socket socket = new Socket("127.0.0.1",9999);
//从socket对象中获取一个字节输出流
OutputStream os = socket.getOutputStream();
//把字节输出流包装成一个打印流
PrintStream ps = new PrintStream(os);
ps.println("hello world!");
ps.flush();
} catch (IOException e) {
e.printStackTrace();
}
}
}2、BIO模式下多发和多收消息
服务端
/**
* 服务端可以反复的接收消息,
*/
public class Server {
public static void main(String[] args) {
try {
System.out.println("——服务端启动——");
//定义一个ServerSocket对象进行服务端的端口注册
ServerSocket ss = new ServerSocket(9999);
//监听客户端的socket链接请求
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();
}
}
}
客户端
/**
* 客户端可以反复的发送消息。
*/
public class Client {
public static void main(String[] args) {
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.print("请输入：");
String msg = sc.nextLine();
ps.println(msg);
ps.flush();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}3、BIO模式下接收多个客户端
打开idea点击运行
点击拷贝，然后点击apply和ok，然后点击运行
客户端分别输入信息发现只能接受第一个客户端的信息，因为服务端只有一个线程只能处理一个客户端的消息
服务端
/**
* 目标:实现服务端可以同时接收多个客户端的Socket通信需求。
* 思路:是服务端每接收到一个客户端socket请求对象之后都交给一个独立的线程
*/
public class Server {
public static void main(String[] args) {
ServerSocket ss = null;
try {
System.out.println("——服务端启动——");
//定义一个ServerSocket对象进行服务端的端口注册
ss = new ServerSocket(9999);
//监听客户端的socket链接请求
while (true){
Socket socket = ss.accept();
//创建一个独立的线程来处理与这个客户端的socket
new ServerThreadReader(socket).start();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
服务端使用多线程处理多个客户端
public class ServerThreadReader extends Thread{
private Socket socket;
public ServerThreadReader(Socket socket) {
this.socket = socket;
}
@Override
public void run() {
InputStream is = null;
try {
//从socket管道中得到一个字节输入流对象
is = socket.getInputStream();
//把字节输入流包装成一个缓冲字符输入流
BufferedReader br = new BufferedReader(new InputStreamReader(is));
String msg;
if ((msg = br.readLine()) != null){
System.out.println("服务端接收到："+msg);
}
} catch (IOException e) {
e.printStackTrace();
}
}
}客户端
/**
* 客户端
*/
public class Client {
public static void main(String[] args) {
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.print("请输入：");
String msg = sc.nextLine();
ps.println(msg);
ps.flush();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}结果显示服务端可以接受多个客户端发出的消息
小结
1.每个Socket接收到，都会创建一个线程，线程的竞争、切换上下文影响性能;
2.每个线程都会占用栈空间和CPU资源;
3.并不是每个socket都进行lO操作，无意义的线程处理;
4.客户端的并发访问增加时。服务端将呈现1:1的线程开销，访问量越大，系统将发生线程栈溢出，线程创建失败，最终导致进程宕机或者僵死，从而不能对外提供服务。
伪异步I/O编程
伪异步I/O的通信框架，采用线程池和任务队列实现，当客户端接入时将客户端的Socket封装成一个Task(该任务实现java.lang.Runnable线程任务接口)交给后端的线程池中进行处理。JDK的线程池维护一个消息队列和N个活跃的线程，对消息队列中Socket任务进行处理，由于线程池可以设置消息队列的大小和最大线程数，因此，它的资源占用是可控的，无论多少个客户端并发访问，都不会导致资源的耗尽和宕机。
服务端
/**
* 目标:开发实现伪异步通信架构
*/
public class Server {
public static void main(String[] args) {
try {
//定义一个ServerSocket对象进行服务端的端口注册
ServerSocket ss = new ServerSocket(9999);
//初始化一个线程池
HandlerSocketServerPool pool = new HandlerSocketServerPool(6,10);
//监听客户端的socket链接请求
while (true){
//2、定义一个循环接收客户端的Socket链接请求
Socket socket = ss.accept();
//3、把socket对象交给一个线程池进行处理
//把socket封装成一个任务对象交给线程池处理
Runnable target = new ServerRunnableTarget(socket);
pool.execute(target);
}
}catch (Exception e){
e.printStackTrace();
}
}
}创建一个线程池
/**
* 创建一个线程池来处理消息
*/
public class HandlerSocketServerPool {
//1、创建一个线程池的成员变量用于存储一个线程池对象
private ExecutorService executorService;
//2、创建这个类的对象的时候就需要初始化线程池对象
public HandlerSocketServerPool(int maxThread , int queueSize){
executorService = new ThreadPoolExecutor(3,maxThread,120,
TimeUnit.SECONDS ,new ArrayBlockingQueue<Runnable>(queueSize));
}
//3、提供一个方法来提交任务给线程池的任务队列来暂存，等着线程池来处理
public void execute(Runnable target){
executorService.execute(target);
}
}/**
* 创建多线程处理消息
*/
public class ServerRunnableTarget implements Runnable{
private Socket socket;
public ServerRunnableTarget(Socket socket){
this.socket = socket;
}
@Override
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();
}
}
}客户端
/**
* 客户端可以反复的发送消息。
*/
public class Client {
public static void main(String[] args) {
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.print("请输入：");
String msg = sc.nextLine();
ps.println(msg);
ps.flush();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}小结
伪异步io采用了线程池实现，因此避免了为每个请求创建一个独立线程造成线程资源耗尽的问题，但由于底层依然是采用的同步阻塞模型，因此无法从根本上解决问题。
如果单个消息处理的缓慢，或者服务器线程池中的全部线程都被阻塞，那么后续socket的i/o消息都将在队列中排队。新的Socket请求将被拒绝，客户端会发生大量连接超时。
基于BIO形式下的文件上传
服务端
/**
* 目标:服务端开发，可以实现接收客户端的任意类型文件，并保存到服务端磁盘
*/
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();
}
}
}public class ServerReaderThread extends Thread{
private Socket socket;
public ServerReaderThread(Socket socket) {
this.socket = socket;
}
@Override
public void run() {
OutputStream os = null;
try {
//1、得到一个数据输入流读取客户端发送过来的数据
DataInputStream dis = new DataInputStream(socket.getInputStream());
//2、读取客户端发送过来的文件类型
String suffix = dis.readUTF();
System.out.println("文件类型位："+suffix);
//3、定义一个字节输出管道负责把客户端发来的文件数据写出去
os = new FileOutputStream("E:\\photo\\server\\"+ UUID.randomUUID().toString()+suffix);
//4、从数据输入流中读取文件数据，写出到字节输出流中去
byte[] bytes = new byte[1024];
int len;
while ((len = dis.read(bytes)) != -1){
os.write(bytes,0,len);
}
System.out.println("服务器端接受文件成功！");
}catch (Exception e){
e.printStackTrace();
}finally {
try {
os.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
客户端
/**
* 目标:实现客户端上传任意类型的文件数据给服务端保存起来。
*/
public class Client {
public static void main(String[] args) {
try {
//1、请求与服务端的Socket链接
Socket socket = new Socket("127.0.0.1",8888);
//2、把字节输出流包装成一个数据输出流
DataOutputStream dos = new DataOutputStream(socket.getOutputStream());
//3、法发送上传文件的后缀给服务端
dos.writeUTF(".png");
//4、把文f件数据发送给服务嵩进行接收
InputStream is = new FileInputStream("E:\\photo\\figure\\1.png");
byte [] bytes = new byte[1024];
int len;
while ((len = is.read(bytes)) != -1){
dos.write(bytes,0,len);
}
dos.flush();
//通知服务端这边的数据发送完毕
socket.shutdownOutput();
}catch (Exception e){
e.printStackTrace();
}
}
}Java BIO模式下的端口转发思想
客户端
/**
*目标:BIO模式下的端口转发思想-服务端实现。
* 服务端实现的需求:
* 1、注册端口
* 2、接收客户端的socket连接，交给一个独立的线程来处理。
* 3、把当前连接的客户端socket存入到一个所谓的在线socket集合中保存
* 4、接收客户端的消息，然后推送给当前所有在线的socket接收。
*/
public class Server {
//定义一个静态集合
public static List<Socket> allSocketOnLine = new ArrayList<>();
public static void main(String[] args) {
try {
//
ServerSocket ss = new ServerSocket(9999);
while (true){
Socket socket = ss.accept();
//把登录的客户端socket存入到一个在线集合中去
allSocketOnLine.add(socket);
//为当前登录成功的socket分配一个独立的线程来处理与之通信
new ServerReaderThread(socket).start();
}
}catch (Exception e){
e.printStackTrace();
}
}
}public class ServerReaderThread extends Thread{
private Socket socket;
public ServerReaderThread(Socket socket) {
this.socket = socket;
}
@Override
public void run() {
try {
//1、从socket中去获取当前客户端的输入流
BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
String msg;
while ((msg = br.readLine()) != null){
//2、服务端接收到了客户端的消息之后，是需要推送给当前所有的在线socket
sendMsgToAllClient(msg);
}
}catch (Exception e){
System.out.println("当前有人下线了");
//从在线socket集合中移除本socket
Server.allSocketOnLine.remove(socket);
}
}
/**
* 把当前客户端发来的消息推送给全部在线的socket
* @param msg
*/
private void sendMsgToAllClient(String msg){
for (Socket sk : Server.allSocketOnLine) {
PrintStream ps = null;
try {
ps = new PrintStream(sk.getOutputStream());
} catch (IOException e) {
e.printStackTrace();
}
ps.println(msg);
ps.flush();
}
}
}
604
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
