【Netty入门和实践】1.传统的socket分析

我们知道，使用Java进行TCP/UDP协议的网络通信一般使用Java的Net包下的Socket服务进行编写，有Server服务端和Client客户端，服务端用于监听客户端的连接和接收客户端发来的信息，而客户端可以接收服务端发送的信息，形成多个客户端与一个服务端连接，各个客户端可以相互通信的机制。

下面我们就编写一个简单的基于Socket服务的TCP协议传输信息的服务端，然后来进行分析。

在Eclipse中新建一个Java工程，名为“IOServer”即是服务端：

然后在src下面创建一个cn.com.io.old包，下面创建一个名为“Old_IO_Server”的类：

在该类中编写服务端代码：

package cn.com.io.old;

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

/***
 * 传统socket服务端
 */
public class Old_IO_Server {
    public static void main(String[] args) throws IOException {
		//创建Socket服务，监听10010端口
    	ServerSocket server = new ServerSocket(10010);
    	System.out.println("服务端启动！");
    	while(true){
    		//获取一个套接字(阻塞)
    		final Socket socket = server.accept();
    		System.out.println("出现一个新客户端！");
    		//业务处理
    		handler(socket);
    	}
	}

    /**
     * 读取数据
     * @param socket
     * @throws Exception 
     * */
	private static void handler(Socket socket){
		try {
			byte [] bytes = new byte[1024];
			InputStream input = socket.getInputStream();
			
			int read = 0;
			while(read!=-1){
				//读取数据(阻塞)
				read = input.read(bytes);
				System.out.println(new String(bytes,0,read));
			}
		} catch (Exception e) {
			e.printStackTrace();
		}finally{
			try {
				System.out.println("socket 关闭");
				socket.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}
}

我们在mian函数的第一行打一个断点，使用Debug模式运行该程序：

可以看到在客户端没有连接进来的时候，服务端会在server.accept();的位置阻塞等待。
然后使用Windows的CMD控制台的telnet进行客户端连接：

可以看到程序向下走了：

当程序走到read = input.read(bytes);发生了阻塞等待，等待客户端传输信息：

此时在阻塞过程中，意味着这条线程是被这个Socket一直占用着的，其它的Socket不能进来。(再次打开一个CMD控制台使用telnet，可以发现进不来)


当我们在CMD中输入信息(Ctrl+]进入客户端，send发信息)，可以看到服务端收到了信息：

想要服务端处理多个客户端的信息，就需要为每一个客户端分配一个线程。下面我们修改一下服务端：

package cn.com.io.old;

import java.io.IOException;
import java.io.InputStream;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/***
 * 传统socket服务端
 */
public class Old_IO_Server {
    public static void main(String[] args) throws IOException {
    	//创建一个缓存线程池
    	ExecutorService newCachedThreadPool = Executors.newCachedThreadPool();
		//创建Socket服务，监听10010端口
    	ServerSocket server = new ServerSocket(10010);
    	System.out.println("服务端启动！");
    	while(true){
    		//获取一个套接字(阻塞)
    		final Socket socket = server.accept();
    		System.out.println("出现一个新客户端！");
    		//在线程池为新客户端开一个线程
    		newCachedThreadPool.execute(new Runnable() {
				@Override
				public void run() {
					//业务处理
		    		handler(socket);
				}
			});
    	}
    }


    /**
     * 读取数据
     * @param socket
     * @throws Exception 
     * */
	private static void handler(Socket socket){
		try {
			byte [] bytes = new byte[1024];
			InputStream input = socket.getInputStream();
			
			int read = 0;
			while(read!=-1){
				//读取数据(阻塞)
				read = input.read(bytes);
				System.out.println(new String(bytes,0,read));
			}
		} catch (Exception e) {
			e.printStackTrace();
		}finally{
			try {
				System.out.println("socket 关闭");
				socket.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}
}

可以看到我们创建了一个缓存线程池，当服务端新连接了一个客户端的时候，就创建一个新的线程为客户端进行服务。

现在使用两个客户端连接10010端口，可以就看到两个客户端的信息都可以接收到：

那么我们是不是就可以使用这种结构实现一个长连接服务器呢？这里还是有一个很大的弊端，因为目前我们每个客户端都为其分配了一个线程去运行，如果有一万个客户端进来，我们就要分配一万个线程给客户端使用，这样的资源消耗是十分巨大的。就好像一个饭店每进来一个客人，就为其分配一个服务员给他服务一样，对于饭店来说服务员的开销也是巨大的。

基于以上几点，传统的Socket服务实现长连接服务是不合适的，但是可以实现短连接的服务器，如老版本的tomcat。

总结：
传统IO传输的特点：
(1)至少两处阻塞点(等待客户端连接，等待客户端发送信息)
(2)单线程下只能有一个客户端连接
(3)使用线程池可以连接多个客户端，但是十分消耗性能。

使用NIO就可以解决传统IO的网络传输问题，我们下篇进行介绍。

转载请注明出处：https://blog.csdn.net/acmman/article/details/80039159