网络编程基础(1) : 网路模型简介+同步阻塞实例

http://blog.csdn.net/yehjordan/article/details/50211453

1. 前言

簡介

网络编程中最基本的架构是C/S架构，也就是由客户端/服务端结合而成的连线架构，而C/S架构又有多种不同的实现方案，对应不同情况下的需求衍生出多种不同效能的网路模型实现方式可供选择，

在程序运行的角度所处的情境下一般可以分为以下四种：

(1) 同步阻塞：由功能调用的调用者(线程)等待结果返回，在结果返回前，当前线程被挂起阻塞住不往下面运行。如：read。

(2) 同步非阻塞：由功能调用的调用者(线程)等待结果返回，调用无法立即得到结果时会立即返回一个状态值，不会阻塞住当前线程运行。但是程序需要循环调用处理，等待接收到数据时才可以开始处理数据。

(3) 异步阻塞：由事件通知机制来通知调用者(线程)所关注的事件被触发，可以开始发起功能调用接收数据。如：select，使用时IO操作通常设为非阻塞，但select调用会阻塞住线程，所以从程序运行的角度來看是阻塞的。

(4) 异步非阻塞：在使用select时仍然需要等待事件通知，线程会被阻塞在select调用上，算是半残的异步，因此有了优化的IO模型如IOCP、AIO，当线程收到事件通知时，数据已经接收完毕并且在用户线程指定的buffer中，线程可直接进行其他处理。

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

补充：同步/异步、阻塞/非阻塞 之厘清

通常阻塞非阻塞的观念其实不容易混淆，比较容易混淆的是同步异步，他们在不同的情境下会有不同的意义。

以下给出一个从I/O操作角度来看的定义，也就是在I/O模型下的定义：

# 同步、异步：指的是  或者说关注的是  调用者(线程)与被调用者(内核)的交互方式。

同步：由"(功能)调用"的调用者(线程)等待"调用"的结果，调用有得到被调用者(內核)返回之结果时才会返回到线程继续运行。

　　　＊线程要等待调用结果返回才能往下运行。(此时线程还是激活的)

异步："(功能)调用"发起后就直接返回，所以不会立即得到返回之结果，
　　　要等到被调用者(内核)I/O操作完成后，藉由"状态"、"通知"来通知调用者(线程)，或调用调用者(线程)早先注册的回调函数。

　　　＊线程在发起调用后仍继续运行。

＊注：

在I/O模型的观点下，select调用算是同步I/O，
因为select虽然有类似异步阻塞的通知机制，但还是要由线程主动发起读写I/O读写数据，整个程序是按顺序运行；
而真正的异步I/O则是由内核读写完数据才通知线程，不需要由线程主动读写数据。

在程序运行的角度来看，实际处理调用的时机是只要是在等到被调用者(内核) 藉由"状态"、"通知"来通知调用者(线程)进行处理，
或调用调用者(线程)早先注册的回调函数，就可以看做异步。

至于在进程间、线程间、网路通信间的情境下，同步又是另一回事了。

# 阻塞、非阻塞：指的是 调用者(线程)进行调用及等待调用结果的方式。

阻塞："(功能)调用"发起后，在I/O操作完成之前 且 调用有得到返回之结果前，线程会被挂起(等待调用得到返回结果)，

　　　直到I/O操作完成后返回结果给调用后，线程才会恢复继续运行。

非阻塞："(功能)调用"发起后，I/O操作被调用后会返回一个状态值(给调用)，所以调用会得到返回结果，线程不会被挂起阻塞住。

=====================================================================================

＊同步and异步差别：同步I/O过程是顺序执行的，异步I/O不是顺序执行。同步I/O中线程要等待调用结果返回，异步则否。

＊同步and阻塞差别：同步调用发生时，当前线程是激活的，只不过调用(函数)还没返回而已；阻塞则是线程被挂起。

网路I/O模型一般分为四种：

　　    |----阻塞I/O

同步---|----非阻塞I/O

　　    |----I/O复用(multiplexing) (select/poll/epoll)

异步I/O  (AIO、IOCP)

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

废话不多说了，概念性质的话讲再多也没法体会，本篇中将给出同步阻塞的代码实现实例。

2. 服务端代码

简单介绍一下服务端的实现， 服务端程序在指定的端口上开启监听，然后用回圈循环监听来自客户端的连接请求 。

当接收到连接请求时，给客户端分配一个socket来识别对此客户端的操作。

一般来说，同步阻塞的实例到这里就差不多完成了，后续就是开始做网路数据的IO处理，只不过这样一来只能进行一对一的连线通信，因为主线程在接收完连线请求后就开始做IO处理了；

如果我们想扩展服务端的网路规模，我们可以通过修改软体架构来实现，最简单的实现方式是可以为每个客户端连线开启一个独立的线程为它服务，这样一来服务端就可以达成一对多客户端服务的效果。

但此种方式的缺陷在于服务可扩展的规模有极限，受限于硬件资源以及系统限制，通常如windows操作系统在32位元下会限制每个进程的内存大约2g，而线程可默认分配到1m的空间，如此一来，每个进程理论上只能开启2000个子线程左右，对应到大约2000个客户端；

2000看似对于小型服务来说是够用的，但是实际情况下CPU每个核心在执行线程时需要给线程分配处理时间，会额外增加系统开销，线程越多系统负载越重，程序效率越差，所以并不是线程开越多就能应付越复杂的情况 :-(

在这篇同步阻塞的Java示例中，以多线程应付简单情况下的网路通信已经足够，要让网络程序更有效率的运行则需要改用其他的网路模型，有机会的话将在后续的文章中介绍。

主線程代碼

[Server.java]

[java]  view plain  copy

 

1. package main.pkg;  
2.   
3. import java.io.IOException;  
4. import java.net.ServerSocket;  
5. import java.net.Socket;  
6. import java.net.SocketTimeoutException;  
7.   
8. public class Server {  
9.   
10.     private ServerSocket msock;  
11.   
12.     public Server(int port) throws IOException {  
13.         msock = new ServerSocket(port); // 在端口上开启监听  
14.         msock.setSoTimeout(0);  
15.           
16.         while(true) { // 循环监听连线请求  
17.             System.out.println("Waiting for new client on port " + msock.getLocalPort() + "...");  
18.             try {  
19.                 Socket ssock = msock.accept(); // 接受client连线  
20.                 new ClientThread(ssock).start(); // 为client开新处理线程  
21.                   
22.             } catch (SocketTimeoutException e) {  
23.                 System.out.println("Socket accepting time-out!");  
24.                 break;  
25.             } catch (IOException e) {  
26.                 e.printStackTrace();  
27.             }  
28.         }  
29.     }  
30.   
31.     public static void main(String[] args) {  
32.         // TODO Auto-generated method stub  
33.         int port = Integer.parseInt(args[0]);  
34.         //int port = 1333;  
35.           
36.         try {  
37.             Server server=new Server(port);  
38.         } catch (IOException e) {  
39.             e.printStackTrace();  
40.         }  
41.     }  
42. }  

服务客户端之子线程代码

[ClientThread.java]

[java]  view plain  copy

 

1. package main.pkg;  
2.   
3. import java.io.BufferedReader;  
4. import java.io.IOException;  
5. import java.io.InputStreamReader;  
6. import java.io.PrintWriter;  
7. import java.net.Socket;  
8. import java.net.SocketException;  
9.   
10. public class ClientThread extends Thread{  
11.   
12.     private Socket s;   
13.       
14.     public ClientThread(Socket ssock) {  
15.         s=ssock;  
16.     }  
17.       
18.     @Override  
19.     public void run() {  
20.         super.run();  
21.         System.out.println(s.getRemoteSocketAddress() + " is connected.");  
22.           
23.         try {  
24.             BufferedReader in = new BufferedReader(new InputStreamReader(s.getInputStream()));  
25.             PrintWriter out = new PrintWriter(s.getOutputStream());  
26.             String text=null;  
27.               
28.             while((text=in.readLine())!=null && !text.equals("exit")) { // 若读入字串不为空且不为exit，则印出client发来的字符串  
29.                 System.out.println("client " + s.getRemoteSocketAddress() +" > " + text);  
30.                 out.println("Your message has sent to " + s.getLocalSocketAddress()); // 回传给client回应字符串  
31.                 out.flush(); // 强制将缓冲区内的数据输出  
32.             }  
33.             System.out.println(s.getRemoteSocketAddress() + " is closed.");  
34.             s.close();  
35.               
36.         } catch (SocketException e) {  
37.             System.out.println("[Warning!] A client had been closed.");  
38.         } catch (IOException e) {  
39.             e.printStackTrace();  
40.         }  
41.     }  
42. }  

3. 客户端代码

[Client.java]

[java]  view plain  copy

 

1. package main.pkg;  
2.   
3. import java.io.BufferedReader;  
4. import java.io.IOException;  
5. import java.io.InputStreamReader;  
6. import java.io.PrintWriter;  
7. import java.net.Socket;  
8. import java.net.UnknownHostException;  
9.   
10. public class Client {  
11.   
12.     public static void main(String[] args) {  
13.         String hostname=args[0];  
14.         int port = Integer.parseInt(args[1]);  
15.         //String hostname="127.0.0.1";  
16.         //int port=1333;  
17.           
18.         System.out.println("Connecting to "+ hostname +":"+port);  
19.         try {  
20.             Socket client = new Socket(hostname, port); // 连接至目的地  
21.             System.out.println("Connected to "+ hostname);  
22.               
23.             PrintWriter out = new PrintWriter(client.getOutputStream());  
24.             BufferedReader in = new BufferedReader(new InputStreamReader(client.getInputStream()));  
25.             BufferedReader stdIn = new BufferedReader(new InputStreamReader(System.in));  
26.             String input;  
27.               
28.             while((input=stdIn.readLine()) != null) { // 读取输入  
29.                 out.println(input); // 发送输入的字符串  
30.                 out.flush(); // 强制将缓冲区内的数据输出  
31.                 if(input.equals("exit"))  
32.                 {  
33.                     break;  
34.                 }  
35.                 System.out.println("server: "+in.readLine());  
36.             }  
37.             client.close();  
38.             System.out.println("client stop.");  
39.         } catch (UnknownHostException e) {  
40.             System.err.println("Don't know about host: " + hostname);  
41.         } catch (IOException e) {  
42.             System.err.println("Couldn't get I/O for the socket connection");  
43.         }  
44.           
45.     }  
46.   
47. }