68.JAVA编程思想——服务多个客户

68.JAVA编程思想——服务多个客户
JabberServer 可以正常工作，但每次只能为一个客户程序提供服务。在典型的服务器中，我们希望同时能处理多个客户的请求。解决这个问题的关键就是多线程处理机制。而对于那些本身不支持多线程的语言，达到这个要求无疑是异常困难的。Java 已对多线程的处理进行了尽可能的简化。由于Java 的线程处理方式非常直接，所以让服务器控制多名客户并不是件难事。最基本的方法是在服务器（程序）里创建单个ServerSocket，并调用accept()来等候一个新连接。一旦accept()返回，我们就取得结果获得的Socket，并用它新建一个线程，令其只为那个特定的客户服务。然后再调用accept()
，等候下一次新的连接请求。

对于下面这段服务器代码，大家可发现它与JabberServer.java例子非常相似，只是为一个特定的客户提供服务的所有操作都已移入一个独立的线程类中：

1     服务端代码

import java.io.*;

import java.net.*;

class ServeOneJabber
extends Thread {

    private Socket
socket;

    private BufferedReader
in;

    private PrintWriter
out;

 

    public ServeOneJabber(Socket
s) throwsIOException {

        socket =
s;

        in =
new BufferedReader(new InputStreamReader(socket.getInputStream()));

        // Enable auto-flush:

       
out= newPrintWriter(newBufferedWriter(newOutputStreamWriter(socket.getOutputStream())),true);

        // If any of the above calls throw an

        // exception, the caller is responsible for

        // closing the socket. Otherwise the thread

        // will close it.

        start(); // Calls run()

    }

 

    public
voidrun() {

        try {

            while (true) {

                String
str = in.readLine();

                if (str.equals("END"))

                    break;

                System.out.println("Echoing: "+
str);

               
out.println(str);

            }

            System.out.println("closing...");

        } catch (IOException
e) {

        } finally {

            try {

                socket.close();

            } catch (IOException
e) {

            }

        }

    }

}

 

public
class MultiJabberServer {

    static
finalintPORT= 8080;

 

    public
staticvoidmain(String[]
args)throwsIOException {

        ServerSocket
s = new ServerSocket(PORT);

        System.out.println("Server Started");

        try {

            while (true) {

                // Blocks until a connection occurs:

                Socket
socket = s.accept();

                try {

                    new ServeOneJabber(socket);

                } catch (IOException
e) {

                    // If it fails, close the socket,

                    // otherwise the thread will close it:

                    socket.close();

                }

            }

        } finally {

            s.close();

        }

    }

} /// :~

每次有新客户请求建立一个连接时，ServeOneJabber 线程都会取得由accept()在main() 中生成的Socket 对象。然后和往常一样，它创建一个BufferedReader，并用Socket 自动刷新PrintWriter 对象。最后，它调用Thread 的特殊方法start()，令其进行线程的初始化，然后调用run()。这里采取的操作与前例是一样的：从套扫字读入某些东西，然后把它原样反馈回去，直到遇到一个特殊的"END"结束标志为止。

同样地，套接字的清除必须进行谨慎的设计。就目前这种情况来说，套接字是在ServeOneJabber外部创建的，所以清除工作可以“共享”。若ServeOneJabber 构建器失败，那么只需向调用者“掷”出一个违例即可，然后由调用者负责线程的清除。但假如构建器成功，那么必须由ServeOneJabber 对象负责线程的清除，这是在它的run()里进行的。

请注意MultiJabberServer 有多么简单。和以前一样，我们创建一个ServerSocket，并调用accept()允许一个新连接的建立。但这一次，accept() 的返回值（一个套接字）将传递给用于ServeOneJabber 的构建器，由它创建一个新线程，并对那个连接进行控制。连接中断后，线程便可简单地消失。

如果ServerSocket 创建失败，则再一次通过main()掷出违例。如果成功，则位于外层的try-finally 代码块可以担保正确的清除。位于内层的try-catch 块只负责防范ServeOneJabber 构建器的失败；若构建器成功，则ServeOneJabber 线程会将对应的套接字关掉。

为了证实服务器代码确实能为多名客户提供服务，下面这个程序将创建许多客户（使用线程），并同相同的服务器建立连接。每个线程的“存在时间”都是有限的。一旦到期，就留出空间以便创建一个新线程。允许创建的线程的最大数量是由final int maxthreads 决定的。大家会注意到这个值非常关键，因为假如把它设得很大，线程便有可能耗尽资源，并产生不可预知的程序错误。

2     客户端代码

import java.net.*;

import java.io.*;

 

class JabberClientThread
extends Thread {

    private Socket
socket;

    private BufferedReader
in;

    private PrintWriter
out;

    private
staticintcounter= 0;

    private
intid=
counter++;

    private
staticintthreadcount= 0;

 

    public
staticintthreadCount() {

        return
threadcount;

    }

 

    public JabberClientThread(InetAddress
addr) {

        System.out.println("Making client " +
id);

        threadcount++;

        try {

            socket =
new Socket(addr, MultiJabberServer.PORT);

        } catch (IOException
e) {

            // If the creation of the socket fails,

            // nothing needs to be cleaned up.

        }

        try {

            in =
new BufferedReader(new InputStreamReader(socket.getInputStream()));

            // Enable auto-flush:

            out =
new PrintWriter(new BufferedWriter(new OutputStreamWriter(socket.getOutputStream())),
true);

            start();

        } catch (IOException
e) {

            // The socket should be closed on any

            // failures other than the socket

            // constructor:

            try {

                socket.close();

            } catch (IOException
e2) {

            }

        }

        // Otherwise the socket will be closed by

        // the run() method of the thread.

    }

 

    public
voidrun() {

        try {

            for (int
i = 0; i < 25;
i++) {

                out.println("Client " +
id + ": " +
i);

                String
str = in.readLine();

                System.out.println(str);

            }

            out.println("END");

        } catch (IOException
e) {

        } finally {

            // Always close it:

            try {

                socket.close();

            } catch (IOException
e) {

            }

            threadcount--;
// Ending this thread

        }

    }

}

 

public
class MultiJabberClient {

    static
finalintMAX_THREADS = 40;

 

    public
staticvoidmain(String[]
args)throwsIOException, InterruptedException {

        InetAddress addr = InetAddress.getByName(null);

        while (true) {

            if (JabberClientThread.threadCount()<
MAX_THREADS)

                new JabberClientThread(addr);

            Thread.currentThread().sleep(100);

        }

    }

} /// :~

JabberClientThread 构建器获取一个InetAddress，并用它打开一个套接字。大家可能已看出了这样的一个套路：Socket 肯定用于创建某种Reader 以及／或者Writer（或者InputStream 和／或OutputStream）对象，这是运用Socket 的唯一方式（当然，我们可考虑编写一、两个类，令其自动完成这些操作，避免大量重复的代码编写工作）。同样地，start()执行线程的初始化，并调用run()。在这里，消息发送给服务器，而来自服务器的信息则在屏幕上回显出来。然而，线程的“存在时间”是有限的，最终都会结束。注意在套接字创建好以后，但在构建器完成之前，假若构建器失败，套接字会被清除。否则，为套接字调用close()的责任便落到了run()方法的头上。

threadcount 跟踪计算目前存在的JabberClientThread对象的数量。它将作为构建器的一部分增值，并在run()退出时减值（run()退出意味着线程中止）。在MultiJabberClient.main()中，大家可以看到线程的数量会得到检查。若数量太多，则多余的暂时不创建。方法随后进入“休眠”状态。这样一来，一旦部分线程最后被中止，多作的那些线程就可以创建了。大家可试验一下逐渐增大MAX_THREADS，看看对于你使用的系统来说，建立多少线程（连接）才会使您的系统资源降低到危险程度。