Java编程那些事儿——文件操作之写文件

Java编程那些事儿——文件操作之写文件

Java, Java培训, Java基础, Java学习, Java教程

11.3.1.4 写文件

    如前所述，将程序内部的数据输出到程序外部的数据源，应该使用IO类体系中的输出流。在实际的编程中，将程序中的数据，例如用户设定或程序运行时生成的内容，存储到外部的文件中，应该使用输出流进行编程。

    基本的输出流包含OutputStream和Writer两个，区别是OutputStream体系中的类（也就是OutputStream的子类）是按照字节写入的，而Writer体系中的类（也就是Writer的子类）是按照字符写入的。

    使用输出流进行编程的步骤是：

    1、建立输出流

    建立对应的输出流对象，也就是完成由流对象到外部数据源之间的转换。

    2、向流中写入数据

    将需要输出的数据，调用对应的write方法写入到流对象中。

    3、关闭输出流

    在写入完毕以后，调用流对象的close方法关闭输出流，释放资源。

    在使用输出流向外部输出数据时，程序员只需要将数据写入流对象即可，底层的API实现将流对象中的内容写入外部数据源，这个写入的过程对于程序员来说是透明的，不需要专门书写代码实现。

    在向文件中输出数据，也就是写文件时，使用对应的文件输出流，包括FileOutputStream和FileWriter两个类，下面以FileOutputStream为例子说明输出流的使用。示例代码如下：

              import java.io.*;

/**

* 使用FileOutputStream写文件示例

*/

public class WriteFile1 {

         public static void main(String[] args) {

                   String s = "Java语言";

                   int n = 100;

                   //声明流对象

                   FileOutputStream fos = null;

                   try{

                            //创建流对象

                            fos = new FileOutputStream("e:\\out.txt");

                            //转换为byte数组

                            byte[] b1 = s.getBytes();

                            //换行符

                            byte[] b2 = "\r\n".getBytes();

                            byte[] b3 = String.valueOf(n).getBytes();

                            //依次写入文件

                            fos.write(b1);

                            fos.write(b2);

                            fos.write(b3);

                   } catch (Exception e) {

                            e.printStackTrace();

                   }finally{

                            try{

                                     fos.close();

                            }catch(Exception e){}

                   }

         }

}

    该示例代码写入的文件使用记事本打开以后，内容为：

    Java语言

    100

    在该示例代码中，演示了将一个字符串和一个int类型的值依次写入到同一个文件中。在写入文件时，首先创建了一个文件输出流对象fos：

    fos = new FileOutputStream（"e：\\out.txt"）；

    该对象创建以后，就实现了从流到外部数据源e：\out.txt的连接。说明：当外部文件不存在时，系统会自动创建该文件，但是如果文件路径中包含未创建的目录时将出现异常。这里书写的文件路径可以是绝对路径也可以是相对路径。

    在实际写入文件时，有两种写入文件的方式：覆盖和追加。其中“覆盖”是指清除原文件的内容，写入新的内容，默认采用该种形式写文件，“追加”是指在已有文件的末尾写入内容，保留原来的文件内容，例如写日志文件时，一般采用追加。在实际使用时可以根据需要采用适合的形式，可以使用：

    public FileOutputStream（String name， boolean append） throws FileNotFoundException

    只需要使用该构造方法在构造FileOutputStream对象时，将第二个参数append的值设置为true即可。

    流对象创建完成以后，就可以使用OutputStream中提供的wirte方法向流中依次写入数据了。最基本的写入方法只支持byte数组格式的数据，所以如果需要将内容写入文件，则需要把对应的内容首先转换为byte数组。

    这里以如下格式写入数据：首先写入字符串s，使用String类的getBytes方法将该字符串转换为byte数组，然后写入字符串“\r\n”，转换方式同上，该字符串的作用是实现文本文件的换行显示，最后写入int数据n，首先将n转换为字符串，再转换为byte数组。这种写入数据的顺序以及转换为 byte数组的方式就是流的数据格式，也就是该文件的格式。因为这里写的都是文本文件，所以写入的内容以明文的形式显示出来，也可以根据自己需要存储的数据设定特定的文件格式。

    其实，所有的数据文件，包括图片文件、声音文件等等，都是以一定的数据格式存储数据的，在保存该文件时，将需要保存的数据按照该文件的数据格式依次写入即可，而在打开该文件时，将读取到的数据按照该文件的格式解析成对应的逻辑即可。

    最后，在数据写入到流内部以后，如果需要立即将写入流内部的数据强制输出到外部的数据源，则可以使用流对象的flush方法实现。如果不需要强制输出，则只需要在写入结束以后，关闭流对象即可。在关闭流对象时，系统首先将流中未输出到数据源中的数据强制输出，然后再释放该流对象占用的内存空间。

    使用FileWriter写入文件时，步骤和创建流对象的操作都和该示例代码一致，只是在转换数据时，需要将写入的数据转换为char数组，对于字符串来说，可以使用String中的toCharArray方法实现转换，然后按照文件格式写入数据即可。

    对于其它类型的字节输出流/字符输出流来说，只是在逻辑上连接不同的数据源，在创建对象的代码上会存在一定的不同，但是一旦流对象创建完成以后，基本的写入方法都是write方法，也需要首先将需要写入的数据按照一定的格式转换为对应的byte数组/char数组，然后依次写入即可。

    所以IO类的这种设计形式，只需要熟悉该体系中的某一个类的使用以后，就可以触类旁通的学会其它相同类型的类的使用，从而简化程序员的学习，使得使用时保持统一。

Java编程那些事儿——读取控制台输入

Java, Java培训, Java基础, Java学习, Java教程

11.3.2 读取控制台输入

    前面介绍了使用IO类实现文件读写的示例，其实在很多地方还需要使用到IO类，这里再以读取控制台输入为例子来介绍IO类的使用。

    控制台（Console）指无图形界面的程序，运行时显示或输入数据的位置，前面的介绍中可以使用System.out.println将需要输出的内容显示到控制台，本部分将介绍如何接受用户在控制台中的输入。

    使用控制台输入是用户在程序运行时和程序进行交互的一种基础手段，这种手段是Windows操作系统出现以前，操作系统位于DOS时代时，用户和程序交互的主要手段。当然，现在这种交互的方式已经被图形界面（GUI）程序取代了。

    在读取控制台操作中，操作系统在用户在控制台输入内容，并按回车键提交以后，将用户提交的内容传递给Java运行时系统，Java运行时系统将用户输入的信息构造成一个输入流对象——System.in，在程序员读取控制台输入时，只需要从该流中读取数据即可。至于构造流System.in的过程对于程序员来说是透明的。

    查阅JDK API可以发现，System类中的静态属性in是InputStream类型的对象，可以按照输入流的读取方法读取即可。

    下面的示例代码实现了输入“回显”的功能，即将用户输入的内容重新显示到控制台，示例代码如下：

/**

* 读取控制台输入，并将输入的内容显示到控制台

*/

public class ReadConsole1 {

         public static void main(String[] args) {

                   try{

                            //提示信息

                            System.out.println("请输入：");

                            //数组缓冲

                            byte[] b = new byte[1024];

                            //读取数据

                            int n = System.in.read(b);

                            //转换为字符串

                            String s = new String(b,0,n);

                            //回显内容

                            System.out.println("输入内容为：" + s);

                   }catch(Exception e){}

         }

}

    在该示例代码中，从System.in中读取出用户的输入，然后将用户输入的内容转换为字符串s，然后输出该字符串的内容即可。

    下面实现一个简单的逻辑，功能为：回显用户在控制台输入的内容，当用户输入quit时程序运行结束。实现的代码如下：

           /**

* 读取控制台输入

* 循环回显内容，当输入quit时退出程序

*/

public class ReadConsole2 {

         public static void main(String[] args) {

                   //数组缓冲

                   byte[] b = new byte[1024];

                   //有效数据个数

                   int n = 0;

                   try{

                            while(true){

                                     //提示信息

                                     System.out.println("请输入：");

                                     //读取数据

                                     n = System.in.read(b);

                                     //转换为字符串

                                     String s = new String(b,0,n - 2);

                                     //判断是否是quit

                                     if(s.equalsIgnoreCase("quit")){

                                               break;  //结束循环

                                     }

                                     //回显内容

                                     System.out.println("输入内容为：" + s);

                            }

                   }catch(Exception e){}

         }

}

    在该示例代码中，加入了一个while循环，使得用户的输入可以进行多次，在用户输入时，送入输入流的内容除了用户输入的内容以外，还包含“\r\n”这两个字符，所以在将输入的内容和quit比较时，去掉读出的最后2个字符，将剩余的内容转换为字符串。

Java编程那些事儿——读取控制台输入 2

Java, Java培训, Java基础, Java学习, Java教程

最后是一个简单的《掷骰子》的控制台小游戏，在该游戏中，玩家初始拥有1000的金钱，每次输入押大还是押小，以及下注金额，随机3个骰子的点数，如果3 个骰子的总点数小于等于9，则开小，否则开大，然后判断玩家是否押对，如果未押对则扣除下注金额，如果押对则奖励和玩家下注金额相同的金钱。该程序的示例代码如下：

            /**

* 掷骰子游戏实现

*/

public class DiceGame {

         public static void main(String[] args) {

                   int money = 1000; //初始金钱数量

                   int diceNum = 0; // 掷出的骰子数值和

                   int type = 0; // 玩家押的大小

                   int cMoney = 0; // 当前下注金额

                   boolean success; // 胜负

                   // 游戏过程

                   while (true) {

                            // 输入大小

                            System.out.println("请押大小(1代表大，2代表小):");

                            type = readKeyboard();

                            // 校验

                            if (!checkType(type)) {

                                     System.out.println("输入非法，请重新输入！");

                                     continue;

                            }

                            // 输入下注金额

                            while(true){

                                     System.out.println("你当前的金钱数量是"

                                                                 + money + "请下注:");

                                     cMoney = readKeyboard();

                                     // 校验

                                     if (!checkCMoney(money,cMoney)) {

                                               System.out.println("输入非法，请重新输入！");

                                               continue;

                                     }else{

                                               break;

                                     }

                            }

                            // 掷骰子

                            diceNum = doDice();

                            // 判断胜负

                            success = isSuccess(type,diceNum);

                            // 金钱变化

                            money = changeMoney(money,success,cMoney);

                            // 游戏结束

                            if(isEnd(money)){

                                     System.out.println("你输了，bye！");

                                     break;

                            }

                   }

         }

         /**

          * 读取用户输入

          * @return 玩家输入的整数，如果格式非法则返回0

          */

         public static int readKeyboard() {

                   try {

                            // 缓冲区数组

                            byte[] b = new byte[1024];

                            // 读取用户输入到数组b中，

                            // 读取的字节数量为n

                            int n = System.in.read(b);

                            // 转换为整数

                            String s = new String(b, 0, n - 2);

                            int num = Integer.parseInt(s);

                            return num;

                   } catch (Exception e) {}

                   return 0;

         }

         /**

          * 押的类型校验

          * @param type  类型

          * @return true代表符合要求，false代表不符合

          */

         public static boolean checkType(int type) {

                   if (type == 1 || type == 2) {

                            return true;

                   } else {

                            return false;

                   }

         }

         /**

          * 校验下注金额是否合法

          * @param money   玩家金钱数

          * @param cMoney  下注金额

          * @return true代表符合要求，false代表不符合要求

          */

         public static boolean checkCMoney(int money, int cMoney) {

                   if (cMoney <= 0) {

                            return false;

                   } else if (cMoney <= money) {

                            return true;

                   } else {

                            return false;

                   }

         }

         /**

          * 掷骰子

          * @return 骰子的数值之和

          */

         public static int doDice() {

                   int n = (int) (Math.random() * 6) + 1;

                   int n1 = (int) (Math.random() * 6) + 1;

                   int n2 = (int) (Math.random() * 6) + 1;

                   // 输出随机结果

                   System.out.println("庄家开：" + n + " " + n1 + " " + n2);

                   return n + n1 + n2;

         }

         /**

          * 胜负判断

          * @param type  用户输入类型

          * @param diceNum   骰子点数

          * @return true代表赢，false代表输

          */

         public static boolean isSuccess(int type, int diceNum) {

                   // 计算庄家类型

                   int bankerType = 0;

                   if (diceNum <= 9) {

                            bankerType = 2;

                            System.out.println("庄家开小!");

                   } else {

                            bankerType = 1;

                            System.out.println("庄家开大!");

                   }

                   if (bankerType == type) { // 赢

                            return true;

                   } else { // 输

                            return false;

                   }

         }

         /**

          * 金钱变化

          * @param money 用户钱数

          * @param success 胜负

          * @param cMoney 下注金额

          * @return 变化以后的金钱

          */

         public static int changeMoney(int money, boolean success, int cMoney) {

                   if (success) {

                            money += cMoney;

                   } else {

                            money -= cMoney;

                   }

                   System.out.println("剩余金额：" + money);

                   return money;

         }

         /**

          * 判断游戏是否结束

          * @param money 玩家金钱

          * @return true代表结束

          */

         public static boolean isEnd(int money) {

                   return money <= 0;

         }

}

Java编程那些事儿——装饰流使用1

Java装饰流, Java培训, Java基础, Java学习, Java教程

11.3.3 装饰流使用

    除了按照流的方向可以把流划分为输入流和输出流两类，按照流读写数据的基本单位把流划分为字节流和字符流两类以外，还可以按照流是否直接连接实际数据源，例如文件、网络、字节数组等，将流又可以划分为实体流和装饰流两大类。

    其中实体流指直接连接数据源的流类，如前面介绍的FileInputStream/FileOutputStream和FileReader和 FileWriter，该类流直接实现将数据源转换为流对象，在实体流类中实现了流和数据源之间的转换，实体流类均可单独进行使用。

    而装饰流指不直接连接数据源，而是以其它流对象（实体流对象或装饰流对象）为基础建立的流类，该类流实现了将实体流中的数据进行转换，增强流对象的读写能力，比较常用的有DataInputStream/DataOutputStream和BufferedReader/BufferedWriter等，装饰流类不可以单独使用，必须配合实体流或装饰流进行使用。

    由于装饰流都是在已有的流对象基础上进行创建的，所以这种创建流的方式被称作“流的嵌套”，通过流的嵌套，可以修饰流的功能，例如使读写的速度增加或者提供更多的读写方式，方便数据格式的处理。

    装饰流不改变原来实体流对象中的数据内容，只是从实体流对象基础上创建出的装饰流对象相对于实体流对象进行了一些功能的增强。

    流的嵌套是学习IO编程时必须掌握的知识，使用它才可以让你真正体会到IO类设计时的设计思路，也可以方便的使用IO类。

    下面分别以DataInputStream/DataOutputStream和BufferedReader/BufferedWriter为例子，详细介绍装饰类的使用。

    11.3.3.1 DataInputStream/DataOutputStream

    在前面的示例中，在向流中写入的数据必须首先转换为byte数组或char数组，当写入的数据比较少、比较简单时，则向流中写入数据时还是不是很麻烦的，但是如果向流中写入数据比较多时，手动转换数据格式则会比较麻烦。当然，很多文件都是根据文件存储的需要设计了专门的存储格式，但是这些格式一般都比较复杂，需要阅读专门的格式文档才可以读写这些特定格式的文件。

    为了简化程序员对于流的操作，使得程序员可以从繁杂的数据格式中解脱出来，在IO类中专门设计了两个类—— DataInputStream/DataOutputStream类简化流数据的读写，使用这两个类，可以实现以增强型的读写方法读写数据，使得读写流的数据变得比较简单。

    在实际使用这两个类时，必须匹配起来进行使用。也就是说，只有使用DataOutputStream流格式写入的数据，在实际读取时才可以使用 DataInputStream进行读取。因为在使用DataOutputStream向流中写入数据时，除了写入实际的数据内容以外，还写入了特定的数据格式，该格式对于程序员来说是透明的，这种特定的格式不需要程序员熟悉，而只需要使用DataInputStream读取即可，读取时的顺序和写入时的顺序和类型保持一致即可。

    在DataInputStream类中，增加了一系列readXXX的方法，例如readInt、readUTF、readBoolean等等，而在 DataOutputStream类中，也增加了一系列writeXXX的方法，例如writeInt、writeUTF、writeBoolean等等，使得对于数据的读写更加方便很容易。

    下面以读写文件为例子，演示DataInputStream/DataOutputStream类的基本使用。

/**

* 模拟需要存储到文件中的数据

* 该类中保存4种类型的数据

*/

public class MyData {

         boolean b;

         int n;

         String s;

         short sh[];

        

         public MyData(){}

        

         public MyData(boolean b,int n,String s,short sh[]){

                   this.b = b;

                   this.n = n;

                   this.s = s;

                   this.sh = sh;

         }

}

    在该示例中，需要将MyData类型的对象内部保存的数据按照一定的格式存储到文件中，这里列举了2种基本数据类型boolean和int，以及两种引用数据类型String和数组，在下面的示例代码中将会以一定的格式写入到文件中。

Java编程那些事儿——装饰流使用2

Java, Java培训, Java基础, Java学习, Java教程

import java.io.*;

/**

* 使用DataOutputStream书写具有一定格式的文件

*/

public class WriteFileUseDataStream {

         public static void main(String[] args) {

                   short sh[] = {1,3,134,12};

                   MyData data =new MyData(true,100,"Java语言",sh);

                   //写入文件

                   writeFile(data);

         }

        

         /**

          * 将MyData对象按照一定格式写入文件中

          * @param data 数据对象

          */

         public static void writeFile(MyData data){

                   FileOutputStream fos = null;

                   DataOutputStream dos = null;

                   try{

                            //建立文件流

                            fos = new FileOutputStream("test.my");

                            //建立数据输出流，流的嵌套

                            dos = new DataOutputStream(fos);

                            //依次写入数据

                            dos.writeBoolean(data.b);

                            dos.writeInt(data.n);

                            dos.writeUTF(data.s);

                            //写入数组

                            int len = data.sh.length;

                            dos.writeInt(len); //数组长度

                            //依次写入每个数组元素

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

                                     dos.writeShort(data.sh[i]);

                            }

                   }catch(Exception e){

                            e.printStackTrace();

                   }finally{

                            try {

                                     dos.close();

                                     fos.close();

                            } catch (Exception e2){

                                     e2.printStackTrace();

                            }

                   }

         }

}

    在该示例代码中，首先建立一个实体流fos，该实体流连接到数据源——文件，然后以该实体流对象为基础，使用流的嵌套，建立装饰流对象dos，由于需要写入流中的对象data中包含的数据比较多，所以需要以一定的格式写入流，这里使用DataOutputStream避免自定义数据格式，而写入流中的顺序就是该流的格式，也就是文件test.my的格式，这种格式对于程序员来说是透明的。

    使用对象dos中对应的writeXXX方法依次将需要存储的数据写入流中，在写入字符串时，为了使字符编码保持一致，一般使用writeUTF写入字符串，也就是先将字符串转换为utf-8格式的byte数组，然后再将该数组以一定的格式写入到流中。而在写入数组时，则首先写入数组的长度，然后再将数组的内容依次写入到流中，使用这种方式就可以很方便的将数组写入到流中。

    这样文件test.my文件就具有了自己特定的文件格式，程序员需要记忆的就是该文件在写入时的写入顺序，可以很方便的使用DataInputStream读取出来。

    下面的代码是使用DataInputStream读取test.my文件的代码，注意文件格式的处理。

             import java.io.*;

/**

* 使用DataInputStream读取自定义格式的文件

*/

public class ReadFileUseDataStream {

         public static void main(String[] args) {

                   MyData data = readFile();

                   System.out.println(data.b);

                   System.out.println(data.n);

                   System.out.println(data.s);

                   int len = data.sh.length;

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

                            System.out.println(data.sh[i]);

                   }

         }

        

         /**

          * 从文件test.my中读取数据，并使用读取到的数据初始化data对象

          * @return 读取到的对象内容

          */

         public static MyData readFile(){

                   MyData data = new MyData();

                   FileInputStream fis = null;

                   DataInputStream dis = null;

                   try {

                            //建立文件流

                            fis = new FileInputStream("test.my");

                            //建立数据输入流，流的嵌套

                            dis = new DataInputStream(fis);

                            //依次读取数据，并赋值给data对象

                            data.b = dis.readBoolean();

                            data.n = dis.readInt();

                            data.s = dis.readUTF();

                            int len = dis.readInt();

                            data.sh = new short[len];

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

                                     data.sh[i] = dis.readShort();

                            }                          

                   } catch (Exception e) {

                            e.printStackTrace();

                   }finally{

                            try {

                                     dis.close();

                                     fis.close();

                            } catch (Exception e) {

                                     e.printStackTrace();

                            }

                   }

                   return data;

         }

}

    在该示例代码中，首先建立实体流fis，然后以该流对象为基础建立dos装饰流，然后按照写入文件的顺序，依次将流中的数据读取出来，并将读取到的数值赋值给data对象中对应的属性，从而实现将数据从文件中恢复到实际的对象。

    最后再次强调，DataInputStream和DataOutputStream必须匹配起来进行使用，也就是使用DataInputStream读取的流数据必须是使用DataOutputStream流写入的数据，这样才能保持格式上的统一。

    当然，使用DataInputStream和DataOutputStream和其它的实体流也可以匹配起来进行使用，例如和 ByteArrayInputStream和ByteArrayOutputStream匹配使用将可以实现方便的把数据转换为特定格式的byte数组以及将byte数组恢复回来，使用的格式和上面的示例类似，这里就不再重复了。

Java编程那些事儿——装饰流使用3

Java, Java培训, Java基础, Java学习, Java教程

11.3.3.2 BufferedReader/BufferedWriter

    在进行IO操作时，除了功能以外，程序的执行效率也是必须要考虑的问题。基本的IO类只是注重功能的实现，例如将特定的数据源转换为流对象，而没有过多的关注读写的效率问题，而实际在进行项目开发时，读写效率也是必须要考虑的问题。

    为了提高IO类的读写效率，在装饰流中专门制作了一类缓冲流，该类流的作用就是提高流的读写效率，这组缓冲流包含：BufferedInputStream/BufferedOutputStream、BufferedReader /BufferedWriter.

    该部分以BufferedReader/BufferedWriter为基础进行介绍。

    由于前面介绍DataInputStream/DataOutputStream时，是以文件流作为实体流进行介绍，这里就不再重复了，这里以前面介绍的接收控制台输入为基础介绍缓冲输入流的使用。

    由于装饰流在进行嵌套时，只能嵌套相同类型的流，例如InputStream类型的流之间可以嵌套，但是InputStream和Reader两个体系之间的流就无法直接嵌套，为了使用新的IO类带来的特性，在IO类中提供了两个专门的类，实现体系之间的转换，这两个流类被形象的称为“桥接流”。

    桥接流主要包含2个，依次是：

    1、InputStreamReader

    该类实现将InputStream及其子类的对象转换为Reader体系类的对象，实现将字节输入流转换为字符输入流。

    2、OutputStreamWriter

    该类实现将OutputStream及其子类的对象转换为Writer体系类的对象，实现将字节输入流转换为字符输入流。

    这两个桥接流使得字节流可以被转换为字符流，但是需要注意的是，字符流无法转换为字节流。

    在读取控制台输入时，直接使用System.in进行读取，虽然在功能上可以实现，但是这种方式读写流的效率比较差，所以在实际使用时一般需要提高读写的效率，这就需要使用装饰流中的缓冲流，这是一个典型的流的嵌套的示例。该代码实现的功能是如果回显用户输入，当用户输入quit时程序退出。该示例的代码如下：

                   import java.io.*;

/**

* 使用BufferedReader读取控制台输入

*/

public class ReadConsoleWithBuffer {

         public static void main(String[] args) {

                   BufferedReader br = null;

                   String s = null;

                   try{

                            //使用流的嵌套构造缓冲流

                            br = new BufferedReader(

                                               new InputStreamReader(System.in));

                            do{

                                     //输出提示信息

                                     System.out.println("请输入：");

                                     //按行读取输入

                                     s = br.readLine();

                                     //输出用户输入

                                     System.out.println(s);

                            }while(!s.equals("quit"));

                   }catch(Exception e){

                            e.printStackTrace();

                   }finally{

                            try{

                                     br.close();

                            }catch(Exception e){

                                     e.printStackTrace();

                            }

                   }

         }

}

    在该示例代码中，首先使用流的嵌套构建了BufferedReader类型的对象br，然后使用BufferedReader中的readLine方法，每次读取用户输入的一行信息，使用readLine方法读取内容时，系统以“\r\n”作为每次的结束符号，而且读取的内容不包含“\r\n”，当读取到流的末尾时readLine方法的返回值是null.然后使用do-while循环判断用户输入的是否是quit，如果输入的是quit，则程序结束，否则继续下一次循环。

    关于BufferedWriter的使用，没有什么特别的地方，这里就不单独举例说明了。

    11.3.3.3 装饰流小结

    前面介绍了两类比较常见的装饰流，在实际的开发中，根据逻辑的需要还可能会用到其它的装饰流，这些装饰流的使用和前面介绍的类类似，在实际使用时通过查阅JDK API文档找到根据功能找到合适的装饰流，然后进行使用即可。

Java编程那些事儿——IO使用注意问题

Java, Java培训, Java基础, Java学习, Java教程

11.3.4 注意问题

    上面介绍了IO类的基本使用，熟悉了实体流和装饰流的基本使用，但是在IO类实际使用时，还是会遇到一系列的问题，下面介绍一些可能会经常遇到的问题。

    11.3.4.1 类的选择

    对于初次接触IO技术的初学者来说，IO类体系博大精深，类的数量比较庞大，在实际使用时经常会无所适从，不知道该使用那些类进行编程，下面介绍一下关于IO类选择的一些技巧。

    选择类的第一步是选择合适的实体流。

    选择实体流时第一步是按照连接的数据源种类进行选择，例如读写文件应该使用文件流，如 FileInputStream/FileOutputStream、FileReader/FileWriter，读写字节数组应该使用字节数组流等，如ByteArrayInputStream/ByteArrayOutputStream.

    选择实体流时第二步是选择合适方向的流。例如进行读操作时应该使用输入流，进行写操作时应该使用输出流。

    选择实体流时第三步是选择字节流或字符流。除了读写二进制文件，或字节流中没有对应的流时，一般都优先选择字符流。

    经过以上步骤以后，就可以选择到合适的实体流了。下面说一下装饰流的选择问题。

    在选择IO类时，实体流是必需的，装饰流是可选的。另外在选择流时实体流只能选择一个，而装饰流可以选择多个。

    选择装饰流时第一步是选择符合要求功能的流。例如需要缓冲流的话选择BufferedReader/BufferedWriter等，有些时候也可能只是为了使用某个装饰流内部提供的方法。

    选择装饰流时第二步是选择合适方向的流，这个和实体流选择中的第二步一致。

    当选择了多个装饰流以后，可以使用流之间的多层嵌套实现要求的功能，流的嵌套之间没有顺序。

    11.3.4.2  非依次读取流数

    据由于IO类设计的特点，在实际读取时，只能依次读取流中的数据，而且在通常情况下，已经读取过的数据无法再进行读取。如果需要重复读取流中某段数据时，一般的做法是将从流中读取的数据使用数组存储起来，然后根据需要读取数组中的内容即可，但是有些时候，还是有一些特殊的情况的，IO类对于这些都进行了支持。

    1、间断性的读取流中的数据

    对于某些特殊格式的文件，例如字体文件等，在实际读取数据时不需要顺序进行读取，而只需要根据内容的位置进行读取。这样可以使用流中的skip方法实现。例如：

    int n = fis.skip（100）；

    该行代码的作用是，以流fis当前位置为基础，当前位置可以是流中的任何位置，向后跳过100个单位（字节流单位为字节，字符流单位是字符），如果再使用read方法继续读取，就是读取跳跃以后新位置的内容，也就相当于跳过了100个单位的内容。

    而实际在使用时，实际真正跳过的单位数量作为skip方法的返回值返回。

   2、重复读取流中某段数据

    当必须重复读取流中同一段数据时，如果对应的流支持mark（标记）的话，则可以重复读取同一段数据。

    下面以重复读取控制台输入流System.in为例子，来介绍mark的使用，示例代码如下：

         import java.io.*;

/**

* mark使用示例

*/

public class MarkUseDemo {

         public static void main(String[] args) {

                   byte[] b = new byte[1024];

                   try{

                            //读取数据

                            int data = System.in.read();

                            //输出第一个字节的数据

                            System.out.println("第一个字节：" + data);

                            //判断该流是否支持mark

                            if(System.in.markSupported()){

                                     //记忆当前位置，可以从当前位置

                                     //向后最多读取100个字节

                                     System.in.mark(100);

                                     //读取数据

                                     int n = System.in.read(b);

                                     //输出读取到的内容

                                     System.out.print("第一次读取到的内容：");

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

                                               System.out.print(b[i] + " ");

                                     }

                                     System.out.println();

                                     //回到标记位置

                                     System.in.reset();

                                     //重复读取标记位置以后的内容

                                     n = System.in.read(b);

                                     //输出读取到的内容

                                     System.out.print("第二次读取到的内容：");

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

                                               System.out.print(b[i] + " ");

                                     }

                                     System.out.println();

                            }

                   }catch(Exception e){

                            e.printStackTrace();

                   }

         }

}

    在该示例中，首先调用System.in流中的read方法，读取流中的第一个字节，并把读取到的数据赋值给data，然后将读取到的第一个字节的数据输出出来。

    然后调用System.in流中的markSupported判断该流是否支持mark功能，如果支持的话则markSupported方法将返回true.

    如果流System.in支持mark，则标记当前位置，并允许从当前位置开始最多读取后续100个字节的数据，其实IO类内部的只读取这些数据，而不真正从流中将这些数据删除。

    后续继续读取流中的数据，如果读取的数据超过100个字节，则mark标记失效，并把读取到的有效数据输出到控制台。

    如果需要从标记位置重复读取已经读取过的数据，则只需要调用流对象中的reset方法重置流的位置，使流可以回到mark的位置，如果继续读取的话，则从该位置开始可以向后读取。这样就可以从mark的位置开始，再次读取后续的数据了。

    例如在控制台输入123456789，则该程序的执行结果是：

    第一个字节：49

    第一次读取到的内容：50 51 52 53 54 55 56 57 13 10

    第二次读取到的内容：50 51 52 53 54 55 56 57 13 10

    其中输入的第一个字节是1，读取时该字符的编码是49，而后续的内容就是流的结构，其中流末尾的13和10是在输入时，添加的回车和换行字符。

    11.3.4.3 中文问题

    由于JDK设计时，对于国际化支持比较好，所以JDK在实际实现时支持很多的字符集，这样在进行特定字符集的处理时就需要特别小心了。

    其实在进行中文处理时，只需要注意一个原则就可以了，这个原则就是将中文字符转换为byte数组时使用的字符集，需要和把byte数组转换为中文字符串时的字符集保持一致，这样就不会出现中文问题了。

    当然，如果不想手动实现字符串和byte数组的转换，可以使用DataInputStream和DataOutputStream中的readUTF和writeUTF实现读写字符串。

    11.4 总结

    关于IO类的使用，还需要在实际开发过程中多进行使用，从而更深入的体会IO类设计的初衷，并掌握IO类的使用。

    另外，IO类是Java中进行网络编程的基础，所以熟悉IO类的使用也是学习网络编程必须的一个基础。

第十二章 多线程

         当计算机处于DOS时代时，程序几乎是没有界面的，而且由于计算机运行速度等原因，那个时代的计算机只能启动一个程序，只有当该程序退出以后才可以执行其它的程序。但是随着计算机性能的提高，以及软件的丰富，如果计算机还只能同时执行一个程序的话，那么计算机恐怕是很多人都不能接受的。

         这种在任何一个时间点，可以有多个程序同时执行，或者有多个程序逻辑同时执行的能力，成为并发执行。

         现在计算机早已进入到并发执行的时代，对于程序编程来说，进行并发执行的程序编写也就被称作并发编程，在Java语言中，同一个程序内部的并发处理由线程这个概念来实现。

12.1 多线程简介

         从小时候开始，老师就教育大家——“一心不可二用”，这是指做一件事情的时候一定要专注，不能够分心。但是在程序编程的领域却早已经需要做到“一心二用”甚至“一心多用”了。下面来看一下线程的概念吧！

12.1.1 进程和线程

         在介绍线程的概念以前，首先介绍一下进程的概念。

         进程(Process)指操作系统中一个独立运行的程序。例如在计算机中，同时运行着QQ、Word、MSN等，那么QQ程序是一个进程，MSN程序也是一个进程。在Windows操作系统中的任务管理器中，就可以清晰的看到当前操作系统中正在运行的进程信息。

         进程，也称任务，所以支持多个进程同时执行的操作系统就被称作多进程操作系统或多任务操作系统，现在主流的操作系统都属于这种类型。在操作系统中，每个进程拥有独立的内存空间等系统资源，进程和进程之间的系统资源不互用，所以进程之间的通信比较麻烦。通过在操作系统上同时运行多个进程，可以充分发挥计算机的硬件能力，更方便用户使用，也使得各种各样的程序大量出现。

         对于只有一个CPU的计算机来说，是如何实现同时执行多个进程的呢？其实CPU采用的原理就是分时执行，每个进程处于操作系统的进程队列中。然后每个进程依次获得一个时间片进入CPU进行执行，在该时间片执行完成以后，该进程保存自身状态，退出CPU，然后其它的进程进入CPU继续执行。由于时间片的时间很短，例如Windows操作系统的时间片是20ms，所以在计算机用户看来程序就是同时执行的，而实际的执行方式是穿插依次执行的。而对于多CPU的计算机来说，只是排队的队列增加了几个而已，每个队列的实现方式和上面的介绍类似。

         但是进程的概念相对比较大，而且需要成为一个独立的程序，这样对于编程来说比较麻烦，所以在程序开发中设计了另外一个概念——线程。

         线程(Thread)指同一个程序(进程)内部每个单独执行的流程。在前面的程序中每个程序内部都只包含一个系统流程，该流程从main方法开始，随着方法的调用进入到每个方法的内部，在方法调用完成以后返回到调用的位置，直到main方法结束以后则该流程结束，这个流程就是前面程序中的系统线程。Java语言对于线程的概念提供了良好的支持，在编程中实际使用线程也显得比其它语言要简单一些。

         而在实际实现时，Java语言支持在一个程序内部同时执行多个流程，其中每个单独的流程就是一个线程。例如在QQ程序中，系统的线程负责响应用户的按键操作，在后台可以启动网络通讯的线程执行数据的发送和接收，这样两个流程之间同时执行，并协调进行工作。而在服务器端程序中，每个和服务器进行通讯的客户端，在服务器端都会启动一个对应的线程进行通讯，这样每个客户端才显得同时和服务器端进行通讯。

         在很多地方，线程被看作是一种“轻量级进程”，因为使用线程和进程的改变比较类似，而且使用线程时对于系统资源，如内存、CPU等，的占用要比进程小很多，也就是有更小的系统开销。另外，同一个程序中的线程之间变量是共享的，线程之间的数据交换要比进程之间的数据交换简单一些。

         总之，无论是进程的概念还是线程的概念，都使编程从串行编程(依次执行)进入到并行编程(同时执行)的领域，而在CPU内部实现的原理都是按照时间片进行切换。

12.1.2 多线程优势

         线程的概念增加了编程的难度，也增加了程序的复杂度，但是该概念还是在程序内部大量进行使用，这主要因为多线程程序的优势。

         多线程程序主要的优势有两个：

1、  提高界面程序响应速度

通过使用线程，可以将需要大量时间完成的流程在后台完成，例如现在常见的网络程序，在进行网络通讯时都需要使用单独的流程进行，也就是启动一个单独的线程进行，这样不会阻塞系统线程的执行，也就是不会阻塞对于界面的操作。另外，如果需要大量操作数据或进行数据变换的程序，也需要在后台启动单独的线程来提高前台界面的响应速度。

通过将程序逻辑独立成一个单独的线程，使得控制界面的系统线程和逻辑线程同时执行，避免了逻辑操作需要大量的时间阻塞系统的线程执行，从而大幅度提高界面程序的响应速度。

2、  充分利用系统资源

通过在一个程序内部同时执行多个流程，可以充分利用CPU等系统资源，从而最大限度的发挥硬件的吸能。就像一个人同时承担多份工作一样，这样可以使这个人的时间获得比较充分的使用。

         当然，多线程程序也有一些不足，例如当程序中的线程数量比较多时，系统将花费大量的时间进行线程的切换，这反而会降低程序的执行效率。

但是，相对于优势来说，劣势还是很有限的，所以在现在的项目开发中，多线程编程技术获得了广泛的使用。

12.1.3 线程生命周期

         线程作为一个全新的概念，主要由系统进行管理，但是熟悉线程概念的各个阶段，是控制线程程序执行的基础，和以后学习的其它Java技术类似，线程在程序中从出现到消亡的各个阶段，在程序中统称为线程的生命周期。

         在Java语言中线程的概念由java.lang.Thread类实现，在该类中封装线程的概念，并且将线程控制的相关方法包含在该类的内部。后续介绍中如果没有特别说明，则提到的方法均是Thread类内部的方法。

         线程的生命周期中包含如下阶段：

1、  新建状态(New)

该状态指线程已经初始化完成，但是还没有启动。具体点说，也就是线程对象已经创建，准备工作已经完成。

2、  运行状态(Run)

运行状态是指线程的正常执行状态，处于该状态的线程在CPU内部执行程序，也就是线程正常运行时的状态。

3、  阻塞状态(Block)

阻塞状态指线程处于执行状态，但是由于没有获得CPU的执行时间，而处于CPU外部等待线程执行的状态。

4、  死亡状态(Dead)

死亡状态指线程执行结束，释放线程占用的系统资源，结束线程执行的状态。

         在实际使用线程时，首先需要创建一个线程对象，在线程对象创建完成以后，该线程就处于新建状态了，在新建状态下的线程，已经初始化完成，但是还没有启动，也就是不会获得CPU的执行时间。在新建状态下，一般可以通过调用线程对象中的start方法，使线程进入到运行状态，start方法不阻塞程序的执行，在调用完成以后立刻就返回了。一旦线程进入运行状态，则开始排队进入CPU执行，根据系统的调度，线程就在运行状态和阻塞状态之间进行切换，这就是线程的执行状态。当线程执行完成或需要结束该流程时，则需要将线程切换到死亡状态，释放线程占用的资源，结束线程的执行。

         另外在线程执行的过程中也可以根据需要调用Thread类中对应的方法改变线程的状态。例如使用线程对象的interrupt中断线程的执行，使线程进入到死亡状态；使用yield方法使当前正在执行的线程从运行状态切换到阻塞状态。

         而具体线程编程的实现方式、线程的控制以及线程编程时需要注意的问题，则将在下面进行详细的介绍。

本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/Mailbomb/archive/2009/05/18/4198613.aspx

12.2 多线程实现方式

         线程的概念虽然比较复杂，但是在Java语言中实现线程却比较简单，只需要按照Java语言中对于线程的规定进行编程即可。

         在实现线程编程时，首先需要让一个类具备多线程的能力，继承Thread类或实现Runnable接口的类具备多线程的能力，然后创建线程对象，调用对应的启动线程方法开始执行即可实现多线程编程。

         在一个程序中可以实现多个线程，多线程编程指在同一个程序中启动了两个或两个以上的编程形式。当启动的线程数量比较多时，对于系统资源的要求比较多，所以程序支持的最大线程数量和计算机的硬件配置相关。

在实际实现线程时，Java语言提供了三种实现方式：

1、  继承Thread类

2、  实现Runnable接口

3、  使用Timer和TimerTask组合

下面依次介绍每种实现方式的代码编写，以及各种实现之间的区别比较。

12.2.1 继承Thread类

         如果一个类继承了Thread类，则该类就具备了多线程的能力，则该类则可以以多线程的方式进行执行。

         但是由于Java语言中类的继承是单重继承，所以该方式受到比较大的限制。

         下面以一个简单的示例介绍该种多线程实现方式的使用以及启动线程的方式。示例代码如下所示：

                   /**

 * 以继承Thread的方式实现线程

 */

public class FirstThread extends Thread{

         public static void main(String[] args) {

                   //初始化线程

                   FirstThread ft = new FirstThread();

                   //启动线程

                   ft.start();

                   

                   try{

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

                                     //延时1秒

                                     Thread.sleep(1000);

                                     System.out.println("main:" + i);

                            }

                   }catch(Exception e){}

         }

 

         public void run(){

                   try{

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

                                     //延时1秒

                                     Thread.sleep(1000);

                                     System.out.println("run:" + i);

                            }

                   }catch(Exception e){}

         }

}

         在该程序中，通过使FirstThread继承Thread类，则FirstThread类具备了多线程的能力，按照Java语言线程编程的规定，线程的代码必须书写在run方法内部或者在run方法内部进行调用，在示例的代码中的run方法实现的代码作用是每隔1秒输出一行文字。换句话说，run方法内部的代码就是自定义线程代码，或者说，自定义线程的代码必须书写在run方法的内部。

         在执行FirstThread类时，和前面的执行流程一样。当执行FirstThread类时，Java虚拟机将开启一个系统线程来执行该类的main方法，main方法的内部代码按照顺序结构进行执行，首先执行线程对象的初始化，然后执行调用start方法。该行代码的作用是启动线程，在执行start方法时，不阻塞程序的执行，start方法的调用立刻返回，Java虚拟机以自己的方式启动多线程，开始执行该线程对象的run方法。同时系统线程的执行流程继续按照顺序执行main方法后续的代码，执行main方法内部的输出。

         这样，在FirstThread执行时，就有了两个同时执行的流程：main流程和自定义run方法流程，换句专业点的话来说，就是该程序在执行时有两个线程：系统线程和自定义线程。这个同时执行可以从该程序的执行结果中获得更加直接的证明。

         该程序的执行结果为：

                   run:0

main:0

main:1

run:1

main:2

run:2

main:3

run:3

main:4

run:4

main:5

run:5

main:6

run:6

main:7

run:7

main:8

run:8

main:9

run:9

         从执行结果可以看到两个线程在同时执行，这将使我们进入多线程编程的时代，进入并发编程的领域，体会神奇的多线程编程的魔力。

         由于两个线程中的延迟时间——1秒，是比较长的，所以看到的结果是线程规律执行的，其实真正的线程执行顺序是不能直接保证的，系统在执行多线程程序时只保证线程是交替执行的，至于那个线程先执行那个线程后执行，则无法获得保证，需要书写专门的代码才可以保证执行的顺序。

         其实，上面的代码可以简化，简化以后的代码为：

                   /**

 * 以继承Thread的方式实现线程2

 * 使用方法简化代码

 */

public class SecondThread extends Thread{

         public static void main(String[] args) {

                   //初始化线程

                   SecondThread ft = new SecondThread();

                   //启动线程

                   ft.start();

                   

                   print("main:");

         }

 

         public void run(){

                   print("run:");

         }

         

         private static void print(String s){

                   try{

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

                                     //延时1秒

                                     Thread.sleep(1000);

                                     System.out.println(s + i);

                            }

                   }catch(Exception e){}

         }

}

         在该示例代码中，将重复的代码组织称print方法，分别在main方法和run方法内部调用该方法。需要特别强调的是，在run方法内部调用的方法，也会以多线程多线程的方式被系统执行，这样更加方便代码的组织。

         其实在实际实现时，还可以把线程以单独类的形式出现，这样实现的代码如下所示：

                   /**

 * 测试类

 */

public class Test {

         public static void main(String[] args) {

                   //初始化线程

                   ThirdThread ft = new ThirdThread();

                   //启动线程

                   ft.start();

                   

                   try{

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

                                     //延时1秒

                                     Thread.sleep(1000);

                                     System.out.println("main:" + i);

                            }

                   }catch(Exception e){}

         }

}

         /**

 * 以继承Thread类的方式实现多线程3

 * 以单独类的实现组织代码

 */

public class ThirdThread extends Thread {

         public void run(){

                   try{

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

                                     //延时1秒

                                     Thread.sleep(1000);

                                     System.out.println("run:" + i);

                            }

                   }catch(Exception e){}

         }

}

         在该示例代码中，ThirdThread类是一个单独的线程类，在该类的run方法内部实现线程的逻辑，使用该种结构符合面向对象组织代码的方式。需要启动该线程时，和前面启动的方式一致。

         一个类具备了多线程的能力以后，可以在程序中需要的位置进行启动，而不仅仅是在main方法内部启动。

         对于同一个线程类，也可以启动多个相同的线程，例如以ThirdThread类为例，启动两次的代码为：

                   ThirdThread t1 = new ThirdThread();

                   t1.start();

                   ThirdThread t2 = new ThirdThread();

                   t2.start();

         而下面的代码是错误的

                   ThirdThread t1 = new ThirdThread();

                   t1.start();

                   t1.start(); //同一个线程不能启动两次

         当自定义线程中的run方法执行完成以后，则自定义线程将自然死亡。而对于系统线程来说，只有当main方法执行结束，而且启动的其它线程都结束以后，才会结束。当系统线程执行结束以后，则程序的执行才真正结束。

         总之，继承Thread类可以使该类具备多线程的能力，需要启动该线程时，只需要创建该类的对象，然后调用该对象中的start方法，则系统将自动以多线程的发那个是执行该对象中的run方法了。

         虽然该种方式受到Java语法中类的单重继承的限制，但是在实际的项目中还是获得了比较广泛的使用，是一种最基本的实现线程的方式。

本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/Mailbomb/archive/2009/05/19/4200767.aspx

12.2.2实现Runnable接口

         一个类如果需要具备多线程的能力，也可以通过实现java.lang.Runnable接口进行实现。按照Java语言的语法，一个类可以实现任意多个接口，所以该种实现方式在实际实现时的通用性要比前面介绍的方式好一些。

         使用实现Runnable接口实现多线程的示例代码如下：

                   /**

 * 测试类

 */

public class Test2 {

         public static void main(String[] args) {

                   //创建对象

                   MyRunnable mr = new MyRunnable();

                   Thread t = new Thread(mr);

                   //启动

                   t.start();

                   try{

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

                                     Thread.sleep(1000);

                                     System.out.println("main:" + i);

                            }

                   }catch(Exception e){}

         }

}

         /**

 * 使用实现Runnable接口的方式实现多线程

 */

public class MyRunnable implements Runnable {

         public void run() {

                   try{

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

                                     Thread.sleep(1000);

                                     System.out.println("run:" + i);

                            }

                   }catch(Exception e){}

         }

}

该示例代码实现的功能和前面实现的功能相同。在使用该方式实现时，使需要实现多线程的类实现Runnable，实现该接口需要覆盖run方法,然后将需要以多线程方式执行的代码书写在run方法内部或在run方法内部进行调用。

在需要启动线程的地方，首先创建MyRunnable类型的对象，然后再以该对象为基础创建Thread类的对象，最后调用Thread对象的start方法即可启动线程。代码如下：

//创建对象

MyRunnable mr = new MyRunnable();

Thread t = new Thread(mr);

//启动

         t.start();

在这种实现方式中，大部分和前面介绍的方式类似，启动的代码稍微麻烦一些。这种方式也是实现线程的一种主要方式。

12.2.3使用Timer和TimerTask组合

         最后一种实现多线程的方式，就是使用java.util包中的Timer和TimerTask类实现多线程，使用这种方式也可以比较方便的实现线程。

         在这种实现方式中，Timer类实现的是类似闹钟的功能，也就是定时或者每隔一定时间触发一次线程。其实，Timer类本身实现的就是一个线程，只是这个线程是用来实现调用其它线程的。而TimerTask类是一个抽象类，该类实现了Runnable接口，所以按照前面的介绍，该类具备多线程的能力。

         在这种实现方式中，通过继承TimerTask使该类获得多线程的能力，将需要多线程执行的代码书写在run方法内部，然后通过Timer类启动线程的执行。

         在实际使用时，一个Timer可以启动任意多个TimerTask实现的线程，但是多个线程之间会存在阻塞。所以如果多个线程之间如果需要完全独立运行的话，最好还是一个Timer启动一个TimerTask实现。

         使用该种实现方式实现的多线程示例代码如下：

                   import java.util.*;

/**

 * 测试类

 */

public class Test3 {

         public static void main(String[] args) {

                   //创建Timer

                   Timer t = new Timer();

                   //创建TimerTask

                   MyTimerTask mtt1 = new MyTimerTask("线程1：");

                   //启动线程

                   t.schedule(mtt1, 0);

         }

}

                  import java.util.TimerTask;

/**

 * 以继承TimerTask类的方式实现多线程

 */

public class MyTimerTask extends TimerTask {

         String s;

         public MyTimerTask(String s){

                   this.s = s;

         }

         

         public void run() {

                   try{

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

                                     Thread.sleep(1000);

                                     System.out.println(s + i);

                            }

                   }catch(Exception e){}

         }

}

         在该示例中，MyTimerTask类实现了多线程，以多线程方式执行的代码书写在该类的run方法内部，该类的功能和前面的多线程的代码实现类似。

         而在该代码中，启动线程时需要首先创建一个Timer类的对象，以及一个MyTimerTask线程类的兑现，然后使用Timer对象的schedule方法实现，启动线程的代码为：

//创建Timer

Timer t = new Timer();

//创建TimerTask

MyTimerTask mtt1 = new MyTimerTask("线程1：");

//启动线程

                   t.schedule(mtt1, 0);

         其中schedule方法中的第一个参数mtt1代表需要启动的线程对象，而第二个参数0则代表延迟0毫秒启动该线程，也就是立刻启动。

         由于schedule方法比较重要，下面详细介绍一下Timer类中的四个schedule方法：

1、  public void schedule(TimerTask task,Date time)

该方法的作用是在到达time指定的时间或已经超过该时间时执行线程task。例如假设t是Timer对象，task是需要启动的TimerTask线程对象，后续示例也采用这种约定实现，则启动线程的示例代码如下：

         Date d = new Date(2009-1900,10-1,1,10,0,0);

           t. schedule(task,d);

则该示例代码的作用是在时间达到d指定的时间或超过该时间(例如2009年10月2号)时，启动线程task。

2、  public void schedule(TimerTask task, Date firstTime, long period)

该方法的作用是在时间到达firstTime开始，每隔period毫秒就启动一次task指定的线程。示例代码如下：

           Date d = new Date(2009-1900,10-1,1,10,0,0);

           t. schedule(task,d,20000);

该示例代码的作用是当时间达到或超过d指定的时间以后，每隔20000毫秒就启动一次线程task，这种方式会重复触发线程。

3、  public void schedule(TimerTask task,long delay)

该方法和第一个方法类似，作用是在执行schedule方法以后delay毫秒以后启动线程task。示例代码如下：

           t. schedule(task,1000);

该示例代码的作用是在执行该行启动代码1000毫秒以后启动一次线程task。

4、  public void schedule(TimerTask task,long delay,long period)

该方法和第二个方法类似，作用是在执行schedule方法以后delay毫秒以后启动线程task，然后每隔period毫秒重复启动线程task。

         例外需要说明的是Timer类中启动线程还包含两个scheduleAtFixedRate方法，这两个方法的参数和上面的第二个和第四个一致，其作用是实现重复启动线程时的精确延时。对于schedule方法来说，如果重复的时间间隔是1000毫秒，则实际的延迟时间是1000毫秒加上系统执行时消耗的时间，例如为5毫秒，则实际每轮的时间间隔为1005毫秒。而对于scheduleAtFixedRate方法来说，如果设置的重复时间间隔为1000毫秒，系统执行时消耗的时间为5毫秒，则延迟时间就会变成995毫秒，从而保证每轮间隔为1000毫秒。

         介绍完了schedule方法以后，让我们再来看一下前面的示例代码，如果在测试类中启动两个MyTimerTask线程，一种实现的代码为：

                   import java.util.Timer;

/**

 * 测试类

 */

public class Test4 {

         public static void main(String[] args) {

                   //创建Timer

                   Timer t = new Timer();

                   //创建TimerTask

                   MyTimerTask mtt1 = new MyTimerTask("线程1：");

                   MyTimerTask mtt2 = new MyTimerTask("线程2：");

                   //启动线程

                   System.out.println("开始启动");

                   t.schedule(mtt1, 1000);

                   System.out.println("启动线程1");

                   t.schedule(mtt2, 1000);

                   System.out.println("启动线程2");

         }

}

         在该示例代码中，使用一个Timer对象t依次启动了两个MyTimerTask类型的对象mtt1和mtt2。而程序的执行结果是：

                  开始启动

启动线程1

启动线程2

线程1：0

线程1：1

线程1：2

线程1：3

线程1：4

线程1：5

线程1：6

线程1：7

线程1：8

线程1：9

线程2：0

线程2：1

线程2：2

线程2：3

线程2：4

线程2：5

线程2：6

线程2：7

线程2：8

线程2：9

         从程序的执行结果可以看出，在Test4类中mtt1和mtt2都被启动，按照前面的schedule方法介绍，这两个线程均会在线程启动以后1000毫秒后获得执行。但是从实际执行效果却可以看出这两个线程不是同时执行的，而是依次执行，这主要是因为一个Timer启动的多个TimerTask之间会存在影响，当上一个线程未执行完成时，会阻塞后续线程的执行，所以当线程1执行完成以后线程2才获得了执行。

         如果需要线程1和线程2获得同时执行，则只需要分别使用两个Timer启动TimerTask线程即可，启动的示例代码如下：

                   import java.util.Timer;

/**

 * 测试类

 */

public class Test5 {

         public static void main(String[] args) {

                   //创建Timer

                   Timer t1 = new Timer();

                   Timer t2 = new Timer();

                   //创建TimerTask

                   MyTimerTask mtt1 = new MyTimerTask("线程1：");

                   MyTimerTask mtt2 = new MyTimerTask("线程2：");

                   //启动线程

                   System.out.println("开始启动");

                   t1.schedule(mtt1, 1000);

                   System.out.println("启动线程1");

                   t2.schedule(mtt2, 1000);

                   System.out.println("启动线程2");

         }

}

         在该示例中，分别使用两个Timer对象t1和t2，启动两个TimerTask线程对象mtt1和mtt2，两者之间不互相干扰，所以达到了同时执行的目的。

         在使用上面的示例进行运行时，由于Timer自身的线程没有结束，所以在程序输出完成以后程序还没有结束，需要手动结束程序的执行。例如在Eclipse中可以点击控制台上面的红色“Teminate”按钮结束程序。

12.2.4 小结

         关于线程的三种实现方式，就简单的介绍这么多。其实无论那种实现方式，都可以实现多线程，在语法允许的前提下，可以使用任何一种方式实现。比较而言，实现Runnable接口方式要通用一些。

         只是从语法角度介绍线程的实现方式，还是无法体会到线程实现的奥妙，下面将通过几个简单的示例来体会线程功能的强大，并体会并发编程的神奇，从而能够进入并发编程的领域发挥技术的优势。

本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/Mailbomb/archive/2009/05/20/4204595.aspx

12.3 多线程使用示例

         多线程技术对于初学者来说，是编程思维的一种跳跃，在实际学习时，一定要熟悉线程的基础知识，掌握线程的实现方式，然后就是开始大量的进行实践，从实践中领悟线程编程的奥妙以及实现的原理。

         下面通过几个常见的例子演示多线程的基本使用。

12.3.1 定时炸弹

         定时炸弹是在电影中常见的一种装置，在该部分就使用多线程技术模拟该功能。实现的功能为：在程序启动以后进行倒计时，当60秒以后程序结束，在程序运行时可以在控制台输入quit控制线程(炸弹)的暂停。

         在该示例程序中，开启了一个系统线程(main方法所在的线程)，该线程的作用是启动模拟定时炸弹的线程，并且在控制台接受用户的输入，并判断输入的内容是否为quit，如果是则结束模拟定时炸弹的线程，程序结束。

         首先来看一下使用继承Thread类的方式实现多线程时的代码示例，代码如下：

                   package example1;

import java.io.*;

/**

 * 模拟定时炸弹线程

 */

public class TestTimeBomb1 {

         public static void main(String[] args) {

                   //创建线程和启动线程

                   TimeBombThread tbt = new TimeBombThread();

                   //接受控制台输入

                   BufferedReader br = new BufferedReader(

                                               new InputStreamReader(System.in));

                   String line;

                   try{

                            while(true){

                                     System.out.println("输入quit结束线程：");

                                     //获得控制台输入

                                     line = br.readLine();

                                     //判断是否是quit

                                     if(line.equals("quit")){

                                               tbt.stopThread(); //结束线程

                                               break; //结束循环

                                     }

                            }

                   }catch(Exception e){}

         }

}

                   package example1;

/**

 * 使用继承Thread类的方式模拟定时炸弹逻辑

 */

public class TimeBombThread extends Thread {

         int n;

         boolean isRun;

         public TimeBombThread(){

                   n = 60;

                   isRun = true;

                   start();//启动线程

         }

         

         public void run(){

                   try{

                            while(isRun){

                                     Thread.sleep(1000); //延迟1秒

                                     System.out.println("剩余时间：" + n);

                                     if(n <= 0){

                                               isRun = false; //结束线程

                                               System.out.println("炸弹爆炸！");

                                               break;

                                     }

                                     n--; //时间减少1

                            }

                   }catch(Exception e){}

         }

         

         public void stopThread(){

                   isRun = false;

         }

}

         在该示例代码中，TestTimeBomb1类中包含的是系统线程，在系统线程中启动模拟定时炸弹的TimeBombThread线程，然后在TestTimeBomb1中接收用户的控制台输入，如果输入的内容是quit则结束线程，程序结束，否则忽略用户的输入，继续等待用户输入。按照前面介绍的IO知识，在接收控制台输入时readLine是阻塞方法，也就是该方法在未获得用户输入时会阻塞系统线程的执行，使系统线程进入到等待状态，等待用户输入。而TimeBombThread实现的逻辑是每隔1秒钟减少一次数值，并输出剩余时间，当剩余时间为零时，结束TimeBombThread线程。这样两个线程就同时工作了，系统线程等待用户输入的同时，模拟定时炸弹的线程继续执行，这样程序中就包含了两个同时执行的流程。

         在这里需要特别说明的是，如何控制线程的结束？在本程序中，使用的是让线程自然死亡的方式，在实际控制线程时，当线程的run方法执行结束则线程自然死亡，所以在本程序中通过控制isRun变量使得线程可以自然结束，从而释放线程占用的资源。

         同样的功能也可以使用Timer和TimerTask组合的方式实现，实现的代码如下所示：

                   package example1;

import java.io.*;

/**

 * 模拟定时炸弹线程

 */

public class TestTimeBomb2 {

         public static void main(String[] args) {

                   //创建线程和启动线程

                   TimeBombTimerTask tbtt = new TimeBombTimerTask();

                   //接受控制台输入

                   BufferedReader br = new BufferedReader(

                                               new InputStreamReader(System.in));

                   String line;

                   try{

                            while(true){

                                     System.out.println("输入quit结束线程：");

                                     //获得控制台输入

                                     line = br.readLine();

                                     //判断是否是quit

                                     if(line.equals("quit")){

                                               tbtt.stopThread(); //结束线程

                                               break; //结束循环

                                     }

                            }

                   }catch(Exception e){}

         }

}

package example1;

import java.util.*;

/**

 * 使用Timer和TimerTask组合模拟定时炸弹

 */

public class TimeBombTimerTask extends TimerTask {

         int n;

         Timer t;

         boolean isRun;

         public TimeBombTimerTask(){

                   n = 60;

                   isRun = true;

                   t = new Timer();

                   t.schedule(this, 0); //启动线程

         }

         

         public void run() {

                   try{

                            while(isRun){

                                     Thread.sleep(1000); //延迟1秒

                                     System.out.println("剩余时间：" + n);

                                     if(n <= 0){

                                               stopThread(); //结束线程

                                               System.out.println("炸弹爆炸！");

                                               break;        //结束循环

                                     }

                                     n--; //时间减少1

                            }

                   }catch(Exception e){}

         }

         

         public void stopThread(){

                   isRun = false;

                   t.cancel();

         }

}

         在该示例代码中，实现的原理和前面的类似，TestTimeBomb2类实现系统线程，功能是启动模拟定时炸弹的线程，并接收用户的控制台输入。而TimeBombTimerTask类实现模拟定时炸弹的线程，在该类内部包含启动线程的Timer对象，当构造该类的对象时，不仅完成该类的初始化，而且启动线程。

         在控制Timer启动的线程结束时，首先结束当前的TimerTask线程，然后再调用Timer对象的cancel方法结束Timer对象的线程，这样才可以真正停止这种方式启动的线程。

         至于使用实现Runnable方式实现线程的方式，和继承Thread类的实现几乎一致，读者可以根据第一种方式的实现独自进行实现，这里就不再重复实现了

本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/Mailbomb/archive/2009/05/22/4207692.aspx

12.3.2 模拟网络数据发送

         在实际的网络程序开发中，由于网络通讯一般都需要消耗时间，所以网络通讯的内容一般都启动专门的线程进行处理。

         这样，在一个最简单的网络程序程序中，至少就包含了两个线程：处理界面绘制和接收用户输入的系统线程，以及至少一个网络通讯线程。

         下面以一个简单的模拟程序，实现模拟网络数据的发送功能，关于更详细的网络编程中线程的使用，可以参看后续的网络编程章节。

         在该示例代码中，用户在控制台输入需要发送的内容，程序接收到用户的输入以后，启动一个单独的线程进行网络通讯，然后用户可以继续在控制台进行输入。示例代码如下所示：

                   package example2;

import java.io.*;

/**

 * 模拟网络数据发送的测试类

 */

public class TestNet {

         public static void main(String[] args) {

                   BufferedReader br = null;

                   String input;

                   try{

                            //初始化输入流

                            br = new BufferedReader(

                                               new InputStreamReader(System.in));

                            //循环接收输入

                            while(true){

                                     System.out.println("请输入内容(quit代表退出程序)：");

                                     //读取控制台输入

                                     input = br.readLine();

                                     //判断是否是结束

                                     if(input.equals("quit")){

                                               break; //结束程序

                                     }

                                     //模拟发送

                                     NetDemoThread ndt = new NetDemoThread(input);

                            }

                   }catch(Exception e){

                   }finally{

                            try {

                                     br.close();

                            } catch (Exception e) {}

                   }

         }

}

package example2;

/**

 * 通过继承Thread类的方式模拟网络通讯线程

 */

public class NetDemoThread extends Thread {

         String data;

         public NetDemoThread(String data){

                   this.data = data;

                   start();

         }

         

         public void run(){

                   try{

                            System.out.println("开始发送");

                            Thread.sleep(10000);  //模拟网络发送的延迟

                            System.out.println("发送完成，发送的内容是：" + data);

                   }catch(Exception e){}

         }

}

         在该示例中，TestNet类实现接收控制台输入，并在接收到用户输入以后，启动网络通讯线程发送数据，当用户在控制台输入quit时，结束程序。NetDemoThread类实现模拟网络通讯线程，在需要发送网络数据时，创建一个NetDemoThread类型的线程对象，并将需要发送的内容作为参数传入到该对象的内容，在run方法中，输出线程的状态，并使用一个延迟10秒，比实际的延迟要夸大很多，的代码模拟发送时的线程延迟。由于这里的延迟比较大，所以如果用户输入的数据速度比较快的话，会存在多个网络通讯的线程同时运行。

         下面是程序的运行结果：

                   请输入内容(quit代表退出程序)：

abc

请输入内容(quit代表退出程序)：

开始发送

123

请输入内容(quit代表退出程序)：

开始发送

tbc

请输入内容(quit代表退出程序)：

开始发送

faga

请输入内容(quit代表退出程序)：

开始发送

发送完成，发送的内容是：abc

hfsd

请输入内容(quit代表退出程序)：

开始发送

发送完成，发送的内容是：123

发送完成，发送的内容是：tbc

发送完成，发送的内容是：faga

发送完成，发送的内容是：hfsd

quit

         在该次运行中，用户依次输入了：123、tbc、faga和hfsd，当用户输入完成以后，模拟网络通讯的线程就被启动，这个可以从输出“开始发送”语句看出，当内容发送完成以后线程自然结束。最后输入quit指令结束程序。

         当然，该程序会在用户输入的内容不同时出现很多不同的结果，这些结果能够使你体会到两点：

1、  多个网络通讯的线程在同时工作，互不干扰。

2、  当输入quit以后，如果还有网络通讯的线程没有结束，则程序会等待到网络通讯的线程结束以后才真正结束。

当然，这两个简单的例子只能够使你熟悉基本的多线程编程的使用，还没有进入到多线程编程的核心。

其实，当多线程一起运行时，除了带来一系列的优势以外，还会带来一系列的问题。例如现实社会中，一个儿子继承遗产时就很简单，但是当有多个儿子呢？所以，下面来深入线程的概念，理解多线程编程存在的问题以及解决办法。

本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/Mailbomb/archive/2009/05/22/4209318.aspx

12.4 多线程问题及处理

         多线程编程为程序开发带来了很多的方便，但是也带来了一些问题，这些问题是在程序开发过程中必须进行处理的问题。

         这些问题的核心是，如果多个线程同时访问一个资源，例如变量、文件等，时如何保证访问安全的问题。在多线程编程中，这种会被多个线程同时访问的资源叫做临界资源。

         下面通过一个简单的示例，演示多个线程访问临界资源时产生的问题。在该示例中，启动了两个线程类DataThread的对象，该线程每隔200毫秒输出一次变量n的值，并将n的值减少1。变量n的值存储在模拟临界资源的Data类中，该示例的核心是两个线程类都使用同一个Data类的对象，这样Data类的这个对象就是一个临界资源了。示例代码如下：

                   package syn1;

/**

 * 模拟临界资源的类

 */

public class Data {

         public int n;

         public Data(){

                   n = 60;

         }

}

package syn1;

/**

 * 测试多线程访问时的问题

 */

public class TestMulThread1 {

         public static void main(String[] args) {

                   Data data = new Data();

                   DataThread d1 = new DataThread(data,"线程1");

                   DataThread d2 = new DataThread(data,"线程2");

         }

}

package syn1;

/**

 * 访问数据的线程

 */

public class DataThread extends Thread {

         Data data;

         String name;

         public DataThread(Data data,String name){

                   this.data = data;

                   this.name = name;

                   start();

         }

          

         public void run(){

                   try{

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

                                     System.out.println(name + ":" + data.n);

                                     data.n--;

                                     Thread.sleep(200);

                            }

                   }catch(Exception e){}

         }

}

         在运行时，因为不同情况下该程序的运行结果会出现不同，该程序的一种执行结果为：

                   线程1:60

线程2:60

线程2:58

线程1:58

线程2:56

线程1:56

线程2:54

线程1:54

线程2:52

线程1:52

线程2:50

线程1:50

线程2:48

线程1:48

线程2:47

线程1:46

线程2:44

线程1:44

线程2:42

线程1:42

         从执行结果来看，第一次都输出60是可以理解的，因为线程在执行时首先输出变量的值，这个时候变量n的值还是初始值60，而后续的输出就比较麻烦了，在开始的时候两个变量保持一致的输出，而不是依次输出n的每个值的内容，而到将要结束时，线程2输出47这个中间数值。

         出现这种结果的原因很简单：线程1改变了变量n的值以后，还没有来得及输出，这个变量n的值就被线程2给改变了，所以在输出时看的输出都是跳跃的，偶尔出现了连续。

         出现这个问题也比较容易接受，因为最基本的多线程程序，系统只保证线程同时执行，至于哪个先执行，哪个后执行，或者执行中会出现一个线程执行到一半，就把CPU的执行权交给了另外一个线程，这样线程的执行顺序是随机的，不受控制的。所以会出现上面的结果。

         这种结果在很多实际应用中是不能被接受的，例如银行的应用，两个人同时取一个账户的存款，一个使用存折、一个使用卡，这样访问账户的金额就会出现问题。或者是售票系统中，如果也这样就出现有人买到相同座位的票，而有些座位的票却未售出。

         在多线程编程中，这个是一个典型的临界资源问题，解决这个问题最基本，最简单的思路就是使用同步关键字synchronized。

         synchronized关键字是一个修饰符，可以修饰方法或代码块，其的作用就是，对于同一个对象(不是一个类的不同对象)，当多个线程都同时调用该方法或代码块时，必须依次执行，也就是说，如果两个或两个以上的线程同时执行该段代码时，如果一个线程已经开始执行该段代码，则另外一个线程必须等待这个线程执行完这段代码才能开始执行。就和在银行的柜台办理业务一样，营业员就是这个对象，每个顾客就好比线程，当一个顾客开始办理时，其它顾客都必须等待，及时这个正在办理的顾客在办理过程中接了一个电话 (类比于这个线程释放了占用CPU的时间，而处于阻塞状态)，其它线程也只能等待。

         使用synchronized关键字修改以后的上面的代码为：

                   package syn2;

/**

 * 模拟临界资源的类

 */

public class Data2 {

         public int n;

         public Data2(){

                   n = 60;

         }

         

         public synchronized void action(String name){

                   System.out.println(name + ":" + n);

                   n--;

         }

}

package syn2;

/**

 * 测试多线程访问时的问题

 */

public class TestMulThread2 {

         public static void main(String[] args) {

                   Data2 data = new Data2();

                   Data2Thread d1 = new Data2Thread(data,"线程1");

                   Data2Thread d2 = new Data2Thread(data,"线程2");

         }

}

package syn2;

/**

 * 访问数据的线程

 */

public class Data2Thread extends Thread {

         Data2 data;

         String name;

         public Data2Thread(Data2 data,String name){

                   this.data = data;

                   this.name = name;

                   start();

         }

          

         public void run(){

                   try{

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

                                     data.action(name);

                                     Thread.sleep(200);

                            }

                   }catch(Exception e){}

         }

}

         该示例代码的执行结果会出现不同，一种执行结果为：

                   线程1:60

线程2:59

线程2:58

线程1:57

线程2:56

线程1:55

线程2:54

线程1:53

线程2:52

线程1:51

线程2:50

线程1:49

线程1:48

线程2:47

线程2:46

线程1:45

线程2:44

线程1:43

线程2:42

线程1:41

         在该示例中，将打印变量n的代码和变量n变化的代码组成一个专门的方法action，并且使用修饰符synchronized修改该方法，也就是说对于一个Data2的对象，无论多少个线程同时调用action方法时，只有一个线程完全执行完该方法以后，别的线程才能够执行该方法。这就相当于一个线程执行到该对象的synchronized方法时，就为这个对象加上了一把锁，锁住了这个对象，别的线程在调用该方法时，发现了这把锁以后就继续等待下去了。

本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/Mailbomb/archive/2009/05/23/4210889.aspx

如果这个例子还不能帮助你理解如何解决多线程的问题，那么下面再来看一个更加实际的例子——卫生间问题。

         例如火车上车厢的卫生间，为了简单，这里只模拟一个卫生间，这个卫生间会被多个人同时使用，在实际使用时，当一个人进入卫生间时则会把卫生间锁上，等出来时打开门，下一个人进去把门锁上，如果有一个人在卫生间内部则别人的人发现门是锁的则只能在外面等待。从编程的角度来看，这里的每个人都可以看作是一个线程对象，而这个卫生间对象由于被多个线程访问，则就是临界资源，在一个线程实际使用时，使用synchronized关键将临界资源锁定，当结束时，释放锁定。实现的代码如下：

                  package syn3;

/**

 * 测试类

 */

public class TestHuman {

         public static void main(String[] args) {

                   Toilet t = new Toilet(); //卫生间对象

                   Human h1 = new Human("1",t);

                   Human h2 = new Human("2",t);

                   Human h3 = new Human("3",t);

         }

}

package syn3;

/**

 * 人线程类，演示互斥

 */

public class Human extends Thread {

         Toilet t;

         String name;

         public Human(String name,Toilet t){

                   this.name = name;

                   this.t = t;

                   start(); //启动线程

         }

         

         public void run(){

                   //进入卫生间

                   t.enter(name);

         }

}

package syn3;

/**

 * 卫生间，互斥的演示

 */

public class Toilet {

         public synchronized void enter(String name){

                   System.out.println(name + "已进入！");

                   try{

                            Thread.sleep(2000);

                   }catch(Exception e){}

                   System.out.println(name + "离开！");

         }

}

         该示例的执行结果为，不同次数下执行结果会有所不同：

                   1已进入！

1离开！

3已进入！

3离开！

2已进入！

2离开！

         在该示例代码中，Toilet类表示卫生间类，Human类模拟人，是该示例中的线程类，TestHuman类是测试类，用于启动线程。在TestHuman中，首先创建一个Toilet类型的对象t，并将该对象传递到后续创建的线程对象中，这样后续的线程对象就使用同一个Toilet对象，该对象就成为了临界资源。下面创建了三个Human类型的线程对象，每个线程具有自己的名称name参数，模拟3个线程，在每个线程对象中，只是调用对象t中的enter方法，模拟进入卫生间的动作，在enter方法中，在进入时输出调用该方法的线程进入，然后延迟2秒，输出该线程离开，然后后续的一个线程进入，直到三个线程都完成enter方法则程序结束。

         在该示例中，同一个Toilet类的对象t的enter方法由于具有synchronized修饰符修饰，则在多个线程同时调用该方法时，如果一个线程进入到enter方法内部，则为对象t上锁，直到enter方法结束以后释放对该对象的锁定，通过这种方式实现无论多少个Human类型的线程，对于同一个对象t，任何时候只能有一个线程执行enter方法，这就是解决多线程问题的第一种思路——互斥的解决原理。

12.4.2 同步

         使用互斥解决多线程问题是一种简单有效的解决办法，但是由于该方法比较简单，所以只能解决一些基本的问题，对于复杂的问题就无法解决了。

         解决多线程问题的另外一种思路是同步。同步是另外一种解决问题的思路，结合前面卫生间的示例，互斥方式解决多线程的原理是，当一个人进入到卫生间内部时，别的人只能在外部时刻等待，这样就相当于别的人虽然没有事情做，但是还是要占用别的人的时间，浪费系统的执行资源。而同步解决问题的原理是，如果一个人进入到卫生间内部时，则别的人可以去睡觉，不占用系统资源，而当这个人从卫生间出来以后，把这个睡觉的人叫醒，则它就可以使用临界资源了。所以使用同步的思路解决多线程问题更加有效，更加节约系统的资源。

 

         在常见的多线程问题解决中，同步问题的典型示例是“生产者-消费者”模型，也就是生产者线程只负责生产，消费者线程只负责消费，在消费者发现无内容可消费时则睡觉。下面举一个比较实际的例子——生活费问题。

         生活费问题是这样的：学生每月都需要生活费，家长一次预存一段时间的生活费，家长和学生使用统一的一个帐号，在学生每次取帐号中一部分钱，直到帐号中没钱时通知家长存钱，而家长看到帐户还有钱则不存钱，直到帐户没钱时才存钱。在这个例子中，这个帐号被学生和家长两个线程同时访问，则帐号就是临界资源，两个线程是同时执行的，当每个线程发现不符合要求时则等待，并释放分配给自己的CPU执行时间，也就是不占用系统资源。实现该示例的代码为：

                   package syn4;

/**

 * 测试类

 */

public class TestAccount {

         public static void main(String[] args) {

                   Accout a = new Accout();

                   StudentThread s = new StudentThread(a);

                   GenearchThread g = new GenearchThread(a);

         }

}

package syn4;

/**

 * 模拟学生线程

 */

public class StudentThread extends Thread {

         Accout a;

         public StudentThread(Accout a){

                   this.a = a;

                   start();

         }

         public void run(){

                   try{

                            while(true){

                                     Thread.sleep(2000);

                                     a.getMoney();  //取钱

                            }

                   }catch(Exception e){}

         }

}

package syn4;

/**

 * 家长线程

 */

public class GenearchThread extends Thread {

         Accout a;

         public GenearchThread(Accout a){

                   this.a = a;

                   start();

         }

         public void run(){

                   try{

                            while(true){

                                     Thread.sleep(12000);

                                     a.saveMoney();  //存钱

                            }

                   }catch(Exception e){}

         }

}

package syn4;

/**

 * 银行账户

 */

public class Accout {

         int money = 0;

         /**

          * 取钱

          * 如果账户没钱则等待，否则取出所有钱提醒存钱

          */

         public synchronized void getMoney(){

                   System.out.println("准备取钱！");

                   try{

                            if(money == 0){

                                     wait();  //等待

                            }

                            //取所有钱

                            System.out.println("剩余:" + money);

                            money -= 50;

                            //提醒存钱

                            notify();

                   }catch(Exception e){}                 

         }

         

         /**

          * 存钱

          * 如果有钱则等待，否则存入200提醒取钱

          */

         public synchronized void saveMoney(){

                   System.out.println("准备存钱！");

                   try{

                            if(money != 0){

                                     wait();  //等待

                            }

                            //取所有钱

                            money = 200;

                            System.out.println("存入:" + money);

                            //提醒存钱

                            notify();

                   }catch(Exception e){}                 

         }

}

         该程序的一部分执行结果为：

                   准备取钱！

准备存钱！

存入:200

剩余:200

准备取钱！

剩余:150

准备取钱！

剩余:100

准备取钱！

剩余:50

准备取钱！

准备存钱！

存入:200

剩余:200

准备取钱！

剩余:150

准备取钱！

剩余:100

准备取钱！

剩余:50

准备取钱！

         在该示例代码中，TestAccount类是测试类，主要实现创建帐户Account类的对象，以及启动学生线程StudentThread和启动家长线程GenearchThread。在StudentThread线程中，执行的功能是每隔2秒中取一次钱，每次取50元。在GenearchThread线程中，执行的功能是每隔12秒存一次钱，每次存200。这样存款和取款之间不仅时间间隔存在差异，而且数量上也会出现交叉。而该示例中，最核心的代码是Account类的实现。

         在Account类中，实现了同步控制功能，在该类中包含一个关键的属性money，该属性的作用是存储帐户金额。在介绍该类的实现前，首先介绍一下两个同步方法——wait和notify方法的使用，这两个方法都是Object类中的方法，也就是说每个类都包含这两个方法，换句话说，就是Java天生就支持同步处理。这两个方法都只能在synchronized修饰的方法或语句块内部采用被调用。其中wait方法的作用是使调用该方法的线程休眠，也就是使该线程退出CPU的等待队列，处于冬眠状态，不执行动作，也不占用CPU排队的时间，notify方法的作用是唤醒一个任意该对象的线程，该线程当前处于休眠状态，至于唤醒的具体是那个则不保证。在Account类中，被StudentThread调用的getMoney方法的功能是判断当前金额是否是0，如果是则使StudentThread线程处于休眠状态，如果金额不是0，则取出50元，同时唤醒使用该帐户对象的其它一个线程，而被GenearchThread线程调用的saveMoney方法的功能是判断当前是否不为0，如果是则使GenearchThread线程处于休眠状态，如果金额是0，则存入200元，同时唤醒使用该帐户对象的其它一个线程。

         如果还是不清楚，那就结合前面的程序执行结果来解释一下程序执行的过程：在程序开始执行时，学生线程和家长线程都启动起来，所以输出“准备取钱”和“准备存钱”，然后学生线程按照该线程run方法的逻辑执行，先延迟2秒，然后调用帐户对象a中的getMoney方法，但是由于初始情况下帐户对象a中的money数值为0，所以学生线程就休眠了。在学生线程执行的同时，家长线程也按照该线程的run方法的逻辑执行，先延迟12秒，然后调用帐户对象a中的saveMoney方法，由于帐户a对象中的money为零，条件不成立，所以执行存入200元，同时唤醒线程，由于使用对象a的线程现在只有学生线程，所以学生线程被唤醒，开始执行逻辑，取出50元，然后唤醒线程，由于当前没有线程处于休眠状态，所以没有线程被唤醒。同时家长线程继续执行，先延迟12秒，这个时候学生线程执行了4次，耗时4X2秒=8秒，就取光了帐户中的钱，接着由于帐户为0则学生线程又休眠了，一直到家长线程延迟12秒结束以后，判断帐户为0，又存入了200元，程序继续执行下去。

         在解决多线程问题是，互斥和同步都是解决问题的思路，如果需要形象的比较这两种方式的区别的话，就看一下下面的示例。一个比较忙的老总，桌子上有2部电话，在一部处于通话状态时，另一部响了，老总拿其这部电话说我在接电话，你等一下，而没有挂电话，这种处理的方式就是互斥。而如果老总拿其另一部电话说，我在接电话，等会我打给你，然后挂了电话，这种处理的方式就是同步。两者相比，互斥明显占用系统资源(浪费电话费，浪费别人的时间)，而同步则是一种更加好的解决问题的思路。

本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/Mailbomb/archive/2009/05/27/4220846.aspx

12.4.3 死锁

         多线程编程在实际的网络程序开发中，在客户端程序实现中使用的比较简单，但是在服务器端程序实现中却不仅是大量使用，而且会出现比客户端更多的问题。

         另外一个容易在服务器端出现的多线程问题是——死锁。死锁指两个或两个以上的线程为了使用某个临界资源而无限制的等待下去。还是以前面卫生间的例子来说明死锁，例如两个人都同时到达卫生间，而且两个人都比较礼貌，第一个人和第二个人说：你先吧，第二个人和第一个人说：你先吧。这两个人就这样一直在互相礼让，谁也不进入，这种现象就是死锁。这里的两个人就好比是线程，而卫生间在这里就是临界资源，而由于这两个线程在一直谦让，谁也不使用临界资源。

         死锁不仅使程序无法达到预期实现的功能，而且浪费系统的资源，所以在服务器端程序中危害比较大，在实际的服务器端程序开发中，需要注意避免死锁。

         而死锁的检测比较麻烦，而且不一定每次都出现，这就需要在测试服务器端程序时，有足够的耐心，仔细观察程序执行时的性能检测，如果发现执行的性能显著降低，则很可能是发生了死锁，然后再具体的查找死锁出现的原因，并解决死锁的问题。

         死锁出现的最本质原因还是逻辑处理不够严谨，在考虑时不是很周全，所以一般需要修改程序逻辑才能够很好的解决死锁。

12.4.4 线程优先级

         在日常生活中，例如火车售票窗口等经常可以看到“XXX优先”，那么多线程编程中每个线程是否也可以设置优先级呢？

         在多线程编程中，支持为每个线程设置优先级。优先级高的线程在排队执行时会获得更多的CPU执行时间，得到更快的响应。在实际程序中，可以根据逻辑的需要，将需要得到及时处理的线程设置成较高的优先级，而把对时间要求不高的线程设置成比较低的优先级。

         在Thread类中，总计规定了三个优先级，分别为：

l  MAX_PRIORITY——最高优先级

l  NORM_PRIORITY——普通优先级，也是默认优先级

l  MIN_PRIORITY——最低优先级

在前面创建的线程对象中，由于没有设置线程的优先级，则线程默认的优先级是NORM_PRIORITY，在实际使用时，也可以根据需要使用Thread类中的setPriority方法设置线程的优先级，该方法的声明为：

         public final void setPriority(int newPriority)

假设t是一个初始化过的线程对象，需要设置t的优先级为最高，则实现的代码为：

         t. setPriority(Thread. MAX_PRIORITY);

这样，在该线程执行时将获得更多的执行机会，也就是优先执行。如果由于安全等原因，不允许设置线程的优先级，则会抛出SecurityException异常。

下面使用一个简单的输出数字的线程演示线程优先级的使用，实现的示例代码如下：

         package priority;

/**

 * 测试线程优先级

 */

public class TestPriority {

         public static void main(String[] args) {

                   PrintNumberThread p1 = new PrintNumberThread("高优先级");

                   PrintNumberThread p2 = new PrintNumberThread("普通优先级");

                   PrintNumberThread p3 = new PrintNumberThread("低优先级");

                   p1.setPriority(Thread.MAX_PRIORITY);

                   p2.setPriority(Thread.NORM_PRIORITY);

                   p3.setPriority(Thread.MIN_PRIORITY);

                   p1.start();

                   p2.start();

                   p3.start();

         }

}

package priority;

/**

 * 输出数字的线程

 */

public class PrintNumberThread extends Thread {

         String name;

         public PrintNumberThread(String name){

                   this.name = name;

         }

         public void run(){

                   try{

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

                                     System.out.println(name + ":" + i);

                            }

                   }catch(Exception e){}

         }

}

程序的一种执行结果为：

高优先级:0

高优先级:1

高优先级:2

普通优先级:0

高优先级:3

普通优先级:1

高优先级:4

普通优先级:2

高优先级:5

高优先级:6

高优先级:7

高优先级:8

高优先级:9

普通优先级:3

普通优先级:4

普通优先级:5

普通优先级:6

普通优先级:7

普通优先级:8

普通优先级:9

低优先级:0

低优先级:1

低优先级:2

低优先级:3

低优先级:4

低优先级:5

低优先级:6

低优先级:7

低优先级:8

低优先级:9

         在该示例程序，PrintNumberThread线程实现的功能是输出数字，每次数字输出之间没有设置时间延迟，在测试类TestPriority中创建三个PrintNumberThread类型的线程对象，然后分别设置线程优先级是最高、普通和最低，接着启动线程执行程序。从执行结果可以看出高优先级的线程获得了更多的执行时间，首先执行完成，而低优先级的线程由于优先级较低，所以最后一个执行结束。

         其实，对于线程优先级的管理主要由系统的线程调度实现，较高优先级的线程优先执行，所以可以通过设置线程的优先级影响线程的执行。

12.5 总结

         关于多线程的基础知识就介绍这么多，在本章中介绍了线程的概念、线程的实现方式以及使用多线程时会遇到的问题以及解决办法，而需要建立多线程的概念，也就是并发编程的概念还需要进行比较多的练习，理解多线程的概念并熟悉多线程的编程。

         而关于多线程编程的高级知识，如线程组等则可以在熟悉了线程的基本概念以后再进行更加深入的学习。

 

12.6 多线程练习

         1、分别使用多线程的3种实现方法，实现一个打印奇数的线程

         2、分别使用多线程的3种实现方法，实现一个打印1-10000之间素数(质数)的线程

         3、在练习1、练习2的基础上，加入控制台输入，当线程执行时，输入quit或exit结束线程和程序的执行。

         4、实现两个线程，一个打印奇数，一个打印偶数，每个线程的延迟时间不一样，实现奇数和偶数的交替打印。

         5、模拟火车票联网售票系统：多个线程同时出票，保证每张出票的编号连续且不重复。

本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/Mailbomb/archive/2009/05/29/4223511.aspx

第十三章 网络编程

         网络编程对于很多的初学者来说，都是很向往的一种编程技能，但是很多的初学者却因为很长一段时间无法进入网络编程的大门而放弃了对于该部分技术的学习。

         在学习网络编程以前，很多初学者可能觉得网络编程是比较复杂的系统工程，需要了解很多和网络相关的基础知识，其实这些都不是很必需的。首先来问一个问题：你会打手机吗？很多人可能说肯定会啊，不就是按按电话号码，拨打电话嘛，很简单的事情啊！其实初学者如果入门网络编程的话也可以做到这么简单！

         网络编程就是在两个或两个以上的设备(例如计算机)之间传输数据。程序员所作的事情就是把数据发送到指定的位置，或者接收到指定的数据，这个就是狭义的网络编程范畴。在发送和接收数据时，大部分的程序设计语言都设计了专门的API实现这些功能，程序员只需要调用即可。所以，基础的网络编程可以和打电话一样简单。

         下面就开始Java语言的网络编程技术学习吧。

13.1 网络概述

         网络编程技术是当前一种主流的编程技术，随着联网趋势的逐步增强以及网络应用程序的大量出现，所以在实际的开发中网络编程技术获得了大量的使用。本章中以浅显的基础知识说明和实际的案例使广大初学者能够进入网络编程技术的大门，至于以后的实际修行就要阅读进阶的书籍以及进行大量的实际练习。

13.1.1 计算机网络概述

         网络编程的实质就是两个(或多个)设备(例如计算机)之间的数据传输。

         按照计算机网络的定义，通过一定的物理设备将处于不同位置的计算机连接起来组成的网络，这个网络中包含的设备有：计算机、路由器、交换机等等。

         其实从软件编程的角度来说，对于物理设备的理解不需要很深刻，就像你打电话时不需要很熟悉通信网络的底层实现是一样的，但是当深入到网络编程的底层时，这些基础知识是必须要补的。

         路由器和交换机组成了核心的计算机网络，计算机只是这个网络上的节点以及控制等，通过光纤、网线等连接将设备连接起来，从而形成了一张巨大的计算机网络。

         网络最主要的优势在于共享：共享设备和数据，现在共享设备最常见的是打印机，一个公司一般一个打印机即可，共享数据就是将大量的数据存储在一组机器中，其它的计算机通过网络访问这些数据，例如网站、银行服务器等等。

         如果需要了解更多的网络硬件基础知识，可以阅读《计算机网络》教材，对于基础进行强化，这个在基础学习阶段不是必须的，但是如果想在网络编程领域有所造诣，则是一个必须的基本功。

         对于网络编程来说，最主要的是计算机和计算机之间的通信，这样首要的问题就是如何找到网络上的计算机呢？这就需要了解IP地址的概念。

         为了能够方便的识别网络上的每个设备，网络中的每个设备都会有一个唯一的数字标识，这个就是IP地址。在计算机网络中,现在命名IP地址的规定是IPv4协议，该协议规定每个IP地址由4个0-255之间的数字组成，例如10.0.120.34。每个接入网络的计算机都拥有唯一的IP地址，这个IP地址可能是固定的，例如网络上各种各样的服务器，也可以是动态的，例如使用ADSL拨号上网的宽带用户，无论以何种方式获得或是否是固定的，每个计算机在联网以后都拥有一个唯一的合法IP地址，就像每个手机号码一样。

         但是由于IP地址不容易记忆，所以为了方便记忆，有创造了另外一个概念——域名(Domain Name)，例如sohu.com等。一个IP地址可以对应多个域名，一个域名只能对应一个IP地址。域名的概念可以类比手机中的通讯簿，由于手机号码不方便记忆，所以添加一个姓名标识号码，在实际拨打电话时可以选择该姓名，然后拨打即可。

         在网络中传输的数据，全部是以IP地址作为地址标识，所以在实际传输数据以前需要将域名转换为IP地址，实现这种功能的服务器称之为DNS服务器，也就是通俗的说法叫做域名解析。例如当用户在浏览器输入域名时，浏览器首先请求DNS服务器，将域名转换为IP地址，然后将转换后的IP地址反馈给浏览器，然后再进行实际的数据传输。

         当DNS服务器正常工作时，使用IP地址或域名都可以很方便的找到计算机网络中的某个设备，例如服务器计算机。当DNS不正常工作时，只能通过IP地址访问该设备。所以IP地址的使用要比域名通用一些。

         IP地址和域名很好的解决了在网络中找到一个计算机的问题，但是为了让一个计算机可以同时运行多个网络程序，就引入了另外一个概念——端口(port)。

         在介绍端口的概念以前，首先来看一个例子，一般一个公司前台会有一个电话，每个员工会有一个分机，这样如果需要找到这个员工的话，需要首先拨打前台总机，然后转该分机号即可。这样减少了公司的开销，也方便了每个员工。在该示例中前台总机的电话号码就相当于IP地址，而每个员工的分机号就相当于端口。

         有了端口的概念以后，在同一个计算机中每个程序对应唯一的端口，这样一个计算机上就可以通过端口区分发送给每个端口的数据了，换句话说，也就是一个计算机上可以并发运行多个网络程序，而不会在互相之间产生干扰。

         在硬件上规定，端口的号码必须位于0-65535之间，每个端口唯一的对应一个网络程序，一个网络程序可以使用多个端口。这样一个网络程序运行在一台计算上时，不管是客户端还是服务器，都是至少占用一个端口进行网络通讯。在接收数据时，首先发送给对应的计算机，然后计算机根据端口把数据转发给对应的程序。

         有了IP地址和端口的概念以后，在进行网络通讯交换时，就可以通过IP地址查找到该台计算机，然后通过端口标识这台计算机上的一个唯一的程序。这样就可以进行网络数据的交换了。

         但是，进行网络编程时，只有IP地址和端口的概念还是不够的，下面就介绍一下基础的网络编程相关的软件基础知识。

13.1. 2 网络编程概述

         按照前面的介绍，网络编程就是两个或多个设备之间的数据交换，其实更具体的说，网络编程就是两个或多个程序之间的数据交换，和普通的单机程序相比，网络程序最大的不同就是需要交换数据的程序运行在不同的计算机上，这样就造成了数据交换的复杂。虽然通过IP地址和端口可以找到网络上运行的一个程序，但是如果需要进行网络编程，则还需要了解网络通讯的过程。

         网络通讯基于“请求-响应”模型。为了理解这个模型，先来看一个例子，经常看电视的人肯定见过审讯的场面吧，一般是这样的：

                   警察：姓名

                   嫌疑犯：XXX

                   警察：性别

                   嫌疑犯：男

                   警察：年龄

                   嫌疑犯：29

                   ……

         在这个例子中，警察问一句，嫌疑犯回答一句，如果警察不问，则嫌疑犯保持沉默。这种一问一答的形式就是网络中的“请求-响应”模型。也就是通讯的一端发送数据，另外一端反馈数据，网络通讯都基于该模型。

         在网络通讯中，第一次主动发起通讯的程序被称作客户端(Client)程序，简称客户端，而在第一次通讯中等待连接的程序被称作服务器端(Server)程序，简称服务器。一旦通讯建立，则客户端和服务器端完全一样，没有本质的区别。

         由此，网络编程中的两种程序就分别是客户端和服务器端，例如QQ程序，每个QQ用户安装的都是QQ客户端程序，而QQ服务器端程序则运行在腾讯公司的机房中，为大量的QQ用户提供服务。这种网络编程的结构被称作客户端/服务器结构，也叫做Client/Server结构，简称C/S结构。

         使用C/S结构的程序，在开发时需要分别开发客户端和服务器端，这种结构的优势在于由于客户端是专门开发的，所以根据需要实现各种效果，专业点说就是表现力丰富，而服务器端也需要专门进行开发。但是这种结构也存在着很多不足，例如通用性差，几乎不能通用等，也就是说一种程序的客户端只能和对应的服务器端通讯，而不能和其它服务器端通讯，在实际维护时，也需要维护专门的客户端和服务器端，维护的压力比较大。

         其实在运行很多程序时，没有必要使用专用的客户端，而需要使用通用的客户端，例如浏览器，使用浏览器作为客户端的结构被称作浏览器/服务器结构，也叫做Browser/Server结构，简称为B/S结构。

         使用B/S结构的程序，在开发时只需要开发服务器端即可，这种结构的优势在于开发的压力比较小，不需要维护客户端。但是这种结构也存在着很多不足，例如浏览器的限制比较大，表现力不强，无法进行系统级操作等。

         总之C/S结构和B/S结构是现在网络编程中常见的两种结构，B/S结构其实也就是一种特殊的C/S结构。

         另外简单的介绍一下P2P(Point to Point)程序，常见的如BT、电驴等。P2P程序是一种特殊的程序，应该一个P2P程序中既包含客户端程序，也包含服务器端程序，例如BT，使用客户端程序部分连接其它的种子(服务器端)，而使用服务器端向其它的BT客户端传输数据。如果这个还不是很清楚，其实P2P程序和手机是一样的，当手机拨打电话时就是使用客户端的作用，而手机处于待机状态时，可以接收到其它用户拨打的电话则起的就是服务器端的功能，只是一般的手机不能同时使用拨打电话和接听电话的功能，而P2P程序实现了该功能。

         最后再介绍一个网络编程中最重要，也是最复杂的概念——协议(Protocol)。按照前面的介绍，网络编程就是运行在不同计算机中两个程序之间的数据交换。在实际进行数据交换时，为了让接收端理解该数据，计算机比较笨，什么都不懂的，那么就需要规定该数据的格式，这个数据的格式就是协议。

         如果没有理解协议的概念，那么再举一个例子，记得有个电影叫《永不消逝的电波》，讲述的是地下党通过电台发送情报的故事，这里我们不探讨电影的剧情，而只关心电台发送的数据。在实际发报时，需要首先将需要发送的内容转换为电报编码，然后将电报编码发送出去，而接收端接收的是电报编码，如果需要理解电报的内容则需要根据密码本翻译出该电报的内容。这里的密码本就规定了一种数据格式，这种对于网络中传输的数据格式在网络编程中就被称作协议。

         那么如何来编写协议格式呢？答案是随意。只要按照这种协议格式能够生成唯一的编码，按照该编码可以唯一的解析出发送数据的内容即可。也正因为各个网络程序之间协议格式的不同，所以才导致了客户端程序都是专用的结构。

         在实际的网络程序编程中，最麻烦的内容不是数据的发送和接收，因为这个功能在几乎所有的程序语言中都提供了封装好的API进行调用，最麻烦的内容就是协议的设计以及协议的生产和解析，这个才是网络编程中最核心的内容。

         关于网络编程的基础知识，就介绍这里，深刻理解IP地址、端口和协议等概念，将会极大的有助于后续知识的学习。

13.1.3 网络通讯方式

         在现有的网络中，网络通讯的方式主要有两种：

1、  TCP(传输控制协议)方式

2、  UDP(用户数据报协议)方式

为了方便理解这两种方式，还是先来看一个例子。大家使用手机时，向别人传递信息时有两种方式：拨打电话和发送短信。使用拨打电话的方式可以保证将信息传递给别人，因为别人接听电话时本身就确认接收到了该信息。而发送短信的方式价格低廉，使用方便，但是接收人有可能接收不到。

在网络通讯中，TCP方式就类似于拨打电话，使用该种方式进行网络通讯时，需要建立专门的虚拟连接，然后进行可靠的数据传输，如果数据发送失败，则客户端会自动重发该数据。而UDP方式就类似于发送短信，使用这种方式进行网络通讯时，不需要建立专门的虚拟连接，传输也不是很可靠，如果发送失败则客户端无法获得。

这两种传输方式都是实际的网络编程中进行使用，重要的数据一般使用TCP方式进行数据传输，而大量的非核心数据则都通过UDP方式进行传递，在一些程序中甚至结合使用这两种方式进行数据的传递。

由于TCP需要建立专用的虚拟连接以及确认传输是否正确，所以使用TCP方式的速度稍微慢一些，而且传输时产生的数据量要比UDP稍微大一些。

         关于网络编程的基础知识就介绍这么多，如果需要深入了解相关知识请阅读专门的计算机网络书籍，下面开始介绍Java语言中网络编程的相关技术。

本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/Mailbomb/archive/2009/06/04/4242970.aspx

13.2 网络编程技术

         前面介绍了网络编程的相关基础知识，初步建立了网络编程的概念，但是实际学习网络编程还必须使用某种程序设计语言进行代码实现，下面就介绍一下网络编程的代码实现。

13.2.1 网络编程步骤

         按照前面的基础知识介绍，无论使用TCP方式还是UDP方式进行网络通讯，网络编程都是由客户端和服务器端组成。当然，B/S结构的编程中只需要实现服务器端即可。所以，下面介绍网络编程的步骤时，均以C/S结构为基础进行介绍。

         说明：这里的步骤实现和语言无关，也就是说，这个步骤适用于各种语言实现，不局限于Java语言。

13.2.1.1 客户端网络编程步骤

         客户端(Client)是指网络编程中首先发起连接的程序，客户端一般实现程序界面和基本逻辑实现，在进行实际的客户端编程时，无论客户端复杂还是简单，以及客户端实现的方式，客户端的编程主要由三个步骤实现：

1、  建立网络连接

客户端网络编程的第一步都是建立网络连接。在建立网络连接时需要指定连接到的服务器的IP地址和端口号，建立完成以后，会形成一条虚拟的连接，后续的操作就可以通过该连接实现数据交换了。

2、  交换数据

连接建立以后，就可以通过这个连接交换数据了。交换数据严格按照请求响应模型进行，由客户端发送一个请求数据到服务器，服务器反馈一个响应数据给客户端，如果客户端不发送请求则服务器端就不响应。

根据逻辑需要，可以多次交换数据，但是还是必须遵循请求响应模型。

3、  关闭网络连接

在数据交换完成以后，关闭网络连接，释放程序占用的端口、内存等系统资源，结束网络编程。

         最基本的步骤一般都是这三个步骤，在实际实现时，步骤2会出现重复，在进行代码组织时，由于网络编程是比较耗时的操作，所以一般开启专门的现场进行网络通讯。

13.2.1.2 服务器端网络编程步骤

         服务器端(Server)是指在网络编程中被动等待连接的程序，服务器端一般实现程序的核心逻辑以及数据存储等核心功能。服务器端的编程步骤和客户端不同，是由四个步骤实现，依次是：

1、  监听端口

服务器端属于被动等待连接，所以服务器端启动以后，不需要发起连接，而只需要监听本地计算机的某个固定端口即可。

这个端口就是服务器端开放给客户端的端口，服务器端程序运行的本地计算机的IP地址就是服务器端程序的IP地址。

2、  获得连接

当客户端连接到服务器端时，服务器端就可以获得一个连接，这个连接包含客户端的信息，例如客户端IP地址等等，服务器端和客户端也通过该连接进行数据交换。

一般在服务器端编程中，当获得连接时，需要开启专门的线程处理该连接，每个连接都由独立的线程实现。

3、  交换数据

服务器端通过获得的连接进行数据交换。服务器端的数据交换步骤是首先接收客户端发送过来的数据，然后进行逻辑处理，再把处理以后的结果数据发送给客户端。简单来说，就是先接收再发送，这个和客户端的数据交换数序不同。

其实，服务器端获得的连接和客户端连接是一样的，只是数据交换的步骤不同。

当然，服务器端的数据交换也是可以多次进行的。

在数据交换完成以后，关闭和客户端的连接。

4、  关闭连接

当服务器程序关闭时，需要关闭服务器端，通过关闭服务器端使得服务器监听的端口以及占用的内存可以释放出来，实现了连接的关闭。

         其实服务器端编程的模型和呼叫中心的实现是类似的，例如移动的客服电话10086就是典型的呼叫中心，当一个用户拨打10086时，转接给一个专门的客服人员，由该客服实现和该用户的问题解决，当另外一个用户拨打10086时，则转接给另一个客服，实现问题解决，依次类推。

         在服务器端编程时，10086这个电话号码就类似于服务器端的端口号码，每个用户就相当于一个客户端程序，每个客服人员就相当于服务器端启动的专门和客户端连接的线程，每个线程都是独立进行交互的。

         这就是服务器端编程的模型，只是TCP方式是需要建立连接的，对于服务器端的压力比较大，而UDP是不需要建立连接的，对于服务器端的压力比较小罢了。

13.2.1.3 小结

         总之，无论使用任何语言，任何方式进行基础的网络编程，都必须遵循固定的步骤进行操作，在熟悉了这些步骤以后，可以根据需要进行逻辑上的处理，但是还是必须遵循固定的步骤进行。

         其实，基础的网络编程本身不难，也不需要很多的基础网络知识，只是由于编程的基础功能都已经由API实现，而且需要按照固定的步骤进行，所以在入门时有一定的门槛，希望下面的内容能够将你快速的带入网络编程技术的大门。

13.2.2 Java网络编程技术

         Java语言是在网络环境下诞生的，所以Java语言虽然不能说是对于网络编程的支持最好的语言，但是必须说是一种对于网络编程提供良好支持的语言，使用Java语言进行网络编程将是一件比较轻松的工作。

         和网络编程有关的基本API位于java.net包中，该包中包含了基本的网络编程实现，该包是网络编程的基础。该包中既包含基础的网络编程类，也包含封装后的专门处理WEB相关的处理类。在本章中，将只介绍基础的网络编程类。

         首先来介绍一个基础的网络类——InetAddress类。该类的功能是代表一个IP地址，并且将IP地址和域名相关的操作方法包含在该类的内部。

         关于该类的使用，下面通过一个基础的代码示例演示该类的使用，代码如下：

                   package inetaddressdemo;

import java.net.*;

/**

 * 演示InetAddress类的基本使用

 */

public class InetAddressDemo {

         public static void main(String[] args) {

                   try{

                            //使用域名创建对象

                            InetAddress inet1 = InetAddress.getByName("www.163.com");

                            System.out.println(inet1);

                            //使用IP创建对象

                            InetAddress inet2 = InetAddress.getByName("127.0.0.1");

                            System.out.println(inet2);

                            //获得本机地址对象

                            InetAddress inet3 = InetAddress.getLocalHost();

                            System.out.println(inet3);

                            //获得对象中存储的域名

                            String host = inet3.getHostName();

                            System.out.println("域名：" + host);

                            //获得对象中存储的IP

                            String ip = inet3.getHostAddress();

                            System.out.println("IP:" + ip);

                   }catch(Exception e){}

         }

}

         在该示例代码中，演示了InetAddress类的基本使用，并使用了该类中的几个常用方法，该代码的执行结果是：

                   www.163.com/220.181.28.50

/127.0.0.1

chen/192.168.1.100

域名：chen

IP:192.168.1.100

         说明：由于该代码中包含一个互联网的网址，所以运行该程序时需要联网，否则将产生异常。

         在后续的使用中，经常包含需要使用InetAddress对象代表IP地址的构造方法，当然，该类的使用不是必须的，也可以使用字符串来代表IP地址进行实现。

本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/Mailbomb/archive/2009/06/05/4245745.aspx

13.2.3 TCP编程

         按照前面的介绍，网络通讯的方式有TCP和UDP两种，其中TCP方式的网络通讯是指在通讯的过程中保持连接，有点类似于打电话，只需要拨打一次号码(建立一次网络连接)，就可以多次通话(多次传输数据)。这样方式在实际的网络编程中，由于传输可靠，类似于打电话，如果甲给乙打电话，乙说没有听清楚让甲重复一遍，直到乙听清楚为止，实际的网络传输也是这样，如果发送的一方发送的数据接收方觉得有问题，则网络底层会自动要求发送方重发，直到接收方收到为止。

         在Java语言中，对于TCP方式的网络编程提供了良好的支持，在实际实现时，以java.net.Socket类代表客户端连接，以java.net.ServerSocket类代表服务器端连接。在进行网络编程时，底层网络通讯的细节已经实现了比较高的封装，所以在程序员实际编程时，只需要指定IP地址和端口号码就可以建立连接了。正是由于这种高度的封装，一方面简化了Java语言网络编程的难度，另外也使得使用Java语言进行网络编程时无法深入到网络的底层，所以使用Java语言进行网络底层系统编程很困难，具体点说，Java语言无法实现底层的网络嗅探以及获得IP包结构等信息。但是由于Java语言的网络编程比较简单，所以还是获得了广泛的使用。

         在使用TCP方式进行网络编程时，需要按照前面介绍的网络编程的步骤进行，下面分别介绍一下在Java语言中客户端和服务器端的实现步骤。

在客户端网络编程中，首先需要建立连接，在Java API中以java.net.Socket类的对象代表网络连接，所以建立客户端网络连接，也就是创建Socket类型的对象，该对象代表网络连接，示例如下：

         Socket socket1 = new Socket(“192.168.1.103”,10000);

         Socket socket2 = new Socket(“www.sohu.com”,80);

上面的代码中，socket1实现的是连接到IP地址是192.168.1.103的计算机的10000号端口，而socket2实现的是连接到域名是www.sohu.com的计算机的80号端口，至于底层网络如何实现建立连接，对于程序员来说是完全透明的。如果建立连接时，本机网络不通，或服务器端程序未开启，则会抛出异常。

连接一旦建立，则完成了客户端编程的第一步，紧接着的步骤就是按照“请求-响应”模型进行网络数据交换，在Java语言中，数据传输功能由Java IO实现，也就是说只需要从连接中获得输入流和输出流即可，然后将需要发送的数据写入连接对象的输出流中，在发送完成以后从输入流中读取数据即可。示例代码如下：

         OutputStream os = socket1.getOutputStream();  //获得输出流

         InputStream is = socket1.getInputStream();     //获得输入流

上面的代码中，分别从socket1这个连接对象获得了输出流和输入流对象，在整个网络编程中，后续的数据交换就变成了IO操作，也就是遵循“请求-响应”模型的规定，先向输出流中写入数据，这些数据会被系统发送出去，然后在从输入流中读取服务器端的反馈信息，这样就完成了一次数据交换过程，当然这个数据交换过程可以多次进行。

这里获得的只是最基本的输出流和输入流对象，还可以根据前面学习到的IO知识，使用流的嵌套将这些获得到的基本流对象转换成需要的装饰流对象，从而方便数据的操作。

最后当数据交换完成以后，关闭网络连接，释放网络连接占用的系统端口和内存等资源，完成网络操作，示例代码如下：

         socket1.close();

这就是最基本的网络编程功能介绍。下面是一个简单的网络客户端程序示例，该程序的作用是向服务器端发送一个字符串“Hello”，并将服务器端的反馈显示到控制台，数据交换只进行一次，当数据交换进行完成以后关闭网络连接，程序结束。实现的代码如下：

package tcp;

import java.io.*;

import java.net.*;

/**

 * 简单的Socket客户端

 * 功能为：发送字符串“Hello”到服务器端，并打印出服务器端的反馈

 */

public class SimpleSocketClient {

         public static void main(String[] args) {

                   Socket socket = null;

                   InputStream is = null;

                   OutputStream os = null;

                   //服务器端IP地址

                   String serverIP = "127.0.0.1";

                   //服务器端端口号

                   int port = 10000;

                   //发送内容

                   String data = "Hello";

                   try {

                            //建立连接

                            socket = new Socket(serverIP,port);

                            //发送数据

                            os = socket.getOutputStream();

                            os.write(data.getBytes());

                            //接收数据

                            is = socket.getInputStream();

                            byte[] b = new byte[1024];

                            int n = is.read(b);

                            //输出反馈数据

                            System.out.println("服务器反馈：" + new String(b,0,n));

                   } catch (Exception e) {

                            e.printStackTrace(); //打印异常信息

                   }finally{

                            try {

                                     //关闭流和连接

                                     is.close();

                                     os.close();

                                     socket.close();

                            } catch (Exception e2) {}

                   }

         }

}

在该示例代码中建立了一个连接到IP地址为127.0.0.1，端口号码为10000的TCP类型的网络连接，然后获得连接的输出流对象，将需要发送的字符串“Hello”转换为byte数组写入到输出流中，由系统自动完成将输出流中的数据发送出去，如果需要强制发送，可以调用输出流对象中的flush方法实现。在数据发送出去以后，从连接对象的输入流中读取服务器端的反馈信息，读取时可以使用IO中的各种读取方法进行读取，这里使用最简单的方法进行读取，从输入流中读取到的内容就是服务器端的反馈，并将读取到的内容在客户端的控制台进行输出，最后依次关闭打开的流对象和网络连接对象。

这是一个简单的功能示例，在该示例中演示了TCP类型的网络客户端基本方法的使用，该代码只起演示目的，还无法达到实用的级别。

如果需要在控制台下面编译和运行该代码，需要首先在控制台下切换到源代码所在的目录，然后依次输入编译和运行命令：

         javac –d . SimpleSocketClient.java

         java tcp.SimpleSocketClient

和下面将要介绍的SimpleSocketServer服务器端组合运行时，程序的输出结果为：

         服务器反馈：Hello

介绍完一个简单的客户端编程的示例，下面接着介绍一下TCP类型的服务器端的编写。首先需要说明的是，客户端的步骤和服务器端的编写步骤不同，所以在学习服务器端编程时注意不要和客户端混淆起来。

在服务器端程序编程中，由于服务器端实现的是被动等待连接，所以服务器端编程的第一个步骤是监听端口，也就是监听是否有客户端连接到达。实现服务器端监听的代码为：

         ServerSocket ss = new ServerSocket(10000);

该代码实现的功能是监听当前计算机的10000号端口，如果在执行该代码时，10000号端口已经被别的程序占用，那么将抛出异常。否则将实现监听。

服务器端编程的第二个步骤是获得连接。该步骤的作用是当有客户端连接到达时，建立一个和客户端连接对应的Socket连接对象，从而释放客户端连接对于服务器端端口的占用。实现功能就像公司的前台一样，当一个客户到达公司时，会告诉前台我找某某某，然后前台就通知某某某，然后就可以继续接待其它客户了。通过获得连接，使得客户端的连接在服务器端获得了保持，另外使得服务器端的端口释放出来，可以继续等待其它的客户端连接。实现获得连接的代码是：

         Socket socket = ss.accept();

该代码实现的功能是获得当前连接到服务器端的客户端连接。需要说明的是accept和前面IO部分介绍的read方法一样，都是一个阻塞方法，也就是当无连接时，该方法将阻塞程序的执行，直到连接到达时才执行该行代码。另外获得的连接会在服务器端的该端口注册，这样以后就可以通过在服务器端的注册信息直接通信，而注册以后服务器端的端口就被释放出来，又可以继续接受其它的连接了。

连接获得以后，后续的编程就和客户端的网络编程类似了，这里获得的Socket类型的连接就和客户端的网络连接一样了，只是服务器端需要首先读取发送过来的数据，然后进行逻辑处理以后再发送给客户端，也就是交换数据的顺序和客户端交换数据的步骤刚好相反。这部分的内容和客户端很类似，所以就不重复了，如果还不熟悉，可以参看下面的示例代码。

最后，在服务器端通信完成以后，关闭服务器端连接。实现的代码为：

         ss.close();

这就是基本的TCP类型的服务器端编程步骤。下面以一个简单的echo服务实现为例子，介绍综合使用示例。echo的意思就是“回声”，echo服务器端实现的功能就是将客户端发送的内容再原封不动的反馈给客户端。实现的代码如下：

         package tcp;

import java.io.*;

import java.net.*;

/**

 * echo服务器

 * 功能：将客户端发送的内容反馈给客户端

 */

public class SimpleSocketServer {

         public static void main(String[] args) {

                   ServerSocket serverSocket = null;

                   Socket socket = null;

                   OutputStream os = null;

                   InputStream is = null;

                   //监听端口号

                   int port = 10000;

                   try {

                            //建立连接

                            serverSocket = new ServerSocket(port);

                            //获得连接

                            socket = serverSocket.accept();

                            //接收客户端发送内容

                            is = socket.getInputStream();

                            byte[] b = new byte[1024];

                            int n = is.read(b);

                            //输出

                            System.out.println("客户端发送内容为：" + new String(b,0,n));

                            //向客户端发送反馈内容

                            os = socket.getOutputStream();

                            os.write(b, 0, n);

                   } catch (Exception e) {

                            e.printStackTrace();

                   }finally{

                            try{

                                     //关闭流和连接

                                     os.close();

                                     is.close();

                                     socket.close();

                                     serverSocket.close();

                            }catch(Exception e){}

                   }

         }

}

在该示例代码中建立了一个监听当前计算机10000号端口的服务器端Socket连接，然后获得客户端发送过来的连接，如果有连接到达时，读取连接中发送过来的内容，并将发送的内容在控制台进行输出，输出完成以后将客户端发送的内容再反馈给客户端。最后关闭流和连接对象，结束程序。

在控制台下面编译和运行该程序的命令和客户端部分的类似。

这样，就以一个很简单的示例演示了TCP类型的网络编程在Java语言中的基本实现，这个示例只是演示了网络编程的基本步骤以及各个功能方法的基本使用，只是为网络编程打下了一个基础，下面将就几个问题来深入介绍网络编程深层次的一些知识。

本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/Mailbomb/archive/2009/06/07/4249623.aspx

为了一步一步的掌握网络编程，下面再研究网络编程中的两个基本问题，通过解决这两个问题将对网络编程的认识深入一层。

1、如何复用Socket连接？

在前面的示例中，客户端中建立了一次连接，只发送一次数据就关闭了，这就相当于拨打电话时，电话打通了只对话一次就关闭了，其实更加常用的应该是拨通一次电话以后多次对话，这就是复用客户端连接。

那么如何实现建立一次连接，进行多次数据交换呢？其实很简单，建立连接以后，将数据交换的逻辑写到一个循环中就可以了。这样只要循环不结束则连接就不会被关闭。按照这种思路，可以改造一下上面的代码，让该程序可以在建立连接一次以后，发送三次数据，当然这里的次数也可以是多次，示例代码如下：

package tcp;

import java.io.*;

import java.net.*;

/**

 * 复用连接的Socket客户端

 * 功能为：发送字符串“Hello”到服务器端，并打印出服务器端的反馈

 */

public class MulSocketClient {

         public static void main(String[] args) {

                   Socket socket = null;

                   InputStream is = null;

                   OutputStream os = null;

                   //服务器端IP地址

                   String serverIP = "127.0.0.1";

                   //服务器端端口号

                   int port = 10000;

                   //发送内容

                   String data[] ={"First","Second","Third"};

                   try {

                            //建立连接

                            socket = new Socket(serverIP,port);

                            //初始化流

                            os = socket.getOutputStream();

                            is = socket.getInputStream();

                            byte[] b = new byte[1024];

                            for(int i = 0;i < data.length;i++){

                                     //发送数据

                                     os.write(data[i].getBytes());

                                     //接收数据

                                     int n = is.read(b);

                                     //输出反馈数据

                                     System.out.println("服务器反馈：" + new String(b,0,n));

                            }

                   } catch (Exception e) {

                            e.printStackTrace(); //打印异常信息

                   }finally{

                            try {

                                     //关闭流和连接

                                     is.close();

                                     os.close();

                                     socket.close();

                            } catch (Exception e2) {}

                   }

         }

}

该示例程序和前面的代码相比，将数据交换部分的逻辑写在一个for循环的内容，这样就可以建立一次连接，依次将data数组中的数据按照顺序发送给服务器端了。

                   如果还是使用前面示例代码中的服务器端程序运行该程序，则该程序的结果是：

                            java.net.SocketException: Software caused connection abort: recv failed

                                     at java.net.SocketInputStream.socketRead0(Native Method)

                                     at java.net.SocketInputStream.read(SocketInputStream.java:129)

                                     at java.net.SocketInputStream.read(SocketInputStream.java:90)

                                     at tcp.MulSocketClient.main(MulSocketClient.java:30)

服务器反馈：First

显然，客户端在实际运行时出现了异常，出现异常的原因是什么呢？如果仔细阅读前面的代码，应该还记得前面示例代码中的服务器端是对话一次数据以后就关闭了连接，如果服务器端程序关闭了，客户端继续发送数据肯定会出现异常，这就是出现该问题的原因。

按照客户端实现的逻辑，也可以复用服务器端的连接，实现的原理也是将服务器端的数据交换逻辑写在循环中即可，按照该种思路改造以后的服务器端代码为：

         package tcp;

import java.io.*;

import java.net.*;

/**

 * 复用连接的echo服务器

 * 功能：将客户端发送的内容反馈给客户端

 */

public class MulSocketServer {

         public static void main(String[] args) {

                   ServerSocket serverSocket = null;

                   Socket socket = null;

                   OutputStream os = null;

                   InputStream is = null;

                   //监听端口号

                   int port = 10000;

                   try {

                            //建立连接

                            serverSocket = new ServerSocket(port);

                            System.out.println("服务器已启动：");

                            //获得连接

                            socket = serverSocket.accept();

                            //初始化流

                            is = socket.getInputStream();

                            os = socket.getOutputStream();

                            byte[] b = new byte[1024];

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

                                     int n = is.read(b);

                                     //输出

                                     System.out.println("客户端发送内容为：" + new String(b,0,n));

                                     //向客户端发送反馈内容

                                     os.write(b, 0, n);

                            }

                   } catch (Exception e) {

                            e.printStackTrace();

                   }finally{

                            try{

                                     //关闭流和连接

                                     os.close();

                                     is.close();

                                     socket.close();

                                     serverSocket.close();

                            }catch(Exception e){}

                   }

         }

}

在该示例代码中，也将数据发送和接收的逻辑写在了一个for循环内部，只是在实现时硬性的将循环次数规定成了3次，这样代码虽然比较简单，但是通用性比较差。

                   以该服务器端代码实现为基础运行前面的客户端程序时，客户端的输出为：

                            服务器反馈：First

服务器反馈：Second

服务器反馈：Third

       服务器端程序的输出结果为：

           服务器已启动：

客户端发送内容为：First

客户端发送内容为：Second

客户端发送内容为：Third

在该程序中，比较明显的体现出了“请求-响应”模型，也就是在客户端发起连接以后，首先发送字符串“First”给服务器端，服务器端输出客户端发送的内容“First”，然后将客户端发送的内容再反馈给客户端，这样客户端也输出服务器反馈“First”，这样就完成了客户端和服务器端的一次对话，紧接着客户端发送“Second”给服务器端，服务端输出“Second”，然后将“Second”再反馈给客户端，客户端再输出“Second”，从而完成第二次会话，第三次会话的过程和这个一样。在这个过程中，每次都是客户端程序首先发送数据给服务器端，服务器接收数据以后，将结果反馈给客户端，客户端接收到服务器端的反馈，从而完成一次通讯过程。

在该示例中，虽然解决了多次发送的问题，但是客户端和服务器端的次数控制还不够灵活，如果客户端的次数不固定怎么办呢？是否可以使用某个特殊的字符串，例如quit，表示客户端退出呢,这就涉及到网络协议的内容了，会在后续的网络应用示例部分详细介绍。下面开始介绍另外一个网络编程的突出问题。

2、如何使服务器端支持多个客户端同时工作？

         前面介绍的服务器端程序，只是实现了概念上的服务器端，离实际的服务器端程序结构距离还很遥远，如果需要让服务器端能够实际使用，那么最需要解决的问题就是——如何支持多个客户端同时工作。

         一个服务器端一般都需要同时为多个客户端提供通讯，如果需要同时支持多个客户端，则必须使用前面介绍的线程的概念。简单来说，也就是当服务器端接收到一个连接时，启动一个专门的线程处理和该客户端的通讯。

         按照这个思路改写的服务端示例程序将由两个部分组成，MulThreadSocketServer类实现服务器端控制，实现接收客户端连接，然后开启专门的逻辑线程处理该连接，LogicThread类实现对于一个客户端连接的逻辑处理，将处理的逻辑放置在该类的run方法中。该示例的代码实现为：

                   package tcp;

import java.net.ServerSocket;

import java.net.Socket;

/**

 * 支持多客户端的服务器端实现

 */

public class MulThreadSocketServer {

         public static void main(String[] args) {

                   ServerSocket serverSocket = null;

                   Socket socket = null;

                   //监听端口号

                   int port = 10000;

                   try {

                            //建立连接

                            serverSocket = new ServerSocket(port);

                            System.out.println("服务器已启动：");

                            while(true){

                                     //获得连接

                                     socket = serverSocket.accept();

                                     //启动线程

                                     new LogicThread(socket);

                            }

                   } catch (Exception e) {

                            e.printStackTrace();

                   }finally{

                            try{

                                     //关闭连接

                                     serverSocket.close();

                            }catch(Exception e){}

                   }

         }

}

         在该示例代码中，实现了一个while形式的死循环，由于accept方法是阻塞方法，所以当客户端连接未到达时，将阻塞该程序的执行，当客户端到达时接收该连接，并启动一个新的LogicThread线程处理该连接，然后按照循环的执行流程，继续等待下一个客户端连接。这样当任何一个客户端连接到达时，都开启一个专门的线程处理，通过多个线程支持多个客户端同时处理。

         下面再看一下LogicThread线程类的源代码实现：

                   package tcp;

import java.io.*;

import java.net.*;

/**

 * 服务器端逻辑线程

 */

public class LogicThread extends Thread {

         Socket socket;

         InputStream is;

         OutputStream os;

         public LogicThread(Socket socket){

                   this.socket = socket;

                   start(); //启动线程

         }

         

         public void run(){

                   byte[] b = new byte[1024];

                   try{

                            //初始化流

                            os = socket.getOutputStream();

                            is = socket.getInputStream();

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

                                     //读取数据

                                     int n = is.read(b);

                                     //逻辑处理

                                     byte[] response = logic(b,0,n);

                                     //反馈数据

                                     os.write(response);

                            }

                   }catch(Exception e){

                            e.printStackTrace();

                   }finally{

                            close();

                   }

         }

         

         /**

          * 关闭流和连接

          */

         private void close(){

                   try{

                            //关闭流和连接

                            os.close();

                            is.close();

                            socket.close();

                   }catch(Exception e){}

         }

         

         /**

          * 逻辑处理方法,实现echo逻辑

          * @param b 客户端发送数据缓冲区

          * @param off 起始下标

          * @param len 有效数据长度

          * @return

          */

         private byte[] logic(byte[] b,int off,int len){

                   byte[] response = new byte[len];

                   //将有效数据拷贝到数组response中

                   System.arraycopy(b, 0, response, 0, len);

                   return response;

         }

}

         在该示例代码中，每次使用一个连接对象构造该线程，该连接对象就是该线程需要处理的连接，在线程构造完成以后，该线程就被启动起来了，然后在run方法内部对客户端连接进行处理，数据交换的逻辑和前面的示例代码一致，只是这里将接收到客户端发送过来的数据并进行处理的逻辑封装成了logic方法，按照前面介绍的IO编程的内容，客户端发送过来的内容存储在数组b的起始下标为0，长度为n个中，这些数据是客户端发送过来的有效数据，将有效的数据传递给logic方法，logic方法实现的是echo服务的逻辑，也就是将客户端发送的有效数据形成以后新的response数组，并作为返回值反馈。

         在线程中将logic方法的返回值反馈给客户端，这样就完成了服务器端的逻辑处理模拟，其他的实现和前面的介绍类似，这里就不在重复了。

         这里的示例还只是基础的服务器端实现，在实际的服务器端实现中，由于硬件和端口数的限制，所以不能无限制的创建线程对象，而且频繁的创建线程对象效率也比较低，所以程序中都实现了线程池来提高程序的执行效率。

         这里简单介绍一下线程池的概念，线程池(Thread pool)是池技术的一种，就是在程序启动时首先把需要个数的线程对象创建好，例如创建5000个线程对象，然后当客户端连接到达时从池中取出一个已经创建完成的线程对象使用即可。当客户端连接关闭以后，将该线程对象重新放入到线程池中供其它的客户端重复使用，这样可以提高程序的执行速度，优化程序对于内存的占用等。

         关于基础的TCP方式的网络编程就介绍这么多，下面介绍UDP方式的网络编程在Java语言中的实现。

本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/Mailbomb/archive/2009/06/10/4258698.aspx

13.2.4 UDP编程

         网络通讯的方式除了TCP方式以外，还有一种实现的方式就是UDP方式。UDP(User Datagram Protocol)，中文意思是用户数据报协议，方式类似于发短信息，是一种物美价廉的通讯方式，使用该种方式无需建立专用的虚拟连接，由于无需建立专用的连接，所以对于服务器的压力要比TCP小很多，所以也是一种常见的网络编程方式。但是使用该种方式最大的不足是传输不可靠，当然也不是说经常丢失，就像大家发短信息一样，理论上存在收不到的可能，这种可能性可能是1%，反正比较小，但是由于这种可能的存在，所以平时我们都觉得重要的事情还是打个电话吧(类似TCP方式)，一般的事情才发短信息(类似UDP方式)。网络编程中也是这样，必须要求可靠传输的信息一般使用TCP方式实现，一般的数据才使用UDP方式实现。

         UDP方式的网络编程也在Java语言中获得了良好的支持，由于其在传输数据的过程中不需要建立专用的连接等特点，所以在Java API中设计的实现结构和TCP方式不太一样。当然，需要使用的类还是包含在java.net包中。

         在Java API中，实现UDP方式的编程，包含客户端网络编程和服务器端网络编程，主要由两个类实现，分别是：

l  DatagramSocket

DatagramSocket类实现“网络连接”，包括客户端网络连接和服务器端网络连接。虽然UDP方式的网络通讯不需要建立专用的网络连接，但是毕竟还是需要发送和接收数据，DatagramSocket实现的就是发送数据时的发射器，以及接收数据时的监听器的角色。类比于TCP中的网络连接，该类既可以用于实现客户端连接，也可以用于实现服务器端连接。

l  DatagramPacket

DatagramPacket类实现对于网络中传输的数据封装，也就是说，该类的对象代表网络中交换的数据。在UDP方式的网络编程中，无论是需要发送的数据还是需要接收的数据，都必须被处理成DatagramPacket类型的对象，该对象中包含发送到的地址、发送到的端口号以及发送的内容等。其实DatagramPacket类的作用类似于现实中的信件，在信件中包含信件发送到的地址以及接收人，还有发送的内容等，邮局只需要按照地址传递即可。在接收数据时，接收到的数据也必须被处理成DatagramPacket类型的对象，在该对象中包含发送方的地址、端口号等信息，也包含数据的内容。和TCP方式的网络传输相比，IO编程在UDP方式的网络编程中变得不是必须的内容，结构也要比TCP方式的网络编程简单一些。

         下面介绍一下UDP方式的网络编程中，客户端和服务器端的实现步骤，以及通过基础的示例演示UDP方式的网络编程在Java语言中的实现方式。

         UDP方式的网络编程，编程的步骤和TCP方式类似，只是使用的类和方法存在比较大的区别，下面首先介绍一下UDP方式的网络编程客户端实现过程。

UDP客户端编程涉及的步骤也是4个部分：建立连接、发送数据、接收数据和关闭连接。

首先介绍UDP方式的网络编程中建立连接的实现。其中UDP方式的建立连接和TCP方式不同，只需要建立一个连接对象即可，不需要指定服务器的IP和端口号码。实现的代码为：

                   DatagramSocket ds = new DatagramSocket();

         这样就建立了一个客户端连接，该客户端连接使用系统随机分配的一个本地计算机的未用端口号。在该连接中，不指定服务器端的IP和端口，所以UDP方式的网络连接更像一个发射器，而不是一个具体的连接。

         当然，可以通过制定连接使用的端口号来创建客户端连接。

                   DatagramSocket ds = new DatagramSocket(5000);

         这样就是使用本地计算机的5000号端口建立了一个连接。一般在建立客户端连接时没有必要指定端口号码。

         接着，介绍一下UDP客户端编程中发送数据的实现。在UDP方式的网络编程中，IO技术不是必须的，在发送数据时，需要将需要发送的数据内容首先转换为byte数组，然后将数据内容、服务器IP和服务器端口号一起构造成一个DatagramPacket类型的对象，这样数据的准备就完成了，发送时调用网络连接对象中的send方法发送该对象即可。例如将字符串“Hello”发送到IP是127.0.0.1，端口号是10001的服务器，则实现发送数据的代码如下：

                  String s = “Hello”;

                   String host = “127.0.0.1”;

                   int port = 10001;

                  //将发送的内容转换为byte数组

                   byte[] b = s.getBytes();

                   //将服务器IP转换为InetAddress对象

                   InetAddress server = InetAddress.getByName(host);

                   //构造发送的数据包对象

                   DatagramPacket sendDp = new DatagramPacket(b,b.length,server,port);

                   //发送数据

                   ds.send(sendDp);

         在该示例代码中，不管发送的数据内容是什么，都需要转换为byte数组，然后将服务器端的IP地址构造成InetAddress类型的对象，在准备完成以后，将这些信息构造成一个DatagramPacket类型的对象，在UDP编程中，发送的数据内容、服务器端的IP和端口号，都包含在DatagramPacket对象中。在准备完成以后，调用连接对象ds的send方法把DatagramPacket对象发送出去即可。

         按照UDP协议的约定，在进行数据传输时，系统只是尽全力传输数据，但是并不保证数据一定被正确传输，如果数据在传输过程中丢失，那就丢失了。

         UDP方式在进行网络通讯时，也遵循“请求-响应”模型，在发送数据完成以后，就可以接收服务器端的反馈数据了。

         下面介绍一下UDP客户端编程中接收数据的实现。当数据发送出去以后，就可以接收服务器端的反馈信息了。接收数据在Java语言中的实现是这样的：首先构造一个数据缓冲数组，该数组用于存储接收的服务器端反馈数据，该数组的长度必须大于或等于服务器端反馈的实际有效数据的长度。然后以该缓冲数组为基础构造一个DatagramPacket数据包对象，最后调用连接对象的receive方法接收数据即可。接收到的服务器端反馈数据存储在DatagramPacket类型的对象内部。实现接收数据以及显示服务器端反馈内容的示例代码如下：

                   //构造缓冲数组

                   byte[] data = new byte[1024];

                   //构造数据包对象

                   DatagramPacket received = new DatagramPacket(data,data.length);

                   //接收数据

                   ds.receive(receiveDp);

                   //输出数据内容

                   byte[] b = receiveDp.getData();  //获得缓冲数组

                   int len = receiveDp.getLength(); //获得有效数据长度

                   String s = new String(b,0,len);

                   System.out.println(s);

         在该代码中，首先构造缓冲数组data，这里设置的长度1024是预估的接收到的数据长度，要求该长度必须大于或等于接收到的数据长度，然后以该缓冲数组为基础，构造数据包对象，使用连接对象ds的receive方法接收反馈数据，由于在Java语言中，除String以外的其它对象都是按照地址传递，所以在receive方法内部可以改变数据包对象receiveDp的内容，这里的receiveDp的功能和返回值类似。数据接收到以后，只需要从数据包对象中读取出来就可以了，使用DatagramPacket对象中的getData方法可以获得数据包对象的缓冲区数组，但是缓冲区数组的长度一般大于有效数据的长度，换句话说，也就是缓冲区数组中只有一部分数据是反馈数据，所以需要使用DatagramPacket对象中的getLength方法获得有效数据的长度，则有效数据就是缓冲数组中的前有效数据长度个内容，这些才是真正的服务器端反馈的数据的内容。

         UDP方式客户端网络编程的最后一个步骤就是关闭连接。虽然UDP方式不建立专用的虚拟连接，但是连接对象还是需要占用系统资源，所以在使用完成以后必须关闭连接。关闭连接使用连接对象中的close方法即可，实现的代码如下：

                   ds.close();

         需要说明的是，和TCP建立连接的方式不同，UDP方式的同一个网络连接对象，可以发送到达不同服务器端IP或端口的数据包，这点是TCP方式无法做到的。

         介绍完了UDP方式客户端网络编程的基础知识以后，下面再来介绍一下UDP方式服务器端网络编程的基础知识。

         UDP方式网络编程的服务器端实现和TCP方式的服务器端实现类似，也是服务器端监听某个端口，然后获得数据包，进行逻辑处理以后将处理以后的结果反馈给客户端，最后关闭网络连接，下面依次进行介绍。

         首先UDP方式服务器端网络编程需要建立一个连接，该连接监听某个端口，实现的代码为：

           DatagramSocket ds = new DatagramSocket(10010);

由于服务器端的端口需要固定，所以一般在建立服务器端连接时，都指定端口号。例如该示例代码中指定10010端口为服务器端使用的端口号，客户端端在连接服务器端时连接该端口号即可。

接着服务器端就开始接收客户端发送过来的数据，其接收的方法和客户端接收的方法一直，其中receive方法的作用类似于TCP方式中accept方法的作用，该方法也是一个阻塞方法，其作用是接收数据。

接收到客户端发送过来的数据以后，服务器端对该数据进行逻辑处理，然后将处理以后的结果再发送给客户端，在这里发送时就比客户端要麻烦一些，因为服务器端需要获得客户端的IP和客户端使用的端口号，这个都可以从接收到的数据包中获得。示例代码如下：

     //获得客户端的IP

     InetAddress clientIP = receiveDp.getAddress();

         //获得客户端的端口号

         Int clientPort = receiveDp.getPort();

     使用以上代码，就可以从接收到的数据包对象receiveDp中获得客户端的IP地址和客户端的端口号，这样就可以在服务器端中将处理以后的数据构造成数据包对象，然后将处理以后的数据内容反馈给客户端了。

     最后，当服务器端实现完成以后，关闭服务器端连接，实现的方式为调用连接对象的close方法，示例代码如下：

         ds.close();

     介绍完了UDP方式下的客户端编程和服务器端编程的基础知识以后，下面通过一个简单的示例演示UDP网络编程的基本使用

本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/Mailbomb/archive/2009/06/14/4267447.aspx

该示例的功能是实现将客户端程序的系统时间发送给服务器端，服务器端接收到时间以后，向客户端反馈字符串“OK”。实现该功能的客户端代码如下所示：

        package udp;

import java.net.*;

import java.util.*;

/**

 * 简单的UDP客户端，实现向服务器端发生系统时间功能

 */

public class SimpleUDPClient {

            public static void main(String[] args) {

                     DatagramSocket ds = null;  //连接对象

                     DatagramPacket sendDp; //发送数据包对象

                DatagramPacket receiveDp; //接收数据包对象

                     String serverHost = "127.0.0.1"; //服务器IP

                int serverPort = 10010;  //服务器端口号

                     try{

                        //建立连接

                        ds = new DatagramSocket();

                        //初始化发送数据

                        Date d = new Date(); //当前时间

                        String content = d.toString(); //转换为字符串

                        byte[] data = content.getBytes();

                        //初始化发送包对象

                        InetAddress address = InetAddress.getByName(serverHost);

                        sendDp = new DatagramPacket(data,data.length,address,serverPort);

                        //发送

                        ds.send(sendDp);

                                                                           

                        //初始化接收数据

                        byte[] b = new byte[1024];

                        receiveDp = new DatagramPacket(b,b.length);

                        //接收

                        ds.receive(receiveDp);

                        //读取反馈内容，并输出

                        byte[] response = receiveDp.getData(); 

                        int len = receiveDp.getLength();

                        String s = new String(response,0,len);

                        System.out.println("服务器端反馈为：" + s);

                }catch(Exception e){

                        e.printStackTrace();

                }finally{

                        try{

                           //关闭连接

                           ds.close();

                        }catch(Exception e){}

                }

            }

        }

在该示例代码中，首先建立UDP方式的网络连接，然后获得当前系统时间，这里获得的系统时间是客户端程序运行的本地计算机的时间，然后将时间字符串以及服务器端的IP和端口，构造成发送数据包对象，调用连接对象ds的send方法发送出去。在数据发送出去以后，构造接收数据的数据包对象，调用连接对象ds的receive方法接收服务器端的反馈，并输出在控制台。最后在finally语句块中关闭客户端网络连接。

和下面将要介绍的服务器端一起运行时，客户端程序的输出结果为：

    服务器端反馈为：OK

下面是该示例程序的服务器端代码实现：

        package udp;

        import java.net.*;

        /**

         * 简单UDP服务器端，实现功能是输出客户端发送数据，

           并反馈字符串“OK"给客户端

         */

        public class SimpleUDPServer {

            public static void main(String[] args) {

                     DatagramSocket ds = null;  //连接对象

                     DatagramPacket sendDp; //发送数据包对象

                     DatagramPacket receiveDp; //接收数据包对象

                     final int PORT = 10010; //端口

                                               try{

                        //建立连接，监听端口

                        ds = new DatagramSocket(PORT);

                        System.out.println("服务器端已启动：");

                        //初始化接收数据

                        byte[] b = new byte[1024];

                        receiveDp = new DatagramPacket(b,b.length);

                        //接收

                        ds.receive(receiveDp);

                        //读取反馈内容，并输出

                        InetAddress clientIP = receiveDp.getAddress();

                        int clientPort = receiveDp.getPort();

                        byte[] data = receiveDp.getData();

                        int len = receiveDp.getLength();

                        System.out.println("客户端IP：" + clientIP.getHostAddress());

                        System.out.println("客户端端口：" + clientPort);

                        System.out.println("客户端发送内容：" + new String(data,0,len));

                                                                           

                        //发送反馈

                        String response = "OK";

                        byte[] bData = response.getBytes();

                        sendDp = new DatagramPacket(bData,bData.length,clientIP,clientPort);

                        //发送

                        ds.send(sendDp);

                                               }catch(Exception e){

                        e.printStackTrace();

                                               }finally{

                        try{

                           //关闭连接

                           ds.close();

                        }catch(Exception e){}

                                               }

            }

        }

在该服务器端实现中，首先监听10010号端口，和TCP方式的网络编程类似，服务器端的receive方法是阻塞方法，如果客户端不发送数据，则程序会在该方法处阻塞。当客户端发送数据到达服务器端时，则接收客户端发送过来的数据，然后将客户端发送的数据内容读取出来，并在服务器端程序中打印客户端的相关信息，从客户端发送过来的数据包中可以读取出客户端的IP以及客户端端口号，将反馈数据字符串“OK”发送给客户端，最后关闭服务器端连接，释放占用的系统资源，完成程序功能示例。

和前面TCP方式中的网络编程类似，这个示例也仅仅是网络编程的功能示例，也存在前面介绍的客户端无法进行多次数据交换，以及服务器端不支持多个客户端的问题，这两个问题也需要对于代码进行处理才可以很方便的进行解决。

在解决该问题以前，需要特别指出的是UDP方式的网络编程由于不建立虚拟的连接，所以在实际使用时和TCP方式存在很多的不同，最大的一个不同就是“无状态”。该特点指每次服务器端都收到信息，但是这些信息和连接无关，换句话说，也就是服务器端只是从信息是无法识别出是谁发送的，这样就要求发送信息时的内容需要多一些，这个在后续的示例中可以看到。

下面是实现客户端多次发送以及服务器端支持多个数据包同时处理的程序结构，实现的原理和TCP方式类似，在客户端将数据的发送和接收放入循环中，而服务器端则将接收到的每个数据包启动一个专门的线程进行处理。实现的代码如下：

    package udp;

    import java.net.*;

    import java.util.*;

    /**

     * 简单的UDP客户端，实现向服务器端发生系统时间功能

     * 该程序发送3次数据到服务器端

     */

    public class MulUDPClient {

                  public static void main(String[] args) {

                 DatagramSocket ds = null;  //连接对象 

                                     DatagramPacket sendDp; //发送数据包对象

                                     DatagramPacket receiveDp; //接收数据包对象

                                     String serverHost = "127.0.0.1"; //服务器IP

                                     int serverPort = 10012;  //服务器端口号

                                     try{

                    //建立连接

                    ds = new DatagramSocket();

                    //初始化

                               InetAddress address = InetAddress.getByName(serverHost);

                    byte[] b = new byte[1024];

                    receiveDp = new DatagramPacket(b,b.length);

                    System.out.println("客户端准备完成");

                    //循环30次，每次间隔0.01秒

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

                                                        //初始化发送数据

                                                        Date d = new Date(); //当前时间

                                                        String content = d.toString(); //转换为字符串

                                                        byte[] data = content.getBytes();

                                                        //初始化发送包对象

                                                        sendDp = new DatagramPacket(data,data.length,address, serverPort);

                                                        //发送

                                                        ds.send(sendDp);

                                                        //延迟

                                                        Thread.sleep(10);

                                                        //接收

                                                        ds.receive(receiveDp);

                                                        //读取反馈内容，并输出

                                                        byte[] response = receiveDp.getData(); 

                                                        int len = receiveDp.getLength();

                                                        String s = new String(response,0,len);

                                                        System.out.println("服务器端反馈为：" + s);

                     }

                 }catch(Exception e){

                     e.printStackTrace();

                 }finally{

                     try{

                                                        //关闭连接

                                                        ds.close();

                     }catch(Exception e){}

                 }

         }

     }

在该示例中，将和服务器端进行数据交换的逻辑写在一个for循环的内部，这样就可以实现和服务器端的多次交换了，考虑到服务器端的响应速度，在每次发送之间加入0.01秒的时间间隔。最后当数据交换完成以后关闭连接，结束程序。

实现该逻辑的服务器端程序代码如下：

package udp;

import java.net.*;

/**

* 可以并发处理数据包的服务器端

* 功能为：显示客户端发送的内容，并向客户端反馈字符串“OK”

*/

public class MulUDPServer {

public static void main(String[] args) {

DatagramSocket ds = null;  //连接对象

DatagramPacket receiveDp; //接收数据包对象

final int PORT = 10012; //端口

byte[] b = new byte[1024];

receiveDp = new DatagramPacket(b,b.length);

try{

//建立连接，监听端口

ds = new DatagramSocket(PORT);

System.out.println("服务器端已启动：");

while(true){

//接收

ds.receive(receiveDp);

//启动线程处理数据包

new LogicThread(ds,receiveDp);

}

}catch(Exception e){

         e.printStackTrace();

}finally{

try{

//关闭连接

ds.close();

}catch(Exception e){}

}

}

}

该代码实现了服务器端的接收逻辑，使用一个循环来接收客户端发送过来的数据包，当接收到数据包以后启动一个LogicThread线程处理该数据包。这样服务器端就可以实现同时处理多个数据包了。

实现逻辑处理的线程代码如下：

package udp;

import java.net.*;

/**

 * 逻辑处理线程

 */

public class LogicThread extends Thread {

/**连接对象*/

DatagramSocket ds;

/**接收到的数据包*/

DatagramPacket dp;

 

public LogicThread(DatagramSocket ds,DatagramPacket dp){

this.ds = ds;

this.dp = dp;

start(); //启动线程

}

 

public void run(){

try{

//获得缓冲数组

byte[] data = dp.getData();

//获得有效数据长度

int len = dp.getLength();

//客户端IP

InetAddress clientAddress = dp.getAddress();

//客户端端口

int clientPort = dp.getPort();

//输出

System.out.println("客户端IP：" + clientAddress.getHostAddress());

System.out.println("客户端端口号：" + clientPort);

System.out.println("客户端发送内容：" + new String(data,0,len));

//反馈到客户端

byte[] b = "OK".getBytes();

DatagramPacket sendDp = new DatagramPacket(b,b.length,clientAddress,clientPort);

//发送

ds.send(sendDp);

}catch(Exception e){

e.printStackTrace();

}

}

}

在该线程中，只处理一次UDP通讯，当通讯结束以后线程死亡，在线程内部，每次获得客户端发送过来的信息，将获得的信息输出到服务器端程序的控制台，然后向客户端反馈字符串“OK”。

由于UDP数据传输过程中可能存在丢失，所以在运行该程序时可能会出现程序阻塞的情况。如果需要避免该问题，可以将客户端的网络发送部分也修改成线程实现。

关于基础的UDP网络编程就介绍这么多了，下面将介绍一下网络协议的概念。

本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/Mailbomb/archive/2009/06/14/4268582.aspx

13.2.5 网络协议

         对于需要从事网络编程的程序员来说，网络协议是一个需要深刻理解的概念。那么什么是网络协议呢？

         网络协议是指对于网络中传输的数据格式的规定。对于网络编程初学者来说，没有必要深入了解TCP/IP协议簇，所以对于初学者来说去读大部头的《TCP/IP协议》也不是一件很合适的事情，因为深入了解TCP/IP协议是网络编程提高阶段，也是深入网络编程底层时才需要做的事情。

         对于一般的网络编程来说，更多的是关心网络上传输的逻辑数据内容，也就是更多的是应用层上的网络协议，所以后续的内容均以实际应用的数据为基础来介绍网络协议的概念。

         那么什么是网络协议呢，下面看一个简单的例子。春节晚会上“小沈阳”和赵本山合作的小品《不差钱》中，小沈阳和赵本山之间就设计了一个协议，协议的内容为：

                   如果点的菜价钱比较贵是，就说没有。

         按照该协议的规定，就有了下面的对话：

                   赵本山：4斤的龙虾

                   小沈阳：(经过判断，得出价格比较高)，没有

                   赵本山：鲍鱼

                   小沈阳：(经过判断，得出价格比较高)，没有

         这就是一种双方达成的一种协议约定，其实这种约定的实质和网络协议的实质是一样的。网络协议的实质也是客户端程序和服务器端程序对于数据的一种约定，只是由于以计算机为基础，所以更多的是使用数字来代表内容，这样就显得比较抽象一些。

         下面再举一个简单的例子，介绍一些基础的网络协议设计的知识。例如需要设计一个简单的网络程序：网络计算器。也就是在客户端输入需要计算的数字和运算符，在服务器端实现计算，并将计算的结果反馈给客户端。在这个例子中，就需要约定两个数据格式：客户端发送给服务器端的数据格式，以及服务器端反馈给客户端的数据格式。

         可能你觉得这个比较简单，例如客户端输入的数字依次是12和432，输入的运算符是加号，可能最容易想到的数据格式是形成字符串“12+432”，这样格式的确比较容易阅读，但是服务器端在进行计算时，逻辑就比较麻烦，因为需要首先拆分该字符串，然后才能进行计算，所以可用的数据格式就有了一下几种：

                   “12，432，+”     格式为：第一个数字，第二个数字，运算符

                   “12，+，432”     格式为：第一个数字，运算符，第二个数字

         其实以上两种数据格式很接近，比较容易阅读，在服务器端收到该数据格式以后，使用“，”为分隔符分割字符串即可。

         假设对于运算符再进行一次约定，例如约定数字0代表+，1代表减，2代表乘，3代表除，整体格式遵循以上第一种格式，则上面的数字生产的协议数据为：

                   “12，432，0”

         这就是一种基本的发送的协议约定了。

         另外一个需要设计的协议格式就是服务器端反馈的数据格式，其实服务器端主要反馈计算结果，但是在实际接受数据时，有可能存在格式错误的情况，这样就需要简单的设计一下服务器端反馈的数据格式了。例如规定，如果发送的数据格式正确，则反馈结果，否则反馈字符串“错误”。这样就有了以下的数据格式：

                   客户端：“1,111,1”         服务器端：”-110”

                   客户端：“123，23，0”    服务器端：“146”

        客户端：“1，2，5”       服务器端：“错误”

         这样就设计出了一种最最基本的网络协议格式，从该示例中可以看出，网络协议就是一种格式上的约定，可以根据逻辑的需要约定出各种数据格式，在进行设计时一般遵循“简单、通用、容易解析”的原则进行。

         而对于复杂的网络程序来说，需要传输的数据种类和数据量都比较大，这样只需要依次设计出每种情况下的数据格式即可，例如QQ程序，在该程序中需要进行传输的网络数据种类很多，那么在设计时就可以遵循：登录格式、注册格式、发送消息格式等等，一一进行设计即可。所以对于复杂的网络程序来说，只是增加了更多的命令格式，在实际设计时的工作量增加不是太大。

         不管怎么说，在网络编程中，对于同一个网络程序来说，一般都会涉及到两个网络协议格式：客户端发送数据格式和服务器端反馈数据格式，在实际设计时，需要一一对应。这就是最基本的网络协议的知识。

         网络协议设计完成以后，在进行网络编程时，就需要根据设计好的协议格式，在程序中进行对应的编码了，客户端程序和服务器端程序需要进行协议处理的代码分别如下。

客户端程序需要完成的处理为：

1、  客户端发送协议格式的生成

2、  服务器端反馈数据格式的解析

服务器端程序需要完成的处理为：

1、  服务器端反馈协议格式的生成

2、  客户端发送协议格式的解析

这里的生成是指将计算好的数据，转换成规定的数据格式，这里的解析指，从反馈的数据格式中拆分出需要的数据。在进行对应的代码编写时，严格遵循协议约定即可。

所以，对于程序员来说，在进行网络程序编写时，需要首先根据逻辑的需要设计网络协议格式，然后遵循协议格式约定进行协议生成和解析代码的编写，最后使用网络编程技术实现整个网络编程的功能。

由于各种网络程序使用不同的协议格式，所以不同网络程序的客户端之间无法通用。

而对于常见协议的格式，例如HTTP(Hyper Text Transfer Protocol，超文本传输协议)、FTP(File Transfer Protocol，文件传输协议)，SMTP(Simple Mail Transfer Protocol，简单邮件传输协议)等等，都有通用的规定，具体可以查阅相关的RFC文档。

最后，对于一种网络程序来说，网络协议格式是该程序最核心的技术秘密，因为一旦协议格式泄漏，则任何一个人都可以根据该格式进行客户端的编写，这样将影响服务器端的实现，也容易出现一些其它的影响。

13.2.6小结

         关于网络编程基本的技术就介绍这么多，该部分介绍了网络编程的基础知识，以及Java语言对于网络编程的支持，网络编程的步骤等，并详细介绍了TCP方式网络编程和UDP方式网络编程在Java语言中的实现。

         网络协议也是网络程序的核心，所以在实际开始进行网络编程时，设计一个良好的协议格式也是必须进行的工作。

本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/Mailbomb/archive/2009/06/16/4274216.aspx

13.3 网络编程示例

         “实践出真知”，所以在进行技术学习时，还是需要进行很多的练习，才可以体会技术的奥妙，下面通过两个简单的示例，演示网络编程的实际使用。

13.3.1质数判别示例

         该示例实现的功能是质数判断，程序实现的功能为客户端程序接收用户输入的数字，然后将用户输入的内容发送给服务器端，服务器端判断客户端发送的数字是否是质数，并将判断的结果反馈给客户端，客户端根据服务器端的反馈显示判断结果。

         质数的规则是：最小的质数是2，只能被1和自身整除的自然数。当用户输入小于2的数字，以及输入的内容不是自然数时，都属于非法输入。

         网络程序的功能都分为客户端程序和服务器端程序实现，下面先描述一下每个程序分别实现的功能：

1、  客户端程序功能：

a)         接收用户控制台输入

b)         判断输入内容是否合法

c)         按照协议格式生成发送数据

d)         发送数据

e)         接收服务器端反馈

f)          解析服务器端反馈信息，并输出

2、  服务器端程序功能：

a)         接收客户端发送数据

b)         按照协议格式解析数据

c)         判断数字是否是质数

d)         根据判断结果，生成协议数据

e)         将数据反馈给客户端

分解好了网络程序的功能以后，就可以设计网络协议格式了，如果该程序的功能比较简单，所以设计出的协议格式也不复杂。

         客户端发送协议格式：

                   将用户输入的数字转换为字符串，再将字符串转换为byte数组即可。

                   例如用户输入16，则转换为字符串“16”，使用getBytes转换为byte数组。

                   客户端发送“quit”字符串代表结束连接

         服务器端发送协议格式：

反馈数据长度为1个字节。数字0代表是质数，1代表不是质数，2代表协议格式错误。

例如客户端发送数字12，则反馈1，发送13则反馈0，发送0则反馈2。

         功能设计完成以后，就可以分别进行客户端和服务器端程序的编写了，在编写完成以后联合起来进行调试即可。

         下面分别以TCP方式和UDP方式实现该程序，注意其实现上的差异。不管使用哪种方式实现，客户端都可以多次输入数据进行判断。对于UDP方式来说，不需要向服务器端发送quit字符串。

         以TCP方式实现的客户端程序代码如下：

                   package example1;

import java.io.*;

import java.net.*;

/**

 * 以TCP方式实现的质数判断客户端程序

 */

public class TCPPrimeClient {

         static BufferedReader br;

         static Socket socket;

         static InputStream is;

         static OutputStream os;

         /**服务器IP*/

         final static String HOST = "127.0.0.1";

         /**服务器端端口*/

         final static int PORT = 10005;

         

         public static void main(String[] args) {

                   init(); //初始化

                   while(true){

                            System.out.println("请输入数字：");

                            String input = readInput(); //读取输入

                            if(isQuit(input)){ //判读是否结束

                                     byte[] b = "quit".getBytes();

                                     send(b);

                                     break; //结束程序

                            }

                            if(checkInput(input)){ //校验合法

                                     //发送数据

                                     send(input.getBytes());

                                     //接收数据

                                     byte[] data = receive();

                                     //解析反馈数据

                                     parse(data);

                            }else{

                                     System.out.println("输入不合法，请重新输入！");

                            }

                   }

                   close();  //关闭流和连接

         }

         

         /**

          * 初始化

          */

         private static void init(){

                   try {

                            br = new BufferedReader(

                                               new InputStreamReader(System.in));

                            socket = new Socket(HOST,PORT);

                            is = socket.getInputStream();

                            os = socket.getOutputStream();

                   } catch (Exception e) {}

         }

         

         /**

          * 读取客户端输入

          */

         private static String readInput(){

                   try {

                            return br.readLine();

                   } catch (Exception e) {

                            return null;

                   }

         }

         

         /**

          * 判断是否输入quit

          * @param input 输入内容

          * @return true代表结束，false代表不结束

          */

         private static boolean isQuit(String input){

                   if(input == null){

                            return false;

                   }else{

                            if("quit".equalsIgnoreCase(input)){

                                     return true;

                            }else{

                                     return false;

                            }

                   }

         }

         

         /**

          * 校验输入

          * @param input 用户输入内容

          * @return true代表输入符合要求，false代表不符合

          */

         private static boolean checkInput(String input){

                   if(input == null){

                            return false;

                   }

                   try{

                            int n = Integer.parseInt(input);

                            if(n >= 2){

                                     return true;

                            }else{

                                     return false;

                            }

                   }catch(Exception e){

                            return false;  //输入不是整数

                   }

         }

         

         /**

          * 向服务器端发送数据

          * @param data 数据内容

          */

         private static void send(byte[] data){

                   try{

                            os.write(data);

                   }catch(Exception e){}

         }

         

         /**

          * 接收服务器端反馈

          * @return 反馈数据

          */

         private static byte[] receive(){

                   byte[] b = new byte[1024];

                   try {

                            int n = is.read(b);

                            byte[] data = new byte[n];

                            //复制有效数据

                            System.arraycopy(b, 0, data, 0, n);

                            return data;

                   } catch (Exception e){}

                   return null;

         }

         

         /**

          * 解析协议数据

          * @param data 协议数据

          */

         private static void parse(byte[] data){

                   if(data == null){

                            System.out.println("服务器端反馈数据不正确！");

                            return;

                   }

                   byte value = data[0]; //取第一个byte

                   //按照协议格式解析

                   switch(value){

                   case 0:

                            System.out.println("质数");

                            break;

                   case 1:

                            System.out.println("不是质数");

                            break;

                   case 2:

                            System.out.println("协议格式错误");

                            break;

                   }

         }

         

         /**

          * 关闭流和连接

          */

         private static void close(){

                   try{

                            br.close();

                            is.close();

                            os.close();

                            socket.close();

                   }catch(Exception e){

                            e.printStackTrace();

                   }

         }

}

         在该代码中，将程序的功能使用方法进行组织，使得结构比较清晰，核心的逻辑流程在main方法中实现。

         以TCP方式实现的服务器端的代码如下：

                   package example1;

import java.net.*;

/**

 * 以TCP方式实现的质数判别服务器端

 */

public class TCPPrimeServer {

         public static void main(String[] args) {

                   final int PORT = 10005;

                   ServerSocket ss  = null;

                   try {

                            ss = new ServerSocket(PORT);

                            System.out.println("服务器端已启动：");

                            while(true){

                                     Socket s = ss.accept();

                                     new PrimeLogicThread(s);

                            }

                   } catch (Exception e) {}

                   finally{

                            try {

                                     ss.close();

                            } catch (Exception e2) {}

                   }

                   

         }

}

package example1;

import java.io.*;

import java.net.*;

/**

 * 实现质数判别逻辑的线程

 */

public class PrimeLogicThread extends Thread {

         Socket socket;

         InputStream is;

         OutputStream os;

         

         public PrimeLogicThread(Socket socket){

                   this.socket = socket;

                   init();

                   start();

         }

         /**

          * 初始化

          */

         private void init(){

                   try{

                            is = socket.getInputStream();

                            os = socket.getOutputStream();

                   }catch(Exception e){}

         }

         

         public void run(){

                   while(true){

                            //接收客户端反馈

                            byte[] data = receive();

                            //判断是否是退出

                            if(isQuit(data)){

                                     break;  //结束循环

                            }

                            //逻辑处理

                            byte[] b = logic(data);

                            //反馈数据

                            send(b);

                   }

                   close();

         }

         

         /**

          * 接收客户端数据

          * @return 客户端发送的数据

          */

         private  byte[] receive(){

                   byte[] b = new byte[1024];

                   try {

                            int n = is.read(b);

                            byte[] data = new byte[n];

                            //复制有效数据

                            System.arraycopy(b, 0, data, 0, n);

                            return data;

                   } catch (Exception e){}

                   return null;

         }

         

         /**

          * 向客户端发送数据

          * @param data 数据内容

          */

         private void send(byte[] data){

                   try{

                            os.write(data);

                   }catch(Exception e){}

         }

         

         /**

          * 判断是否是quit

          * @return 是返回true，否则返回false

          */

         private boolean isQuit(byte[] data){

                   if(data == null){

                            return false;

                   }else{

                            String s = new String(data);

                            if(s.equalsIgnoreCase("quit")){

                                     return true;

                            }else{

                                     return false;

                            }

                   }

         }

         

         private byte[] logic(byte[] data){

                   //反馈数组

                   byte[] b = new byte[1];

                   //校验参数

                   if(data == null){

                            b[0] = 2;

                            return b;

                   }

                   try{

                            //转换为数字

                            String s = new String(data);

                            int n = Integer.parseInt(s);

                            //判断是否是质数

                            if(n >= 2){

                                     boolean flag = isPrime(n);

                                     if(flag){

                                               b[0] = 0;

                                     }else{

                                               b[0] = 1;

                                     }

                            }else{

                                     b[0] = 2;  //格式错误

                                     System.out.println(n);

                            }

                   }catch(Exception e){

                            e.printStackTrace();

                            b[0] = 2;

                   }

                   return b;

         }

         

         /**

          * 

          * @param n

          * @return

          */

         private boolean isPrime(int n){

                   boolean b = true;

                   for(int i = 2;i <= Math.sqrt(n);i++){

                            if(n % i == 0){

                                     b = false;

                                     break;

                            }

                   }

                   return b;

         }

         

         /**

          * 关闭连接

          */

         private void close(){

                   try {

                            is.close();

                            os.close();

                            socket.close();

                   } catch (Exception e){}

         }

}

         本示例使用的服务器端的结构和前面示例中的结构一致，只是逻辑线程的实现相对来说要复杂一些，在线程类中的logic方法中实现了服务器端逻辑，根据客户端发送过来的数据，判断是否是质数，然后根据判断结果按照协议格式要求，生成客户端反馈数据，实现服务器端要求的功能

本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/Mailbomb/archive/2009/06/17/4277293.aspx

13.3.2 猜数字小游戏

         下面这个示例是一个猜数字的控制台小游戏。该游戏的规则是：当客户端第一次连接到服务器端时，服务器端生产一个【0，50】之间的随机数字，然后客户端输入数字来猜该数字，每次客户端输入数字以后，发送给服务器端，服务器端判断该客户端发送的数字和随机数字的关系，并反馈比较结果，客户端总共有5次猜的机会，猜中时提示猜中，当输入”quit”时结束程序。

         和前面的示例类似，在进行网络程序开发时，首先需要分解一下功能的实现，觉得功能是在客户端程序中实现还是在服务器端程序中实现。区分的规则一般是：客户端程序实现接收用户输入等界面功能，并实现一些基础的校验降低服务器端的压力，而将程序核心的逻辑以及数据存储等功能放在服务器端进行实现。遵循该原则划分的客户端和服务器端功能如下所示。

         客户端程序功能列表：

1、  接收用户控制台输入

2、  判断输入内容是否合法

3、  按照协议格式发送数据

4、  根据服务器端的反馈给出相应提示

         服务器端程序功能列表：

1、  接收客户端发送数据

2、  按照协议格式解析数据

3、  判断发送过来的数字和随机数字的关系

4、  根据判断结果生产协议数据

5、  将生产的数据反馈给客户端

         在该示例中，实际使用的网络命令也只有两条，所以显得协议的格式比较简单。

         其中客户端程序协议格式如下：

1、  将用户输入的数字转换为字符串，然后转换为byte数组

2、  发送“quit”字符串代表退出

         其中服务器端程序协议格式如下：

1、  反馈长度为1个字节，数字0代表相等(猜中)，1代表大了，2代表小了，其它数字代表错误。

         实现该程序的代码比较多，下面分为客户端程序实现和服务器端程序实现分别进行列举。

         客户端程序实现代码如下：

                 package guess;

import java.net.*;

import java.io.*;

/**

 * 猜数字客户端

 */

public class TCPClient {

  public static void main(String[] args) {

         Socket socket = null;

         OutputStream os = null;

         InputStream is = null;

         BufferedReader br = null;

         byte[] data = new byte[2];

         try{

                   //建立连接

                   socket = new Socket(

                                     "127.0.0.1",10001);

                   

                   //发送数据

                   os= socket.getOutputStream();

                   

                   //读取反馈数据

                   is = socket.getInputStream();

                   

                   //键盘输入流

                   br = new BufferedReader(

                                     new InputStreamReader(System.in));

                   

                   //多次输入

                   while(true){

                            System.out.println("请输入数字：");

                            //接收输入

                            String s = br.readLine();

                            //结束条件

                            if(s.equals("quit")){

                                     os.write("quit".getBytes());

                                     break;

                            }

                            //校验输入是否合法

                            boolean b = true;

                            try{

                                     Integer.parseInt(s);

                            }catch(Exception e){

                                     b = false;

                            }

                            if(b){ //输入合法

                                     //发送数据

                                     os.write(s.getBytes());

                                     //接收反馈

                                     is.read(data);

                                     //判断

                                     switch(data[0]){

                                     case 0:

                                               System.out.println("相等！祝贺你！");

                                               break;

                                     case 1:

                                               System.out.println("大了！");

                                               break;

                                     case 2:

                                               System.out.println("小了！");

                                               break;

                                     default:

                                               System.out.println("其它错误！");

                                     }

                                     //提示猜的次数

                                     System.out.println("你已经猜了" + data[1] + "次！");

                                     //判断次数是否达到5次

                                     if(data[1] >= 5){

                                               System.out.println("你挂了！");

                                               //给服务器端线程关闭的机会

                                               os.write("quit".getBytes());

                                               //结束客户端程序

                                               break;

                                     }

                            }else{  //输入错误

                                     System.out.println("输入错误！");

                            }

                   }

         }catch(Exception e){

                   e.printStackTrace();

         }finally{

                   try{

                            //关闭连接

                            br.close();

                            is.close();

                            os.close();

                            socket.close();

                   }catch(Exception e){

                            e.printStackTrace();

                   }

         }

  }

      }

   在该示例中，首先建立一个到IP地址为127.0.0.1的端口为10001的连接，然后进行各个流的初始化工作，将逻辑控制的代码放入在一个while循环中，这样可以在客户端多次进行输入。在循环内部，首先判断用户输入的是否为quit字符串，如果是则结束程序，如果输入不是quit，则首先校验输入的是否是数字，如果不是数字则直接输出“输入错误！”并继续接收用户输入，如果是数字则发送给服务器端，并根据服务器端的反馈显示相应的提示信息。最后关闭流和连接，结束客户端程序。

         服务器端程序的实现还是分为服务器控制程序和逻辑线程，实现的代码分别如下：

                 package guess;

import java.net.*;

/**

 * TCP连接方式的服务器端

 * 实现功能：接收客户端的数据，判断数字关系

 */

public class TCPServer {

  public static void main(String[] args) {

         try{

                   //监听端口

                   ServerSocket ss = new ServerSocket(10001);

                   System.out.println("服务器已启动：");

                   //逻辑处理

                   while(true){

                            //获得连接

                            Socket s = ss.accept(); 

                            //启动线程处理

                            new LogicThread(s);

                   }

                   

         }catch(Exception e){

                   e.printStackTrace();

         }

  }

      }

      package guess;

import java.net.*;

import java.io.*;

import java.util.*;

/**

 * 逻辑处理线程

 */

public class LogicThread extends Thread {

      Socket s;

      

      static Random r = new Random();

      

      public LogicThread(Socket s){

              this.s = s;

              start();  //启动线程

      }

      

      public void run(){ 

              //生成一个[0，50]的随机数

              int randomNumber = Math.abs(r.nextInt() % 51);

              //用户猜的次数

              int guessNumber = 0;

              InputStream is = null;

              OutputStream os = null;

              byte[] data = new byte[2];

              try{

                       //获得输入流

                       is = s.getInputStream();

                       //获得输出流

                       os = s.getOutputStream();

                       while(true){  //多次处理

                                 //读取客户端发送的数据

                                 byte[] b = new byte[1024];

                                 int n = is.read(b);

                                 String send = new String(b,0,n);

                                 //结束判别

                                 if(send.equals("quit")){

                                          break;

                                 }

                                 //解析、判断

                                 try{

                                          int num = Integer.parseInt(send);

                                          //处理

                                          guessNumber++; //猜的次数增加1

                                          data[1] = (byte)guessNumber;

                                          //判断

                                          if(num > randomNumber){

                                                   data[0] = 1;

                                          }else if(num < randomNumber){

                                                   data[0] = 2;

                                          }else{

                                                   data[0] = 0;

                                                   //如果猜对

                                                   guessNumber = 0; //清零

                                                   randomNumber = Math.abs(r.nextInt() % 51);

                                          }

                                          //反馈给客户端

                                          os.write(data);                                     

                                          

                                 }catch(Exception e){ //数据格式错误

                                          data[0] = 3;

                                          data[1] = (byte)guessNumber;

                                          os.write(data);  //发送错误标识

                                          break;

                                 }

                                 os.flush();   //强制发送

                       }

                       

              }catch(Exception e){

                       e.printStackTrace();

              }finally{

                       try{

                                 is.close();

                                 os.close();

                                 s.close();

                       }catch(Exception e){}

              }

      }

}

在该示例中，服务器端控制部分和前面的示例中一样。也是等待客户端连接，如果有客户端连接到达时，则启动新的线程去处理客户端连接。在逻辑线程中实现程序的核心逻辑，首先当线程执行时生产一个随机数字，然后根据客户端发送过来的数据，判断客户端发送数字和随机数字的关系，然后反馈相应的数字的值，并记忆客户端已经猜过的次数，当客户端猜中以后清零猜过的次数，使得客户端程序可以继续进行游戏。

总体来说，该程序示例的结构以及功能都与上一个程序比较类似，希望通过比较这两个程序，加深对于网络编程的认识，早日步入网络编程的大门。

本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/Mailbomb/archive/2009/06/24/4293752.aspx

13.4 中文问题

         网络传输过程中的中文问题也比较突出，出现该问题的原因和前面IO部分介绍的一致，都是由于传输过程中客户端程序和服务器端程序采用的字符集不一致，在解决该问题以前首先进行如下的思考：

                   是否在网络中一定要传输中文字符？

         从前面的示例中可以看出，通过一定的协议格式设计，可以避免在网络中传输中文字符，这样就从基础上避免了中文问题的出现。例如在程序中需要传输“成功”、“失败”这样的中文字符串，在协议中可以约定数字0代表“成功”、1代表“失败”，这样在网络上传输数字即可，在客户端和服务器端进行简单的变换即可。

         其实这也是设计网络协议时基本的设计技巧，通过合理的使用该技巧既可以减少网络传输的数据量，也可以从根本上避免网络传输过程中的中文问题。

         如果必须在网络中传输中文字符，例如QQ中的聊天信息，这就需要使客户端程序使用的字符集编码和服务器端程序使用的字符集编码保持一致，这是中文问题解决的最基本的思路实现。

13.5 总结

         关于Java语言的网络编程，本章介绍了网络编程的相关基础知识，介绍了Java语言中如何进行TCP和UDP格式的网络编程，并通过简单的示例演示网络编程的基本使用，通过这些内容的介绍将大家带入网络编程的大门，当然需要完全掌握网络编程，还需要进行很多艰苦卓越的工作，如果阅读本章内容比较轻松，还需要对于网络编程进行进阶的话，建议阅读《Java 2网络协议内幕》一书。

13.6 网络练习

         1、分别使用TCP方式和UDP方式，实现将客户端输入的阿拉伯数字转换为中文大写数字。

2、分别使用TCP方式和UDP方式，实现本章中介绍的计算器示例，体会客户端和服务器端的功能划分以及框架实现。

3、设计一个简单的程序，实现向服务器端上传文件，并实现文件在服务器端的存储。

4、阅读P2P网络的相关知识，实现一个P2P的聊天程序