Java Socket 编程那些事(1)

前言

最近在准备面试和笔试的一些东西,回去翻看了Java关于IO的基础,发现很多基础还是没有记牢固,现在回头重新学习,就从socket通讯开始吧,虽然说现在企业很少直接编写socket,都是使用一些封装好的框架,netty,mina等。不过对于这些基础的知识,还是需要掌握牢固的,对于以后学习更深的框架和笔试面试都很有裨益。

BIO、NIO、AIO的区别

Java中的IO的方式有三种
Java BIO : 同步并阻塞,服务器实现模式为一个连接一个线程,即客户端有连接请求时服务器端就需要启动一个线程进行处理,如果这个连接不做任何事情会造成不必要的线程开销,当然可以通过线程池机制改善。在JDK1.4以前采用这种方式
Java NIO : 同步非阻塞,服务器实现模式为一个请求一个线程,即客户端发送的连接请求都会注册到多路复用器上,多路复用器轮询到连接有I/O请求时才启动一个线程进行处理。
Java AIO(NIO.2) : 异步非阻塞,服务器实现模式为一个有效请求一个线程,客户端的I/O请求都是由OS先完成了再通知服务器应用去启动线程进行处理,

曾经在一篇文章中看到这么很好的比喻

如果你想吃一份宫保鸡丁盖饭:

同步阻塞:你到饭馆点餐,然后在那等着,还要一边喊:好了没啊!

同步非阻塞:在饭馆点完餐,就去遛狗了。不过溜一会儿,就回饭馆喊一声:好了没啊!

异步阻塞:遛狗的时候,接到饭馆电话,说饭做好了,让您亲自去拿。

异步非阻塞:饭馆打电话说,我们知道您的位置,一会给你送过来,安心遛狗就可以了。

这里我们从最简单的BIO开始学习吧

单线程通讯

首先我们先新建一个Server类,这个类将监听12345这个端口,等待客户端的连接,客户端与服务器连接后,客户端可以像服务器发送信息,如果发送bye,则结束通讯

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
package edu.gduf.bio.socket.demo1;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;
/**
* 基于bio的socket服务器端
*
* @author ZGJ
* @date 2017年5月4日
*/
public class Server {
public static void main(String[] args) {
//创建一个serversocket在10000号端口监听
try (ServerSocket server = new ServerSocket(12345)) {
//等待客户端连接,将一直阻塞直到有客户端连接
Socket socket = server.accept();
BufferedReader in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
PrintWriter out = new PrintWriter(socket.getOutputStream());
while (true) {
String msg = in.readLine();
System.out.println(msg);
out.println("Server received " + msg);
out.flush();
if (msg.equals("bye")) {
break;
}
}
} catch (IOException e) {
e.printStackTrace();
}
}
}

这里try (ServerSocket server = new ServerSocket(12345))采用了java7的try-with-resources语法,这样写的好处是try里面声明的资源在最后都会自动关闭,而不需要我们手动关闭,简化了语法

Client类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
package edu.gduf.bio.socket.demo1;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.Socket;
/**
* 基于bio的socket客户端
*
* @author ZGJ
* @date 2017年5月4日
*/
public class Client {
public static void main(String[] args) {
try (Socket socket = new Socket("127.0.0.1", 12345)) {
//获取socket输入流
BufferedReader in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
//socket输出流
PrintWriter out = new PrintWriter(socket.getOutputStream());
//标准输入流
BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
while (true) {
String msg = reader.readLine();
out.println(msg);
out.flush();
if (msg.equals("bye")) {
break;
}
System.out.println(in.readLine());
}
} catch (IOException e) {
e.printStackTrace();
}
}
}

运行结果:
Client:

hello
Server received hello
haha
Server received haha
bye

Server:
hello
haha
bye

多线程通讯

我们发现,服务器只能处理一个客户端的请求,服务器处理了第一个客户端的请求之后,后续的Client就不能再连接,这个时候我们需要做一些改动,当服务器收到客户端的连接请求后,客户端的请求放在一个新的线程中去处理,而主线程仍然继续等待其他客户端的连接,这样就不会阻塞服务器处理其他客户端的请求了,只需要修改服务器的代码,客户端代码和原来的一样

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
package edu.gduf.bio.socket.demo2;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;
/**
* 处理多个client的server
* @author ZGJ
* @date 2017年5月4日
*/
public class MulitClientServer {
public static void main(String[] args) {
try(ServerSocket server = new ServerSocket(12345)) {
//循环接受客户端请求
while(true) {
Socket socket = server.accept();
handle(socket);
}
} catch(IOException e) {
e.printStackTrace();
}
}
/**
* 处理客户请求
* @param socket
*/
private static void handle(Socket socket) {
//开启一个线程,lambda表达式
new Thread(() -> {
try(BufferedReader in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
PrintWriter writer = new PrintWriter(socket.getOutputStream(), true)) {
while(true) {
String message = in.readLine();
System.out.println(message);
writer.println("Server received: " + message);
if("bye".equals(message)) {
break;
}
}
} catch(IOException e) {
e.printStackTrace();
}
}).start();
}
}

我们可以看到,当服务器接受到一个客户单的请求之后,采用handle()方法去处理客户端的请求,这里使用了Java8中lambda表达式来替代匿名内部类的语法,来简化我们的编程,使我们的语法更加简洁。对于每一个客户端的请求都开启一个新的线程去处理,当然,如果还想做到更加优化,可以采用Executor线程池去处理,节省创建和关闭线程的开销。