小测试代码，目的是发送端从键盘中，输入字符。接收端接到字符后转成大写。当发送端发"over"时，接受端接到打开并结束，关闭流掉。
但测试代码存在问题，while循环停不了。下面是代码：
代码一： while循环用 类静态变量FLAG控制：

1. import java.net.*;
   
2. import java.io.*;
   
3. import java.util.Date;
   
4. public class UdpSocketTest{
   
5. public static boolean FLAG = true ;
   
6. public static void main(String[] args){
   
7. 
   
8. }
   
9. }
   
10. 
    
11. class SerSocket{
    
12. public static void main(String[] args) throws Exception{
    
13. DatagramSocket ds = new DatagramSocket(40009);
    
14. while(UdpSocketTest.FLAG)
    
15. {
    
16. byte[] buf = new byte[1024];
    
17. DatagramPacket dp = new DatagramPacket(buf,buf.length);
    
18. ds.receive(dp);
    
19. InetAddress ia = dp.getAddress();
    
20. String ip = ia.getHostAddress();
    
21. System.out.println(ip+"..... connected");
    
22. String content = new String(dp.getData(),0,dp.getLength());
    
23. content = content.toUpperCase();
    
24. System.out.println("content=="+content);
    
25. Thread.sleep(5000); //先暂停5秒，等if over先执行，置FLAG为false
    
26. Date d = new Date();
    
27. System.out.println(d.toString()+"Ser执行UdpSocketTest.FLAG==::"+UdpSocketTest.FLAG);
    
28. }
    
29. ds.close();
    
30. }
    
31. 
    
32. }
    
33. 
    
34. class CliSocket{
    
35. 
    
36. public static void main(String[] args) throws Exception{
    
37. 
    
38. DatagramSocket ds = new DatagramSocket();
    
39. InetAddress ia = InetAddress.getByName("127.0.0.1");
    
40. BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    
41. String line = null;
    
42. while((line=br.readLine())!=null){
    
43. byte[] buf = line.getBytes();
    
44. DatagramPacket dp = new DatagramPacket(buf,buf.length,ia,40009);
    
45. ds.send(dp);
    
46. if("over".equals(line))
    
47. {
    
48. UdpSocketTest.FLAG = false;
    
49. Date d = new Date();
    
50. System.out.println(d.toString()+"Cli执行UdpSocketTest.FLAG==::"+UdpSocketTest.FLAG);
    
51. break ;
    
52. }
    
53. }
    
54. ds.close();
    
55. br.close();
    
56. 
    
57. }
    
58. }

复制代码

代码二： while循环用 单例 Flag成员变量  控制：

1. import java.net.*;
   
2. import java.io.*;
   
3. import java.util.Date;
   
4. public class UdpSocketTest2{
   
5. //public static boolean FLAG = true ;
   
6. private static final UdpSocketTest2 ut = new UdpSocketTest2(); //郁闷，换成单例类，还是一样存在问题。
   
7. private boolean flag = true ;
   
8. private UdpSocketTest2(){
   
9. }
   
10. public static UdpSocketTest2 getInstance(){
    
11. return ut ;
    
12. }
    
13. public void setFlag(boolean flag){
    
14. this.flag = flag;
    
15. }
    
16. public boolean getFlag(){
    
17. return flag ;
    
18. }
    
19. 
    
20. public static void main(String[] args){
    
21. 
    
22. }
    
23. }
    
24. 
    
25. class SerSocket{
    
26. public static void main(String[] args) throws Exception{
    
27. DatagramSocket ds = new DatagramSocket(40009);
    
28. UdpSocketTest2 ut = UdpSocketTest2.getInstance();
    
29. while(ut.getFlag())
    
30. {
    
31. byte[] buf = new byte[1024];
    
32. DatagramPacket dp = new DatagramPacket(buf,buf.length);
    
33. ds.receive(dp);
    
34. InetAddress ia = dp.getAddress();
    
35. String ip = ia.getHostAddress();
    
36. System.out.println(ip+"..... connected");
    
37. String content = new String(dp.getData(),0,dp.getLength());
    
38. content = content.toUpperCase();
    
39. System.out.println("content=="+content);
    
40. Thread.sleep(5000); //先暂停5秒，等if over先执行，置FLAG为false
    
41. Date d = new Date();
    
42. System.out.println(d.toString()+"Ser 执行ut.getFlag()==::"+ut.getFlag());
    
43. }
    
44. ds.close();
    
45. }
    
46. 
    
47. }
    
48. 
    
49. class CliSocket{
    
50. 
    
51. public static void main(String[] args) throws Exception{
    
52. UdpSocketTest2 ut = UdpSocketTest2.getInstance();
    
53. DatagramSocket ds = new DatagramSocket();
    
54. InetAddress ia = InetAddress.getByName("127.0.0.1");
    
55. BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    
56. String line = null;
    
57. while((line=br.readLine())!=null){
    
58. byte[] buf = line.getBytes();
    
59. DatagramPacket dp = new DatagramPacket(buf,buf.length,ia,40009);
    
60. ds.send(dp);
    
61. if("over".equals(line))
    
62. {
    
63. ut.setFlag(false);
    
64. Date d = new Date();
    
65. System.out.println(d.toString()+"Cli 执行ut.getFlag()==::"+ut.getFlag());
    
66. break ;
    
67. }
    
68. }
    
69. ds.close();
    
70. br.close();
    
71. 
    
72. }
    
73. }

复制代码

Why？为什么循环停不了，测试结果如图：



图上，显示证明了，FLAG已经被置为flase了，为什么5秒后打印却是true呢？
用单例模式也是一样的，求解?
----
ps: 不要说在接收端也弄个over的判断，再break循环。 我就想知道，为什么以上两种方式的while循环结束不了，为什么5秒前FLAG为false，5秒后为true了。

------------
问题解决，结贴。

//楼主，这两段代码我都给你修改了一下，你看我的注释吧。。。。。。。。。。
//发送代码，这个发送代码你写一个类，类名叫CliSocket
import java.net.*;
import java.io.*;
import java.util.Date;
//这里去掉public，去掉类中的main方法，
class UdpSocketTest{
public static boolean FLAG = true ;

}
//这里加上public这个为主类，。。。。。。。。。。。注意这时这个flag为true,
public class CliSocket{

public static void main(String[] args) throws Exception{

DatagramSocket ds = new DatagramSocket();
InetAddress ia = InetAddress.getByName("127.0.0.1");
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
String line = null;
while((line=br.readLine())!=null){
byte[] buf = line.getBytes();
DatagramPacket dp = new DatagramPacket(buf,buf.length,ia,40009);
ds.send(dp);
//这里直到你输入一个over字符串才把flag赋值成false,但是一定注意这里是发送类中的flag，与另一个类SerSocket中的flag毫无关系和联系
if("over".equals(line))
{
UdpSocketTest.FLAG = false;
Date d = new Date();
System.out.println(d.toString()+"Cli执行UdpSocketTest.FLAG==::"+UdpSocketTest.FLAG);
break ;
}
}
ds.close();
br.close();

}
}




//接受代码写成一个类，类名称叫SerSocket

import java.net.*;
import java.io.*;
import java.util.Date;
//这里去掉public，去掉类中的main方法，

class UdpSocketTest{
public static boolean FLAG = true ;

}
//这里加上public这个为主类，注意这时这个flag为true,你这里之所以一直循环，就是因为这个flag一直为true,你并没有在这个SerSocket中赋值，我给你加了一些代码，你看

public class SerSocket{
public static void main(String[] args) throws Exception{
DatagramSocket ds = new DatagramSocket(40009);
while(UdpSocketTest.FLAG)
{
byte[] buf = new byte[1024];
DatagramPacket dp = new DatagramPacket(buf,buf.length);
ds.receive(dp);
InetAddress ia = dp.getAddress();
String ip = ia.getHostAddress();
System.out.println(ip+"..... connected");
String content = new String(dp.getData(),0,dp.getLength());
content = content.toUpperCase();

//这是我给你添加的代码你看看。。。。。。。。。。。。。。。。。。。
if("over".equals(content) || "OVER".equals(content)){
UdpSocketTest.FLAG = false;
}

System.out.println("content=="+content);
Thread.sleep(5000); //先暂停5秒，等if over先执行，置FLAG为false
Date d = new Date();
System.out.println(d.toString()+"Ser执行UdpSocketTest.FLAG==::"+UdpSocketTest.FLAG);
}
ds.close();
}

}

{:soso_e100:}，我已经帮你解决了，给我点分数啊，怎么样，我正在上班，抽时间给你看的，你满意吗？补充，一个类叫CliSocket.java,一个叫SerSocket.java
{:soso_e181:}

龙卷风V龙卷风 发表于 2012-8-1 15:19
，我已经帮你解决了，给我点分数啊，怎么样，我正在上班，抽时间给你看的，你满意吗？补充， ...

ps: 不要说在接收端也弄个over的判断，再break循环。 我就想知道，为什么以上两种方式的while循环结束不了，为什么5秒前FLAG为false，5秒后为true了

抱歉，给不了你。你的说法，我不太认可。我并不想在接收端，弄个over这样的判断。再来结束掉while循环。
这题目，我自己已经解决了。

原因：接收端与发送端都是main函数，我启动了两个命令窗口两个java，即产生了两个JVM。
两个JVM之间，数据并不是共享的。两个JVM中 UdpSocketTest.FLAG都是独立的。

在接收端main中，我并没有改变UdpSocketTest.FLAG的值，所以无论在发送端做何动作，不修改接收端代码。UdpSocketTest.FLAG永远不可以为false。
所以与UDP发包接包，根本没有关系的。
至少目前我的电脑配置及环境搭配，还不支持 云服务或集群服务。
为了证明，以上说明。特此发个简单测试代码:

import java.util.Date;
class DataTest{
        public static int d1 = 1;

}


class JVM2{
        public static void main(String[] args) throws Exception{
               
                DataTest.d1 = 2 + DataTest.d1;
                System.out.println("JVM2停止5秒再打印 DataTest.d1="+DataTest.d1);
                Thread.sleep(5000);
                Date d = new Date();
                System.out.println(d+"  JVM2-------::"+DataTest.d1);
        }

}

class JVM1{

        public static void main(String[] args){
                DataTest.d1 = 3 + DataTest.d1;
                Date d = new Date();
                System.out.println(d+"  JVM1-------::"+DataTest.d1);
        }
}

--------
先运行 JVM2，d1值为3，此时立马运行JVM1，d1的值，不为因为JVM2中值为3了，再加3.而是4.


OVER,结题。
呵呵，自己动手解决，丰衣足食。:D