1. import java.net.*;
   
2. import java.io.*;
   
3. class Send implements Runnable
   
4. {
   
5.         private DatagramSocket ds;
   
6.         public Send(DatagramSocket ds)
   
7.         {
   
8.                 this.ds=ds;
   
9.         }
   
10.         public void run()
    
11.         {
    
12.                 try
    
13.                 {
    
14.                         BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    
15.                         String line;
    
16.                         while ((line=br.readLine())!=null)
    
17.                         {
    
18.                                 if ("886".equals(line))
    
19.                                         break;
    
20.                                 byte[] buf=line.getBytes();
    
21.                                 DatagramPacket dp=new DatagramPacket(buf,buf.length,InetAddress.getByName("127.0.0.1"),10003);
    
22.                                 ds.send(dp);
    
23.                         }
    
24.                         ds.close();
    
25.                 }
    
26.                 catch (Exception e)
    
27.                 {
    
28.                         throw new RuntimeException("发送失败");
    
29.                 }
    
30.                
    
31.         }
    
32. }
    
33. 
    
34. class Rece implements Runnable
    
35. {
    
36.         private DatagramSocket ds;
    
37.         public Rece(DatagramSocket ds)
    
38.         {
    
39.                 this.ds=ds;
    
40.         }
    
41.         public void run()
    
42.         {
    
43.                 try
    
44.                 {
    
45.                         byte [] buf=new byte[1024];
    
46.                 DatagramPacket dp=new DatagramPacket(buf,buf.length);
    
47.                 while (true)
    
48.                 {
    
49.                         ds.receive(dp);
    
50.                         String res=new String(buf,0,dp.getLength());
    
51.                         System.out.println(res);
    
52.                 }
    
53.                 }
    
54.                 catch (Exception e)
    
55.                 {
    
56.                         throw new RuntimeException("接收失败");
    
57.                 }
    
58.         }
    
59. }
    
60. class UdpClint2
    
61. {
    
62.         public static void main(String[] args) throws Exception
    
63.         {
    
64.                 new Thread(new Send(new DatagramSocket())).start();
    
65.             new Thread(new Send(new DatagramSocket(10001))).start();
    
66.         }
    
67. }
    
68. 
    
69. 
    
70. 
    
71. import java.net.*;
    
72. import java.io.*;
    
73. class Send implements Runnable
    
74. {
    
75.         private DatagramSocket ds;
    
76.         public Send(DatagramSocket ds)
    
77.         {
    
78.                 this.ds=ds;
    
79.         }
    
80.         public void run()
    
81.         {
    
82.                 try
    
83.                 {
    
84.                         BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    
85.                         String line;
    
86.                         while ((line=br.readLine())!=null)
    
87.                         {
    
88.                                 if ("exit".equals(line))
    
89.                                         break;
    
90.                                 byte[] buf=line.getBytes();
    
91.                                 DatagramPacket dp=new DatagramPacket(buf,buf.length,InetAddress.getByName("127.0.0.1"),10001);
    
92.                                 ds.send(dp);
    
93.                         }
    
94.                         ds.close();
    
95.                 }
    
96.                 catch (Exception e)
    
97.                 {
    
98.                         throw new RuntimeException("发送失败");
    
99.                 }
    
100.                
     
101.         }
     
102. }
     
103. 
     
104. class Rece implements Runnable
     
105. {
     
106.         private DatagramSocket ds;
     
107.         public Rece(DatagramSocket ds)
     
108.         {
     
109.                 this.ds=ds;
     
110.         }
     
111.         public void run()
     
112.         {
     
113.                 try
     
114.                 {
     
115.                         byte [] buf=new byte[1024];
     
116.                         DatagramPacket dp=new DatagramPacket(buf,buf.length);
     
117.                         while (true)
     
118.                         {
     
119.                                 String ip=dp.getAddress().getHostAddress();
     
120.                                 ds.receive(dp);
     
121.                                 System.out.println(ip+"::"+new String(buf,0,dp.getLength()));
     
122.                         }
     
123.                 }
     
124.                 catch (Exception e)
     
125.                 {
     
126.                         throw new RuntimeException("接收失败");
     
127.                 }
     
128.         }
     
129. }
     
130. class UdpClint
     
131. {
     
132.         public static void main(String[] args) throws Exception
     
133.         {
     
134.                 new Thread(new Send(new DatagramSocket())).start();
     
135.             new Thread(new Send(new DatagramSocket(10003))).start();
     
136.         }
     
137. }
     
138. 
     
139. 
     
140. 
     

复制代码

为什么两个控制台不能互相通信呢？？？？

楼主,你好像在mian函数里面new的都是send哎...没有receive有木有?
  new Thread(new Send(new DatagramSocket())).start();
  new Thread(new Send(new DatagramSocket(10003))).start();

程序好乱，目测你出现了两个端口号，10001和10003，一个连接通常只需要指定一个端口号就行了，发送端可以让系统自动分配端口号，检查一下吧。

最好把你的代码加上注释，这样自己以后再看的时候也不用全部看一遍，减少阅读时间，而且对别人也是一种很清晰的阐述。谢谢

VOIDMAIN 发表于 2013-3-21 00:30
程序好乱，目测你出现了两个端口号，10001和10003，一个连接通常只需要指定一个端口号就行了，发送端可以让 ...

我两个端口号分别是给两个receive设的监听端口，我是想让两个窗口同时既能够发送又能够接收

黄玉昆 发表于 2013-3-21 10:33
最好把你的代码加上注释，这样自己以后再看的时候也不用全部看一遍，减少阅读时间，而且对别人也是一种很清 ...

嗯嗯，这个坏习惯得好好改改，谢谢提醒