/*
* 编写一个聊天程序，接收数据2部分
*  这两部分需要同时执行，so多线程
*          因为收和发动作是不一致的，所以要定义2个run方法
*          而且这两个方法要封装到不同的类中        
*
*
* */
package netText;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.net.SocketException;
import java.net.UnknownHostException;

public class UdpTxet {
        public static void main(String[] args) throws SocketException{
                DatagramSocket sendSocket = new DatagramSocket();
                DatagramSocket receSocket = new DatagramSocket(10009);
               
                new Thread(new UdpSend(sendSocket)).start();
                new Thread(new UdpRece(receSocket)).start();
        }
}
//发送键盘录入的类
class UdpSend implements Runnable {
        private DatagramSocket ds;
        public UdpSend(DatagramSocket ds){
                this.ds = ds;
        }
        public void run(){
                try {
                        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
                        //键盘录入数据，并封装成数据包
                        String line = null;
                        while((line=br.readLine())!=null){
                                if("886".equals(line))
                                        break;
                                byte[] data = line.getBytes();
                                DatagramPacket dp = new DatagramPacket(data,data.length,
                                                        InetAddress.getByName("111.201.122.45"),10009);
                //通过Socket服务，将已有的数据包发送出去
                                ds.send(dp);
                        }
                                ds.close();
                } catch (UnknownHostException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                } catch (IOException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                }
        }
}
//接收数据的类
class UdpRece implements Runnable {
        private DatagramSocket ds;
        public UdpRece(DatagramSocket ds){
                this.ds = ds;
        }
        public void run(){
                try{
                        while(true){
                                //定义数据包，用于存储数据
                                byte[] buf = new byte[1024];
                                DatagramPacket dp = new DatagramPacket(buf,buf.length);
                                //通过receive方法将收到的数据存入数据包中
                                ds.receive(dp);
                                //通过数据包的方法获取其中的数据
                                String ip = dp.getAddress().getHostAddress();
                                String data = new String(dp.getData(),0,dp.getLength());
                                System.out.println("Ip = "+ip+" "+data);
                        }
                }
                catch(Exception e){
                        throw new RuntimeException("接收数据失败");
                }               
        }
}
我用MyEclipse写的  为什么运行结果一直是在控制台录入数据啊，输入886也一样。
输出ip+data都没有

886只是关闭了你的键盘录入  没有关闭下面的接收端  所以程序会一直运行 处于接受状态  我的能输出结果 不知道你的为什么

玥夜 发表于 2014-8-17 17:34
886只是关闭了你的键盘录入  没有关闭下面的接收端  所以程序会一直运行 处于接受状态  我的能输出结果 不 ...

我用的是MyEclipse， 程序运行了就只有下面一个控制台啊，只能进行键盘录入，其他什么都看不到啊。求大神指导

1. package com.itheima;
   
2. 
   
3. /*
   
4. * 编写一个聊天程序，接收数据2部分
   
5. *  这两部分需要同时执行，so多线程
   
6. *          因为收和发动作是不一致的，所以要定义2个run方法
   
7. *          而且这两个方法要封装到不同的类中        
   
8. *
   
9. *
   
10. * */
    
11. 
    
12. import java.io.BufferedReader;
    
13. import java.io.IOException;
    
14. import java.io.InputStreamReader;
    
15. import java.net.DatagramPacket;
    
16. import java.net.DatagramSocket;
    
17. import java.net.InetAddress;
    
18. import java.net.SocketException;
    
19. import java.net.UnknownHostException;
    
20. 
    
21. public class UdpTxet {
    
22.          public static void main(String[] args) throws SocketException{
    
23.                  DatagramSocket sendSocket = new DatagramSocket();
    
24.                  DatagramSocket receSocket = new DatagramSocket(10009);
    
25.                  
    
26.                  new Thread(new UdpSend(sendSocket)).start();
    
27.                  new Thread(new UdpRece(receSocket)).start();
    
28.          }
    
29. }
    
30. 
    
31. class UdpSend implements Runnable {
    
32.          private DatagramSocket ds;
    
33.          public UdpSend(DatagramSocket ds){
    
34.                  this.ds = ds;
    
35.          }
    
36.          public void run(){
    
37.                  try {
    
38.                          BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    
39. 
    
40.                         String line = null;
    
41.                          while((line=br.readLine())!=null){
    
42.                                  if("886".equals(line))//将判断语句也发过去，当接收端接受到就跳出while循环，
    
43.                                  {
    
44.                                          byte[] data = line.getBytes();
    
45.                                          DatagramPacket dp = new DatagramPacket(data,data.length,
    
46.                                                          InetAddress.getByName("127.0.0.1"),10009);
    
47.                                          ds.send(dp);
    
48.                                           break;
    
49.                                  }
    
50.                                
    
51.                                          
    
52.                                          byte[] data = line.getBytes();
    
53.                                          DatagramPacket dp = new DatagramPacket(data,data.length,
    
54.                                                          InetAddress.getByName("127.0.0.1"),10009);
    
55.                                 ds.send(dp);
    
56.                                        
    
57.                                  
    
58.                          }
    
59.                          ds.close();
    
60.                  } catch (UnknownHostException e) {
    
61.                          e.printStackTrace();
    
62.                  } catch (IOException e) {
    
63.                          e.printStackTrace();
    
64.                  }
    
65.          }
    
66. }
    
67. class UdpRece implements Runnable {
    
68.          private DatagramSocket ds;
    
69.          public UdpRece(DatagramSocket ds){
    
70.                  this.ds = ds;
    
71.          }
    
72.          public void run(){
    
73.                  try{
    
74.                          while(true){
    
75.                                 byte[] buf = new byte[1024];
    
76.                                  DatagramPacket dp = new DatagramPacket(buf,buf.length);
    
77.                                 ds.receive(dp);
    
78.                                 String ip = dp.getAddress().getHostAddress();
    
79.                                  String data = new String(dp.getData(),0,dp.getLength());
    
80.                                  System.out.println("Ip = "+ip+" "+data);
    
81.                                  if("886".equals(data))//加入判断语句，跳出循环
    
82.                                          break ;//
    
83.                          }
    
84.                  }
    
85.                  catch(Exception e){
    
86.                          throw new RuntimeException("接收数据失败");
    
87.                  }   
    
88.                  ds.close();
    
89.          }
    
90. }

复制代码

群里面已经给你发了解决方法

“886”结束的是发送端的线程，接收端还在挂起，没有显示输出是没收到数据，看看IP地址是否正确！！！