既然说到了nio,就得谈下面几个问题
为什么会出现新io,"旧io"有什么问题吗?
ok,一步一步来,先给大家看几个样例:

1单线程的server程序

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

public class SocketServiceTest
{
    public static void main(String[] args) throws Exception
    {
        ServerSocket serverSocket = new ServerSocket(10002);
        Socket socket = null;
        try
        {
            while (true)
            {
                socket = serverSocket.accept();
                System.out.println("socket连接：" + socket.getRemoteSocketAddress().toString());
                BufferedReader in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
                while(true)
                {
                    String readLine = in.readLine();
                    System.out.println("收到消息" + readLine);
                    if("end".equals(readLine))
                        break;
                }
                
            }
        }
        catch (SocketException se)
        {
            System.out.println("client断开连接");
        }
        catch (IOException e)
        {
            e.printStackTrace();
        }
        finally
        {
            System.out.println("socket关闭：" + socket.getRemoteSocketAddress().toString());
            socket.close();
        }
    }
}

我们执行Socket Test这个软件来測试一下
结果例如以下:

(为什么jfsdkof 没有显示出来?

自己想)

(有个小问题,程序没办法退出,有几种方法 能够在break那里主动抛出一个异常,或者把break改成return,又有个小问题先运行return还是finally?这个大家自己百度,我就不多说了)
除了上面的问题,另一个,假设我同一时候开两个test软件,结果会是这样:在我第一个程序敲打end之前,第二个程序发的全部消息都没有反应,但第一个程序一旦发送end,第二个程序之前发的命令会都显示出来(break与return在这样是不一样的,哪里有差别,大家自己试)
换句话说,上面的代码,仅仅能同一时候执行一个client!

2多线程的服务程序

import java.net.*;
import java.io.*;
import java.util.Scanner;

 public class MultithreadJIoSocketTest
{
    public static void main (String[] args) throws Exception
    {
        ServerSocket serverSocket = new ServerSocket(10002);
        Thread thread = new Thread(new Accptor(serverSocket));
        thread.start();
    }
}

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

 public class Accptor implements Runnable
    {
        private ServerSocket serverSocket;
        
        public Accptor(ServerSocket serverSocket)
        {
            this.serverSocket = serverSocket;
        }

        public void run()
        {
            while (true)
            {
                Socket socket = null;
                try
                {
                    socket = serverSocket.accept();
                    if(socket != null)
                    {
                        System.out.println("收到了socket：" + socket.getRemoteSocketAddress().toString());
                        Thread thread = new Thread(new Processor(socket));
                        thread.start();
                    }
                }
                catch (IOException e)
                {
                    e.printStackTrace();
                }
            }
        }
    }


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

 public class Processor implements Runnable
    {
        private Socket socket;
        
        public Processor(Socket socket)
        {
            this.socket = socket;
        }
        
        
        public void run()
        {
            try
            {
                BufferedReader in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
                String readLine;
                while(true)
                {
                    readLine = in.readLine();
                    System.out.println("收到消息" + readLine);
                    if("end".equals(readLine))
                    {
                        break;
                    }
                    //client断开连接
                    Thread.sleep(5000);
                }
            }
            catch (InterruptedException e)
            {
               e.printStackTrace();
            }
            catch (SocketException se)
            {
                System.out.println("client断开连接");
            }
            catch (IOException e)
            {
                e.printStackTrace();
            }
            finally {
                try
                {
                    socket.close();
                }
                catch (IOException e)
                {
                    e.printStackTrace();
                }
            }
        }
        
    }

这里启用了线程的概念,都非常easy,假设大家哪里还是不清楚,能够看看<<谈谈java中的线程(0基础概念) >>就在我写的博客里面,非常easy的一些基础知识#
显演示样例如以下

这里似乎攻克了不能同一时候訪问的问题,可是技术的进步总是这样,你攻克了一个问题,立即就会出现新的三个问题
新出现的问题有
1 如今的http请求支持长连接,假设同一时候又10000个人在线,服务端就启动10000个线程吗? 假设是10万人呢?
2 就算不考虑第一个问题,假设多个线程涉及到对同一个文件的读写,怎么保证一致性?
3 假设我想提升某些用户的优先级,怎么办?
另外另一个问题,在上面的样例中并没有体现出来,就是效率!我们期待一种新的io方式,来提升速度#

至少上面的三个问题都说明,我们须要一种新的io方式!

OK,下一章我们再说nio

说说nio