生意规模扩大

话说，老王和大明的生意越来越好，这就需要两个人增强业务往来，由于天南地北，两个人只能每次运输都需要雇一个人去运货(new 一个线程)，一个月下来，两人一算，人力成本太大了，光是雇佣人一个月就用了将近一百个人，本来生意旺盛，却还亏损了。两个人思来想去，想到了一个好主意，可以租个宿舍，就固定雇佣几个人，谁闲着谁就去运输，这样可以大大降低人的数量，又可以充分发挥人的效率。

其实上面这种思路就是服务端每次新连接客户端不在new一个线程，二是创建一个线程池，这样避免线程的大量创建，下面我们来用代码实现下以上的逻辑。

首先创建老王类，和昨天的BIO没有什么区别：

/**

* 伪异步请求 老王

*

* @author wangmj

* @since 2018/11/19

*/

public class FakeBioClient {

public static void main(String[] args) {

int port = 8761;

Socket socket = null;

PrintWriter out = null;

BufferedReader in = null;

try {

//创建客户端soket--老王

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

while (true) {

//获取输出流，向服务器发送消息

OutputStream os = socket.getOutputStream();

out = new PrintWriter(os, true);

out.println("今天给你发送东北特产100斤，发送时间：" + new Date());

System.out.println("老王的东北特产成功送出");

in = new BufferedReader(new InputStreamReader(socket.getInputStream()));

//收到服务端的响应

String resp = in.readLine();

System.out.println("收到大明的反馈=" + resp);

Thread.sleep(500);

}

} catch (IOException e) {

e.printStackTrace();

} catch (InterruptedException e) {

e.printStackTrace();

} finally {

if (out != null) {

out.close();

}

try {

if (in != null) {

in.close();

}

if (socket != null) {

socket.close();

}

} catch (IOException e) {

e.printStackTrace();

}

}

}

}

接着我们创建工人管理宿舍—线程池

/**

* @author wangmj

* @since 2018/11/19

*/

public class FakeBioServerExecutePool {

private ExecutorService executor;

public FakeBioServerExecutePool() {

executor = new ThreadPoolExecutor(Runtime.getRuntime().availableProcessors(), 100, 120L, TimeUnit.SECONDS, new ArrayBlockingQueue(5000));

}

public void execute(Runnable task) {

executor.execute(task);

}

}

有一点需要提醒，创建线程池不要用Excecutors类创建，尽量用new ThreadPoolExecutor创建，因为这样可以自己定义线程池参数，并且可以自己定义拒绝策略。

现在我们继续创建小美类，大明的具体业务处理对象：

/**

* @author wangmj

* @since 2018/11/19

*/

public class FakeBioServerHandler implements Runnable {

private Socket socket;

public FakeBioServerHandler(Socket socket) {

this.socket = socket;

}

public void run() {

BufferedReader in = null;

PrintWriter out = null;

try {

in = new BufferedReader(new InputStreamReader(socket.getInputStream()));

out = new PrintWriter(socket.getOutputStream(), true);

//从大明收到的特产

String messageFromDM = null;

while (true) {

messageFromDM = in.readLine();

if (messageFromDM == null) {

break;

}

System.out.println("收到老王的特产=" + messageFromDM);

out.println("老铁，已收到特产，接收时间：" + new Date());

System.out.println("通知老王已收到特产");

}

} catch (IOException e) {

e.printStackTrace();

} finally {

try {

if (in != null) {

in.close();

}

} catch (IOException e) {

e.printStackTrace();

}

if (out != null) {

out.close();

}

}

}

}

最后我们创建大明类：

/**

* 大明类，负责接收老王发过来的特产

*

* @author wangmj

* @since 2018/11/19

*/

public class FakeBioServer {

public static void main(String[] args) {

int port = 8761;

Socket socket = null;

try {

//创建大明类

ServerSocket serverSocket = new ServerSocket(port);

socket = serverSocket.accept();

System.out.println("创建大明类成功，并阻塞等待老王发送的特产");

FakeBioServerExecutePool executePool = new FakeBioServerExecutePool();

executePool.execute(new FakeBioServerHandler(socket));

} catch (IOException e) {

e.printStackTrace();

}

}

}

好，这样一条龙我们就都创建完毕，包括了客户端，服务端及服务端的线程池，让我们运行下查看结果，

客户端运行结果—老王类

服务端运行结果–大明类

原理分析

首先，这次创建的客户端及服务端还是基于BIO，也就是说读写还是会同步阻塞，只不过这次我们将服务端每次接收新的连接不是每次都new Thread创建线程，而是用线程池来管理线程，想以此来减少线程的创建，并且设定了一个最大任务队列；模型图如下(模型图用的processon画的，画的不怎么好)

分析：

当任务足够多，并且网络较差，造成一次IO的时间过多，就会造成队列堆积大量等待任务，由于服务端只有一个acceptor处理，新的客户端连接就会被拒绝，那么最终会导致队列中堆积大量的请求，同时客户端连接失败，服务端CPU飙升，系统崩溃，所以伪异步IO模型解决不了问题