网络编程复习（二）：JDK1.5之前的伪异步BIO编程

在JDK1.5之前并没有提供NIO非阻塞异步通信，在这里说一下什么是BIO：就是同步阻塞形式的通信模式，那么什么是NIO，就是同步非阻塞通信模式，同时，在JDK1.7之后，支持异步非阻塞通信模式，就是所说的NIO2.0.那么是怎么实现多个client连接服务器的呢？答案是使用的是伪异步方式，即自定义线程池加队列方式，下面看看代码：

client类：与上一篇没有任何变化

package 网络编程_最原始BIO2;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.Socket;

public class Client {
	public static void main(String[] args) {
		PrintWriter writer = null;
		BufferedReader reader = null;
		Socket client = null;
		try {
			client = new Socket("127.0.0.1", 8888);
			writer = new PrintWriter(client.getOutputStream(), true);//该地方必须加true，设置为自动刷新
			reader = new BufferedReader(new InputStreamReader(client.getInputStream()));
			writer.println("接收客户端发送请求");
			System.out.println("请求已经发出");
			String body = reader.readLine();
			System.out.println(body);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if (reader != null) {
				try {
					client.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
			if (writer != null) {
				writer.close();
			}
			if (client != null) {
				try {
					reader.close();
				} catch (IOException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
				client = null;
			}
		}
	}
}

server类：

package 网络编程_最原始BIO2;

import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;

import 网络编程_最原始.HanderSocket;

public class Server {
	static ServerSocket server = null;
	public static void main(String[] args) {
		try {
			server = new ServerSocket(8888);
			System.out.println("server start...");
			while(true){
				Socket socket = server.accept();
				new HanderPoolExecuter(50, 1000).executors(new HanderSocket(socket));
			}
		} catch (IOException e) {
			e.printStackTrace();
		}finally {
			if(server!=null){
				try {
					server.close();
				} catch (IOException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
				server = null;
			}
		}		
	}
}

HandlerPoolExecutor自定义线程池类：

package 网络编程_最原始BIO2;

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class HanderPoolExecuter {
    Integer initSize;
	Integer maxSize;
	private ExecutorService executorService;
	private BlockingQueue<Runnable> blockingQueue = new ArrayBlockingQueue<>(1000);
	public HanderPoolExecuter(int initSize,int maxSize){
		this.initSize = initSize;
		this.maxSize = maxSize;
		executorService = new ThreadPoolExecutor(initSize, maxSize, 60, TimeUnit.SECONDS, blockingQueue);
	}
	public void executors(Runnable task){
		executorService.execute(task);
	}
}

任务类HandlerSocket类，没有任何变化：

package 网络编程_最原始BIO2;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.Socket;

public class HanderSocket implements Runnable{
	Socket socket = null;
	public  HanderSocket(Socket socket) {
		this.socket = socket;
	}	
	@Override
	public void run() {
		BufferedReader reader = null;
		PrintWriter writer = null;
		try {
			reader = new BufferedReader(new InputStreamReader(this.socket.getInputStream()));
			writer = new PrintWriter(this.socket.getOutputStream(),true);
			String body = null;
			while(true){
				body = reader.readLine();
				if(body == null) break;
				System.out.println(body);
				writer.println("你好，服务端已经接收到你的请求");
				System.out.println("已经向客户端反馈结果");
			}
		} catch (Exception e) {
			e.printStackTrace();
		}finally {
			if(writer !=null){
					writer.close();
			}
			if(reader !=null){
				try {
					reader.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
			if(socket!=null){
				try {
					socket.close();
				} catch (IOException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
				socket = null;
			}
		}
	}

}

这种伪异步的方式其实还是阻塞形式的，并不适合当前开发场景，下一篇将介绍JDK1.7之后提供的非阻塞异步NIO通信方式。