Skip to content

9. 程序源代码

9.1. 通用 TCP 客户端

互联网早期创建的许多服务都遵循之前学习的回显服务器模型：客户端与服务器的交互仅限于文本行的交换。我们将编写一个通用 TCP 客户端，其启动方式如下：java cltTCPgenerique server port

该 TCP 客户端将连接到服务器的端口。连接成功后，它将创建两个线程：

  1. 一个线程负责读取键盘输入的命令并将其发送至服务器
  2. 另一个线程负责读取服务器的响应并将其显示在屏幕上

为何需要两个线程？每个 TCP-IP 服务都有其特定的协议，有时会出现以下情况：

  • 客户端必须发送数行文本后才能收到响应
  • 服务器的响应可能包含多行文本

因此，那种向服务器发送一行并接收一行响应的循环并不总是适用。因此，我们将创建两个独立的循环：

  • 一个循环用于读取键盘输入的命令并发送至服务器。用户将通过关键字“fin”来标记命令的结束。
  • 一个用于接收并显示服务器响应的循环。这是一个无限循环，只有当服务器关闭网络连接或用户在键盘上输入“end”命令时才会中断。

要实现这两个独立的循环，我们需要两个独立的线程。让我们通过一个示例来观察执行过程：我们的通用 TCP 客户端连接到一个 SMTP（简单邮件传输协议）服务。该服务负责将电子邮件路由到收件人。它运行在 25 号端口上，并使用基于文本的交换协议。


Dos>java clientTCPgenerique istia.univ-angers.fr 25
Commandes :
<-- 220 istia.univ-angers.fr ESMTP Sendmail 8.11.6/8.9.3; Mon, 13 May 2002 08:37:26 +0200
help
<-- 502 5.3.0 Sendmail 8.11.6 -- HELP not implemented
mail from: machin@univ-angers.fr
<-- 250 2.1.0 machin@univ-angers.fr... Sender ok
rcpt to: serge.tahe@istia.univ-angers.fr
<-- 250 2.1.5 serge.tahe@istia.univ-angers.fr... Recipient ok
data
<-- 354 Enter mail, end with "." on a line by itself
Subject: test
 
ligne1
ligne2
ligne3
.
<-- 250 2.0.0 g4D6bks25951 Message accepted for delivery
quit
<-- 221 2.0.0 istia.univ-angers.fr closing connection
[fin du thread de lecture des réponses du serveur]
fin
[fin du thread d'envoi des commandes au serveur]

让我们来分析一下这些客户端与服务器的交互：

  • 当客户端连接到 SMTP 服务时，该服务会发送一条欢迎消息： 
<-- 220 istia.univ-angers.fr ESMTP Sendmail 8.11.6/8.9.3; Mon, 13 May 2002 08:37:26 +0200
  • 某些服务提供“help”命令，用于显示该服务支持的命令列表。但本例并非如此。示例中使用的 SMTP 命令如下：
    • mail from: 发件人，用于指定发件人的电子邮件地址
    • rcpt to: 收件人，用于指定邮件收件人的电子邮件地址。如果有多个收件人，则需针对每位收件人重复执行 rcpt to: 命令。
    • data，该命令向 SMTP 服务器发出信号，表示邮件即将发送。如服务器响应所示，这将是一系列以仅含一个句点的行结尾的行。邮件可能包含通过空行与邮件正文分隔的标题。在本示例中，我们使用 Subject: 关键字添加了主题
  • 消息发送完成后，我们可以使用 quit 命令告知服务器操作已完成。随后服务器将关闭网络连接。读取线程可检测到此事件并停止运行。
  • 随后用户在键盘上输入“end”，以停止读取键盘输入命令的线程。

若检查收到的邮件，我们会看到以下内容（Outlook）：

Image

请注意，SMTP 服务无法检测发件人是否有效。因此，您绝不能信任邮件中的“发件人”字段。在此案例中，发件人 machin@univ-angers.fr 并不存在。

这个通用的 TCP 客户端允许我们发现互联网服务的通信协议，并据此为这些服务的客户端构建专门的类。让我们来探索 POP（邮局协议）服务的通信协议，该协议允许我们检索存储在服务器上的电子邮件。它运行在 110 端口上。


Dos> java clientTCPgenerique istia.univ-angers.fr 110
Commandes :
<-- +OK Qpopper (version 4.0.3) at istia.univ-angers.fr starting.
help
<-- -ERR Unknown command: "help".
user st
<-- +OK Password required for st.
pass monpassword
<-- +OK st has 157 visible messages (0 hidden) in 11755927 octets.
list
<-- +OK 157 visible messages (11755927 octets)
<-- 1 892847
<-- 2 171661
...
<-- 156 2843
<-- 157 2796
<-- .
retr 157
<-- +OK 2796 octets
<-- Received: from lagaffe.univ-angers.fr (lagaffe.univ-angers.fr [193.49.144.1])
<--     by istia.univ-angers.fr (8.11.6/8.9.3) with ESMTP id g4D6wZs26600;
<--     Mon, 13 May 2002 08:58:35 +0200
<-- Received: from jaume ([193.49.146.242])
<--     by lagaffe.univ-angers.fr (8.11.1/8.11.2/GeO20000215) with SMTP id g4D6wSd37691;
<--     Mon, 13 May 2002 08:58:28 +0200 (CEST)
...
<-- ------------------------------------------------------------------------
<-- NOC-RENATER2                  Tl.  : 0800 77 47 95
<-- Fax : (+33) 01 40 78 64 00 ,  Email : noc-r2@cssi.renater.fr
<-- ------------------------------------------------------------------------
<--
<-- .
quit
<-- +OK Pop server at istia.univ-angers.fr signing off.
[fin du thread de lecture des réponses du serveur]
fin
[fin du thread d'envoi des commandes au serveur]

主要命令如下：

  • user login，在此处输入您在邮件服务器上的登录名
  • pass password，在此输入与前一个登录名关联的密码
  • list，用于获取邮件列表，格式为编号、字节大小
  • retr i，用于阅读编号为 i 的邮件
  • quit，用于结束本次会话。

现在，让我们来探讨客户端与 Web 服务器之间的通信协议，该服务器通常运行在 80 端口上：


Dos> java clientTCPgenerique istia.univ-angers.fr 80
Commandes :
GET /index.html HTTP/1.0
 
<-- HTTP/1.1 200 OK
<-- Date: Mon, 13 May 2002 07:30:58 GMT
<-- Server: Apache/1.3.12 (Unix)  (Red Hat/Linux) PHP/3.0.15 mod_perl/1.21
<-- Last-Modified: Wed, 06 Feb 2002 09:00:58 GMT
<-- ETag: "23432-2bf3-3c60f0ca"
<-- Accept-Ranges: bytes
<-- Content-Length: 11251
<-- Connection: close
<-- Content-Type: text/html
<--
<-- <html>
<--
<-- <head>
<-- <meta http-equiv="Content-Type"
<-- content="text/html; charset=iso-8859-1">
<-- <meta name="GENERATOR" content="Microsoft FrontPage Express 2.0">
<-- <title>Bienvenue a l'ISTIA - Universite d'Angers</title>
<-- </head>
....
<-- face="Verdana"> - Dernire mise  jour le <b>10 janvier 2002</b></font></p>
<-- </body>
<-- </html>
<--
[fin du thread de lecture des réponses du serveur]
fin
[fin du thread d'envoi des commandes au serveur]

Web客户端按照以下模式向服务器发送命令：

commande1
commande2
...
commanden
[ligne vide]

Web 服务器仅在收到空行后才会响应。在此示例中，我们仅使用了一个命令：

GET /index.html HTTP/1.0

该命令向服务器请求 URL /index.html，并表明使用的是 HTTP 1.0 版本。该协议的最新版本为 1.1。示例显示，服务器通过发送 index.html 文件的内容并随后关闭连接来响应，正如我们所见，响应显示为“线程终止”。在发送 index.html 文件的内容之前，Web 服务器先发送了一系列标头，随后是一个空行：

<-- HTTP/1.1 200 OK
<-- Date: Mon, 13 May 2002 07:30:58 GMT
<-- Server: Apache/1.3.12 (Unix)  (Red Hat/Linux) PHP/3.0.15 mod_perl/1.21
<-- Last-Modified: Wed, 06 Feb 2002 09:00:58 GMT
<-- ETag: "23432-2bf3-3c60f0ca"
<-- Accept-Ranges: bytes
<-- Content-Length: 11251
<-- Connection: close
<-- Content-Type: text/html
<--
<-- <html>

<html> 这一行是 /index.html 文件的第一行。前面的文本被称为 HTTP（超文本传输协议）头。我们在此不详细讨论这些头，但请记住，我们的通用客户端提供了访问这些头的途径，这有助于理解它们。例如，第一行：

<-- HTTP/1.1 200 OK

表明被访问的 Web 服务器支持 HTTP/1.1 协议，并且已成功找到请求的文件（200 OK），其中 200 是一个 HTTP 响应代码。这些行

<-- Content-Length: 11251
<-- Connection: close
<-- Content-Type: text/html

告知客户端，它将接收 11,251 字节的 HTML（超文本标记语言）文本，且数据发送完毕后连接将被关闭。

至此，我们拥有了一个非常实用的 TCP 客户端。虽然它的功能确实不如我们之前使用的 telnet 程序，但亲手编写它还是很有趣的。通用 TCP 客户端程序如下：

// imported packages
import java.io.*;
import java.net.*;

public class clientTCPgenerique{

    // receives the characteristics of a service as a parameter in the form
     // server port
     // connects to the service
     // creates a thread to read keyboard commands
     // these will be sent to the
     // creates a thread to read server responses
     // these will be displayed on the screen
     // the whole thing ends with the command end typed on the keyboard

   // instance variable
  private static Socket client;

    public static void main(String[] args){

         // syntax
        final String syntaxe="pg serveur port";

         // number of arguments
        if(args.length != 2)
            erreur(syntaxe,1);

         // note the server name
        String serveur=args[0];

         // port must be integer >0
        int port=0;
        boolean erreurPort=false;
        Exception E=null;
        try{
            port=Integer.parseInt(args[1]);
        }catch(Exception e){
            E=e;
            erreurPort=true;
        }
        erreurPort=erreurPort || port <=0;
        if(erreurPort)
            erreur(syntaxe+"\n"+"Port incorrect ("+E+")",2);

        client=null;
         // there may be problems
        try{
             // connect to the service
            client=new Socket(serveur,port);
        }catch(Exception ex){
             // error
            erreur("Impossible de se connecter au service ("+ serveur
                +","+port+"), erreur : "+ex.getMessage(),3);
             // end
            return;
        }//catch

         // create read/write threads
    new ClientSend(client).start();
    new ClientReceive(client).start();

        // end thread main
        return;
    }// hand

     // error display
    public static void erreur(String msg, int exitCode){
         // error display
        System.err.println(msg);
         // stop with error
        System.exit(exitCode);
    }//error
}//class  

class ClientSend extends Thread {
    // class for reading keyboard commands
     // and send them to a server via a tcp client passed in parameter

    private Socket client;    // tcp client

     // manufacturer
    public ClientSend(Socket client){
         // we note the tcp client
        this.client=client;
    }//manufacturer

     // thread Run method
    public void run(){

        // local data
        PrintWriter OUT=null;            // network write streams
    BufferedReader IN=null;        // keyboard flow
        String commande=null;            // command read from keyboard

         // error management
        try{
             // network write stream creation
            OUT=new PrintWriter(client.getOutputStream(),true);
      // keyboard input stream creation
      IN=new BufferedReader(new InputStreamReader(System.in));
            // order entry-send loop
            System.out.println("Commandes : ");
            while(true){
                 // read command typed on keyboard
                commande=IN.readLine().trim();
                // finished?
                if (commande.toLowerCase().equals("fin")) break;
                // send order to server
                OUT.println(commande);
                 // next order
            }//while
        }catch(Exception ex){
             // error
            System.err.println("Envoi : L'erreur suivante s'est produite : " + ex.getMessage());
        }//catch
         // end - close flows
        try{
            OUT.close();client.close();
        }catch(Exception ex){}
         // signals the end of the thread
        System.out.println("[Envoi : fin du thread d'envoi des commandes au serveur]");
    }//run
}//class

class ClientReceive extends Thread{
    // class responsible for reading lines of text intended for a 
     // tcp client passed as parameter

    private Socket client;    // tcp client

     // manufacturer
    public ClientReceive(Socket client){
         // we note the tcp client
        this.client=client;
    }//manufacturer

     // thread Run method
    public void run(){

        // local data
        BufferedReader IN=null;        // network read stream
        String réponse=null;        // server response

         // error management
        try{
             // create network read stream
            IN=new BufferedReader(new InputStreamReader(client.getInputStream()));
            // loop read text lines from IN stream
            while(true){
                 // network streaming
                réponse=IN.readLine();
                 // closed flow?
                if(réponse==null) break;
                // display
                System.out.println("<-- "+réponse);
            }//while
        }catch(Exception ex){
            // error
            System.err.println("Réception : L'erreur suivante s'est produite : " + ex.getMessage());
        }//catch
         // end - we close the feeds
        try{
            IN.close();client.close();
        }catch(Exception ex){}
         // signals the end of the thread
        System.out.println("[Réception : fin du thread de lecture des réponses du serveur]");
    }//run
}//class

9.2. 通用 TCP 服务器

现在我们来看一个服务器

  • ，它会在屏幕上显示客户端发送的命令
  • 并将用户在键盘上输入的文本行作为响应发送给客户端。因此，用户在此扮演了服务器的角色。

该程序通过以下命令启动：java genericTCPserver listeningPort，其中 listeningPort 是客户端必须连接的端口。客户端服务将由两个线程处理：

  • 一个线程专门用于读取客户端发送的文本行
  • 另一个线程专门用于读取用户在键盘上输入的响应。该线程将使用 `fin` 命令发出信号，表示其正在关闭与客户端的连接。

服务器为每个客户端创建两个线程。如果有 n 个客户端，则同时会有 2n 个活跃线程。除非用户在键盘上按下 Ctrl-C，否则服务器本身不会停止运行。让我们来看几个示例。

服务器运行在 100 端口，我们使用通用客户端与其通信。客户端窗口如下所示：


E:\data\serge\MSNET\c#\réseau\client tcp générique> java clientTCPgenerique localhost 100
Commandes :
commande 1 du client 1
<-- réponse 1 au client 1
commande 2 du client 1
<-- réponse 2 au client 1
fin
L'erreur suivante s'est produite : Impossible de lire les données de la connexion de transport.
[fin du thread de lecture des réponses du serveur]
[fin du thread d'envoi des commandes au serveur]

以 <-- 开头的行是服务器发送给客户端的；其余行是客户端发送给服务器的。服务器窗口如下：


Dos> java serveurTCPgenerique 100
Serveur générique lancé sur le port 100
Thread de lecture des réponses du serveur au client 1 lancé
1 : Thread de lecture des demandes du client 1 lancé
<-- commande 1 du client 1
réponse 1 au client 1
1 : <-- commande 2 du client 1
réponse 2 au client 1
1 : [fin du Thread de lecture des demandes du client 1]
fin
[fin du Thread de lecture des réponses du serveur au client 1]

以 <-- 开头的行是客户端发送给服务器的。以 N: 开头的行是服务器发送给客户端 N 的。尽管客户端 1 已结束，但上面的服务器仍然处于活动状态。我们为同一服务器启动第二个客户端：


Dos> java clientTCPgenerique localhost 100
Commandes :
commande 3 du client 2
<-- réponse 3 au client 2
fin
L'erreur suivante s'est produite : Impossible de lire les données de la connexion de transport.
[fin du thread de lecture des réponses du serveur]
[fin du thread d'envoi des commandes au serveur]

此时服务器窗口显示如下：


Dos> java serveurTCPgenerique 100
Serveur générique lancé sur le port 100
Thread de lecture des réponses du serveur au client 1 lancé
1 : Thread de lecture des demandes du client 1 lancé
<-- commande 1 du client 1
réponse 1 au client 1
1 : <-- commande 2 du client 1
réponse 2 au client 1
1 : [fin du Thread de lecture des demandes du client 1]
fin
[fin du Thread de lecture des réponses du serveur au client 1]
Thread de lecture des réponses du serveur au client 2 lancé
2 : Thread de lecture des demandes du client 2 lancé
<-- commande 3 du client 2
réponse 3 au client 2
2 : [fin du Thread de lecture des demandes du client 2]
fin
[fin du Thread de lecture des réponses du serveur au client 2]
^C

现在，让我们通过在 88 端口上运行我们的通用服务器来模拟一个 Web 服务器：


Dos> java serveurTCPgenerique 88
Serveur générique lancé sur le port 88

现在，让我们打开浏览器并访问 URL http://localhost:88/exemple.html。浏览器将连接到本地主机的 88 端口，并请求 /example.html 页面：

Image

现在让我们看看我们的服务器窗口：

Dos>java serveurTCPgenerique 88
Serveur générique lancé sur le port 88
Thread de lecture des réponses du serveur au client 2 lancé
2 : Thread de lecture des demandes du client 2 lancé
<-- GET /exemple.html HTTP/1.1
<-- Accept: image/gif, image/x-xbitmap, image/jpeg, image/pjpeg, application/msword, */*
<-- Accept-Language: fr
<-- Accept-Encoding: gzip, deflate
<-- User-Agent: Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.0; .NET CLR 1.0.3705; .NET CLR 1.0.2
914)
<-- Host: localhost:88
<-- Connection: Keep-Alive
<--

这展示了浏览器发送的 HTTP 头部。这使我们能够逐步了解 HTTP 协议。在之前的示例中，我们创建了一个仅发送 GET 请求的 Web 客户端。当时这样就足够了。在这里，我们可以看到浏览器还会向服务器发送其他信息。这些信息旨在告知服务器当前正在处理的是何种类型的客户端。我们还注意到，HTTP 头部以空行结尾。

让我们为客户端编写一个响应。此时，操作键盘的用户就是实际的服务器，可以手动编写响应。回想一下前一个示例中 Web 服务器发送的响应：

<-- HTTP/1.1 200 OK
<-- Date: Mon, 13 May 2002 07:30:58 GMT
<-- Server: Apache/1.3.12 (Unix)  (Red Hat/Linux) PHP/3.0.15 mod_perl/1.21
<-- Last-Modified: Wed, 06 Feb 2002 09:00:58 GMT
<-- ETag: "23432-2bf3-3c60f0ca"
<-- Accept-Ranges: bytes
<-- Content-Length: 11251
<-- Connection: close
<-- Content-Type: text/html
<--
<-- <html>

让我们尝试提供一个类似的响应：

...
<-- Host: localhost:88
<-- Connection: Keep-Alive
<--
2 : HTTP/1.1 200 OK
2 : Server: serveur tcp generique
2 : Connection: close
2 : Content-Type: text/html
2 :
2 : <html>
2 :   <head><title>Serveur generique</title></head>
2 :   <body>
2 :     <center>
2 :       <h2>Reponse du serveur generique</h2>
2 :     </center>
2 :    </body>
2 : </html>
2 : fin
L'erreur suivante s'est produite : Impossible de lire les données de la connexion de transport.
[fin du Thread de lecture des demandes du client 2]
[fin du Thread de lecture des réponses du serveur au client 2]

以 2: 开头的行是从服务器发送到客户端 #2 的。end 命令关闭了从服务器到客户端的连接。在我们的响应中，我们仅使用了以下 HTTP 头部：

HTTP/1.1 200 OK
2 : Server: serveur tcp generique
2 : Connection: close
2 : Content-Type: text/html
2 :

我们没有指定要发送的文件大小（Content-Length），而是简单地表明在发送完成后将关闭连接（Connection: close）。这对浏览器来说已经足够了。当浏览器看到连接关闭时，它就会知道服务器的响应已经完成，并会显示发送给它的 HTML 页面。该页面如下所示：

2 : <html>
2 :   <head><title>Serveur generique</title></head>
2 :   <body>
2 :     <center>
2 :       <h2>Reponse du serveur generique</h2>
2 :     </center>
2 :    </body>
2 : </html>

随后，用户通过输入“fin”命令关闭与客户端的连接。浏览器随即得知服务器的响应已完成，并可将其显示出来：

Image

如果在上面的示例中，您选择“查看/源代码”来查看浏览器接收的内容，您将看到：

Image

也就是说，这正是通用服务器发送的内容。

通用 TCP 服务器的代码如下：

// packages
import java.io.*;
import java.net.*;

public class serveurTCPgenerique{

    // main program
    public static void main (String[] args){

    // receives the port of listening to customer requests
     // creates a thread to read client requests
     // these will be displayed on the screen
     // creates a thread to read keyboard commands
     // these will be sent as a reply to the customer
     // the whole thing ends with the command end typed on the keyboard

    final String syntaxe="Syntaxe : pg port";
   // instance variable
         // is there an argument
     if(args.length != 1)
        erreur(syntaxe,1);

         // port must be integer >0
        int port=0;
        boolean erreurPort=false;
        Exception E=null;
        try{
            port=Integer.parseInt(args[0]);
        }catch(Exception e){
            E=e;
            erreurPort=true;
        }
        erreurPort=erreurPort || port <=0;
        if(erreurPort)
            erreur(syntaxe+"\n"+"Port incorrect ("+E+")",2);

     // we create the listening service
    ServerSocket ecoute=null;
    int nbClients=0;    // no. of customers handled
        try{
             // create the service
            ecoute=new ServerSocket(port);
             // follow-up
            System.out.println("Serveur générique lancé sur le port " + port);

             // customer service loop
            Socket client=null;
            while (true){ // infinite loop - will be stopped by Ctrl-C
                 // waiting for a customer
                client=ecoute.accept();

                 // the service is provided by separate threads
                nbClients++;

                 // create read/write threads
        new ServeurSend(client,nbClients).start();
        new ServeurReceive(client,nbClients).start();

                // back to listening to requests
            }// end while
        }catch(Exception ex){
             // we report the error
            erreur("L'erreur suivante s'est produite : " + ex.getMessage(),3);
        }//catch
    }// fine hand

     // error display
    public static void erreur(String msg, int exitCode){
         // error display
        System.err.println(msg);
         // stop with error
        System.exit(exitCode);
    }//error
}//class

class ServeurSend extends Thread{
    // class responsible for reading typed responses
     // and send them to a client via a tcp client passed to the

    Socket client;    // tcp client
    int numClient;        // customer no

     // manufacturer
    public ServeurSend(Socket client, int numClient){
         // we note the tcp client
        this.client=client;
         // and its
        this.numClient=numClient;
    }//manufacturer

     // thread Run method
    public void run(){

        // local data
        PrintWriter OUT=null;        // network write streams
        String réponse=null;        // answer read from keyboard
    BufferedReader IN=null;    // keyboard flow

        // follow-up
        System.out.println("Thread de lecture des réponses du serveur au client "+ numClient + " lancé");
         // error management
        try{
             // network write stream creation
            OUT=new PrintWriter(client.getOutputStream(),true);
      // keyboard flow creation
      IN=new BufferedReader(new InputStreamReader(System.in));
            // order entry-send loop
            while(true){
                 // customer identification
                System.out.print("--> " + numClient + " : ");
                 // read response typed on keyboard
                réponse=IN.readLine().trim();
                // finished?
                if (réponse.toLowerCase().equals("fin")) break;
                // send response to server
                OUT.println(réponse);
                 // following response
            }//while
        }catch(Exception ex){
             // error
            System.err.println("L'erreur suivante s'est produite : " + ex.getMessage());
        }//catch
         // end - close flows
        try{
            OUT.close();client.close();
        }catch(Exception ex){}
         // signals the end of the thread
        System.out.println("[fin du Thread de lecture des réponses du serveur au client "+ numClient+ "]");
    }//run
}//class

class ServeurReceive extends Thread{
    // class responsible for reading text lines sent to the server 
     // via a tcp client passed to the builder

    Socket client;    // tcp client
    int numClient;        // customer no

     // manufacturer
    public ServeurReceive(Socket client, int numClient){
         // we note the tcp client
        this.client=client;
         // and its
        this.numClient=numClient;
    }//manufacturer

     // thread Run method
    public void run(){

        // local data
        BufferedReader IN=null;        // network read stream
        String réponse=null;        // server response

         // follow-up
        System.out.println("Thread de lecture des demandes du client "+ numClient + " lancé");
         // error management
        try{
             // create network read stream
            IN=new BufferedReader(new InputStreamReader(client.getInputStream()));
            // loop read text lines from IN stream
            while(true){
                 // network streaming
                réponse=IN.readLine();
                 // closed flow?
                if(réponse==null) break;
                // display
                System.out.println("<-- "+réponse);
            }//while
        }catch(Exception ex){
            // error
            System.err.println("L'erreur suivante s'est produite : " + ex.getMessage());
        }//catch
         // end - close flows
        try{
            IN.close();client.close();
        }catch(Exception ex){}
         // signals the end of the thread
        System.out.println("[fin du Thread de lecture des demandes du client "+ numClient+"]");
    }//run
}//class
https://stahe.github.io
本教程由 Serge Tahé 编写，根据 知识共享 署名-非商业性使用- 相同方式共享 3.0 未本地化.