通过socket编程掌握IO流 —— BIO

一、本次目标

编写最简单的1:1的server:client，感受socket通信编程；
修改client为多线程，模拟多个client请求server，观测server响应；
封装server处理client请求方法，另开线程处理；
处理线程加入线程池管理，减轻server负荷；

二、动手实践

1、编写配置接口，包含默认服务端地址、端口等

package com.cjt.io;

public interface Config {

  String DEFAULT_ENCODE = "UTF-8";

  String DEFAULT_ADDR = "127.0.0.1";

  int DEFAULT_PORT = 6666;
}

2、编写时间工具类DateUtil，方便输出日志打印

package com.cjt.io;

import java.text.SimpleDateFormat;
import java.util.Date;

public class DateUtil {

  private final static String DEFAULT_PATTERN = "HH:mm:ss";

  public static String getCurTimeStr(){
    SimpleDateFormat sdf = new SimpleDateFormat(DEFAULT_PATTERN);
    return sdf.format(new Date());
  }
}

3、编写服务端代码

package com.cjt.io.bio;

import com.cjt.io.Config;
import com.cjt.io.DateUtil;

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

public class ServerBIO implements Config{

  private ServerSocket server;

  private ServerBIO(int port){
    try {
      server = new ServerSocket(port);
    } catch (IOException e) {
      e.printStackTrace();
    }
  }


  private void start() {
    System.out.println("[" + DateUtil.getCurTimeStr() + "]:服务端已经启动");
    try {
      while (true) {
        System.out.println("[" + DateUtil.getCurTimeStr() + "]:server循环获取client请求开始");
        // 阻塞，直到有客户端发起请求
        Socket socket = server.accept();
        System.out.println("[" + DateUtil.getCurTimeStr() + "]:有新的client连接啦");
        try (BufferedReader reader = new BufferedReader(new InputStreamReader(socket.getInputStream(), DEFAULT_ENCODE))){
          String line;
          StringBuilder builder = new StringBuilder();
          // 普通IO流会阻塞，所以这里的readLine()时间会根据客户端操作的时间而定
          while ((line = reader.readLine()) != null) {
            builder.append(line);
            builder.append(System.getProperty("line.separator"));
          }
          System.out.println("[" + DateUtil.getCurTimeStr() + "]:client传来消息");
          System.out.println(builder.toString());
        } catch (IOException e) {
          e.printStackTrace();
          break;
        }
      }
    } catch (IOException e) {
      e.printStackTrace();
    }
  }

  public static void main(String[] args){
    new ServerBIO(DEFAULT_PORT).start();
  }
}

4、编写客户端代码

package com.cjt.io.bio;

import com.cjt.io.Config;
import com.cjt.io.DateUtil;

import java.io.*;
import java.net.Socket;

public class ClientBIO implements Config {

  private String serverIp;

  private int port;

  private String msg;

  private int second;

  private ClientBIO(String serverIp, int port) {
    this.serverIp = serverIp;
    this.port = port;
  }

  private ClientBIO second(int second) {
    this.second = second;
    return this;
  }

  private ClientBIO msg(String msg) {
    this.msg = msg;
    return this;
  }

  private void sleep(int second) {
    try {
      Thread.sleep(second * 1000);
    } catch (InterruptedException e) {
      e.printStackTrace();
    }
  }

  public void send() {
    try (Socket socket = new Socket(serverIp, port)) {
      System.out.println("[" + DateUtil.getCurTimeStr() + "]:连接server成功");
      BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream(), DEFAULT_ENCODE));
      writer.write(msg);
      writer.flush();
      sleep(second);
      System.out.println("[" + DateUtil.getCurTimeStr() + "]:client写入消息" + msg);
    } catch (IOException e) {
      e.printStackTrace();
    }
  }


  public static void main(String[] args) {
    ClientBIO client_1 = new ClientBIO(DEFAULT_ADDR, DEFAULT_PORT).second(3).msg("我是第一个客户端");
    client_1.send();
  }
}

5、测试IO流的阻塞性

基于最简单的单线程方式我们分别实现了server和client的编写，这里不会详细阐述怎么读流，写数据，buffered流怎么用，主要是研究IO流的特性，更好地学会怎么处理高并发中的流处理。

首先启动ServerBIO，查看控制台：

[17:06:54]:服务端已经启动
[17:06:54]:server循环获取client请求开始

根据server的代码，可以发现目前就阻塞在server.accept()这个位置，然后我们再启动client的main方法，模拟了两个client一前一后发送请求，观察client的控制台：

[17:06:57]:连接server成功
[17:07:00]:client写入消息我是第一个客户端

同时切到server的控制台：

[17:06:54]:服务端已经启动
[17:06:54]:server循环获取client请求开始
[17:06:57]:有新的client连接啦
[17:07:00]:client传来消息
我是第一个客户端

[17:07:00]:server循环获取client请求开始

57秒client连接server成功，同时server打印“有新的client连接”，由于手动sleep的原因，直到00秒时client请求写入数据才完成，而server便一直阻塞在reader.readLine()这个位置，直接阻塞到00秒读取到client的消息，然后继续循环获取client阻塞在server.accept()这个位置。

这只是一个最最简单的socket通信模型，只有一个client请求，那么我们修改client实现Runnable接口，开启线程发送数据，模拟多个client并行访问server：

package com.cjt.io.bio;

import com.cjt.io.Config;
import com.cjt.io.DateUtil;

import java.io.*;
import java.net.Socket;

public class ClientBIO implements Config, Runnable {

  private String serverIp;

  private int port;

  private String msg;

  private int second;

  private ClientBIO(String serverIp, int port) {
    this.serverIp = serverIp;
    this.port = port;
  }

  private ClientBIO second(int second) {
    this.second = second;
    return this;
  }

  private ClientBIO msg(String msg) {
    this.msg = msg;
    return this;
  }

  private void sleep(int second) {
    try {
      Thread.sleep(second * 1000);
    } catch (InterruptedException e) {
      e.printStackTrace();
    }
  }

  @Override
  public void run() {
    try (Socket socket = new Socket(serverIp, port)) {
      System.out.println("[" + DateUtil.getCurTimeStr() + "]:连接server成功");
      BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream(), DEFAULT_ENCODE));
      writer.write(msg);
      writer.flush();
      sleep(second);
      System.out.println("[" + DateUtil.getCurTimeStr() + "]:client写入消息" + msg);
    } catch (IOException e) {
      e.printStackTrace();
    }
  }

  public static void main(String[] args) {
    ClientBIO client_1 = new ClientBIO(DEFAULT_ADDR, DEFAULT_PORT).second(3).msg("我是第一个客户端");
    new Thread(client_1).start();
    ClientBIO client_2 = new ClientBIO(DEFAULT_ADDR, DEFAULT_PORT).second(1).msg("我是第二个客户端");
    new Thread(client_2).start();
  }
}

运行client的main方法，观察client的控制台：

[17:21:44]:连接server成功
[17:21:44]:连接server成功
[17:21:45]:client写入消息我是第二个客户端
[17:21:47]:client写入消息我是第一个客户端

很明显多线程并行发送请求到server，由于client_2的sleep为1秒的原因，较client_1先打印，然后回到server的控制台：

[17:21:37]:服务端已经启动
[17:21:37]:server循环获取client请求开始
[17:21:44]:有新的client连接啦
[17:21:47]:client传来消息
我是第一个客户端

[17:21:47]:server循环获取client请求开始
[17:21:47]:有新的client连接啦
[17:21:47]:client传来消息
我是第二个客户端

[17:21:47]:server循环获取client请求开始

server这里控制台输出完全相反，44秒提示“有新的client连接啦”，这里是client_1，通过后面的msg也可以知道，然后在47秒读取完client_1后立即获取到client_2的连接，虽然client_2的sleep有1秒的时间，但是由于client_2的连接时间在44秒，所以数据早已准备就绪，但是server的线程阻塞在读取client_1了。

三、补充完善

1、封装server处理client请求，单独新开线程：

package com.cjt.io.bio;

import com.cjt.io.Config;
import com.cjt.io.DateUtil;

import java.io.*;
import java.net.Socket;

public class ClientHandler implements Runnable, Config {

  private Socket socket;

  ClientHandler(Socket socket) {
    this.socket = socket;
  }

  @Override
  public void run() {
    try {
      BufferedReader reader = new BufferedReader(new InputStreamReader(socket.getInputStream(), DEFAULT_ENCODE));
      String line;
      StringBuilder builder = new StringBuilder();
      // 普通IO流会阻塞，所以这里的readLine()时间会根据客户端操作的时间而定
      while ((line = reader.readLine()) != null) {
        builder.append(line);
        builder.append(System.getProperty("line.separator"));
      }
      System.out.println("[" + DateUtil.getCurTimeStr() + "]:client传来消息");
      System.out.println(builder.toString());
    } catch (IOException e) {
      e.printStackTrace();
    }
  }
}

同时修改server的start调用代码：

System.out.println("[" + DateUtil.getCurTimeStr() + "]:服务端已经启动");
while (true) {
  try {
    System.out.println("[" + DateUtil.getCurTimeStr() + "]:server循环获取client请求开始");
    // 阻塞，直到有客户端发起请求
    Socket socket = server.accept();
    System.out.println("[" + DateUtil.getCurTimeStr() + "]:有新的client连接啦");
    new Thread(new ClientHandler(socket)).start();
  } catch (IOException e) {
    e.printStackTrace();
    break;
  }
}

不需要修改client代码，直接启动server后，在启动client的main方法，观测这次server的控制台：

[17:37:53]:服务端已经启动
[17:37:53]:server循环获取client请求开始
[17:38:00]:有新的client连接啦
[17:38:00]:server循环获取client请求开始
[17:38:00]:有新的client连接啦
[17:38:00]:server循环获取client请求开始
[17:38:02]:client传来消息
我是第二个客户端

[17:38:04]:client传来消息
我是第一个客户端

对比上面，很明显server新开了client处理线程，在处理client消息方面不会造成阻塞了。server收到client连接后新开线程处理并立即轮询接下来连接的client，“我是第二个客户端”较先打印很好的印证了这点。

2、将ClientHandler处理线程加入到线程池

Java创建的线程属于宝贵的系统资源，若是在大量的client访问时，则会创建大量的client消息处理线程，这样必将导致系统性能急剧下降，最终宕掉。所以我们可以将client消息处理线程加入到线程池中进行管理：

··· ···
// 定长线程池，超出数量的线程会在队列中等待
private ExecutorService threadPool = Executors.newFixedThreadPool(20);
··· ···
// 创建一个新的线程加入到线程池中管理并立即提交执行
threadPool.execute(new Thread(new ClientHandler(socket)));
··· ···

这样就不用担心由于高并发产生巨大的线程从而使系统崩溃，运行结果与上面相差无异。这里就不再重复，感兴趣的可以自己试试。

3、增加server响应

修改ClientHandler，简单回应client（复述消息）：

··· ···
// 在写之前必须关闭读
socket.shutdownInput();

BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream(), DEFAULT_ENCODE));
writer.write(builder.toString());
writer.flush();

socket.close();
··· ···

那么client的发送消息也得需要读取server的响应了，修改client的run方法：

  @Override
  public void run() {
    try (Socket socket = new Socket(serverIp, port)) {
      System.out.println("[" + DateUtil.getCurTimeStr() + "]:连接server成功");
      BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream(), DEFAULT_ENCODE));
      writer.write(msg);
      writer.flush();
      sleep(second);
      System.out.println("[" + DateUtil.getCurTimeStr() + "]:client写入消息");
      System.out.println(msg);

      // 在写之前必须关闭写
      socket.shutdownOutput();

      BufferedReader reader = new BufferedReader(new InputStreamReader(socket.getInputStream(), DEFAULT_ENCODE));
      StringBuilder builder = new StringBuilder();
      while ((msg = reader.readLine()) != null){
        builder.append(msg);
        builder.append(System.getProperty("line.separator"));
      }
      System.out.println("[" + DateUtil.getCurTimeStr() + "]:server传来消息");
      System.out.println(builder.toString());
    } catch (IOException e) {
      e.printStackTrace();
    }
  }

同样的先运行server后，再执行client的main方法，观测client的控制台：

[18:08:07]:连接server成功
[18:08:07]:连接server成功
[18:08:08]:client写入消息
我是第二个客户端
[18:08:08]:server传来消息
我是第二个客户端

Disconnected from the target VM, address: '127.0.0.1:61618', transport: 'socket'
[18:08:10]:client写入消息
我是第一个客户端
[18:08:10]:server传来消息
我是第一个客户端

这说明已经server成功做出了响应，并且client也成功读取到了server的消息。这里需要强调的是：

jdk 1.7开始，try后面可直接初始化某些流（implements AutoCloseable），则会自动关闭；
socket关闭后对应的输入/输出流也会被关闭；
socket 一次I/O操作既有读也有写的话，中间一定要加上shutup流；

最后编辑于：2017.12.10 05:04:13

人面猴
序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
沈念sama阅读 215,463评论 6赞 497
死咒
序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
沈念sama阅读 91,868评论 3赞 391
救了他两次的神仙让他今天三更去死
文/潘晓璐我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
开封第一讲书人阅读 161,213评论 0赞 351
道士缉凶录：失踪的卖姜人
文/不坏的土叔我叫张陵，是天一观的道长。经常有香客问我，道长，这世上最难降的妖魔是什么？我笑而不...
开封第一讲书人阅读 57,666评论 1赞 290
港岛之恋（遗憾婚礼）
正文为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
茶点故事阅读 66,759评论 6赞 388
恶毒庶女顶嫁案：这布局不是一般人想出来的
文/花漫我一把揭开白布。她就那样静静地躺着，像睡着了一般。火红的嫁衣衬着肌肤如雪。梳的纹丝不乱的头发上，一...
开封第一讲书人阅读 50,725评论 1赞 294
城市分裂传说
那天，我揣着相机与录音，去河边找鬼。笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。我是一名探鬼主播，决...
沈念sama阅读 39,716评论 3赞 415
双鸳鸯连环套：你想象不到人心有多黑
文/苍兰香墨我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
开封第一讲书人阅读 38,484评论 0赞 270
万荣杀人案实录
序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
沈念sama阅读 44,928评论 1赞 307
护林员之死
正文独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋以下内容为张勋视角年9月15日...
茶点故事阅读 37,233评论 2赞 331
白月光启示录
正文我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
茶点故事阅读 39,393评论 1赞 345
活死人
序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
沈念sama阅读 35,073评论 5赞 340
日本核电站爆炸内幕
正文年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
茶点故事阅读 40,718评论 3赞 324
男人毒药：我在死后第九天来索命
文/蒙蒙一、第九天我趴在偏房一处隐蔽的房顶上张望。院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
开封第一讲书人阅读 31,308评论 0赞 21
一桩弑父案，背后竟有这般阴谋
文/苍兰香墨我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。一阵脚步声响...
开封第一讲书人阅读 32,538评论 1赞 268
情欲美人皮
我被黑心中介骗来泰国打工，没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。一个月前我还...
沈念sama阅读 47,338评论 2赞 368
代替公主和亲
正文我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
茶点故事阅读 44,260评论 2赞 352