import java.io.*;
import java.net.*;
class  Testg
{
        public static void main(String[] args) throws Exception
        {
                DatagramSocket dt=new DatagramSocket();
                DatagramSocket dgt=new DatagramSocket(10002);
                new Thread(new Send(dt)).start();
                new Thread(new Receive(dgt)).start();
        }
}
class  Send implements Runnable
{
        private DatagramSocket dt;
        public  Send(DatagramSocket dt)
        {
                this.dt=dt;
        }
       
        public void run()
        {
                try{
                BufferedReader bfr=new BufferedReader(new InputStreamReader(System.in));
                String line=null;
                while ((line=bfr.readLine())!=null)

                {   
            if (line.equals("baibai"))//结束标记。为什么输入结束标记不能结束，而且不能再进行键盘录入
                   {
                           break;
                   }
                        byte[] by=line.getBytes();       
               
                   DatagramPacket dst=new DatagramPacket(by,by.length,InetAddress.getByName("192.168.0.156"),10002);
                   dt.send(dst);
                  
            }
                dt.close();
                //bfr.close();
        }
       
        catch(Exception e)
        {
                throw new RuntimeException("fasongshibai");
        }
        }
}
class Receive implements Runnable
{
        private DatagramSocket dt;
        public  Receive(DatagramSocket dt)
        {
                this.dt=dt;
        }
       
        public void run()
        {
                try{
    while(true)
                {
        byte [] by=new byte [1024];
        DatagramPacket dpt=new DatagramPacket(by,by.length);
        dt.receive(dpt);
        System.out.println(new String (dpt.getData(),0,dpt.getLength()));
            }
        //dt.close();
        }

        catch(Exception e)
        {
                throw new RuntimeException("jieshoushibai");
        }
        }
}

你同时开启了发送端和接收端两个线程，输入结束标记"baibai"后，只是结束了发送端线程，接收端线程还在运行状态，在等接收数据，程序还没结束。当然，发送端都关闭了，肯定就不能在控制台输入并发送数据。下面代码改了两个地方，就可以做到你要的效果了。

1. import java.io.*;
   
2. import java.net.*;
   
3. class  Testg
   
4. {
   
5.         public static void main(String[] args) throws Exception
   
6.         {
   
7.                 DatagramSocket dt=new DatagramSocket();
   
8.                 DatagramSocket dgt=new DatagramSocket(10002);
   
9.                 new Thread(new Send(dt)).start();
   
10.                 new Thread(new Receive(dgt)).start();
    
11.         }
    
12. }
    
13. class  Send implements Runnable
    
14. {
    
15.         private DatagramSocket dt;
    
16.         public  Send(DatagramSocket dt){
    
17.                 this.dt=dt;
    
18.         }      
    
19.         public void run()
    
20.         {
    
21.                 try
    
22.                 {
    
23.                                 BufferedReader bfr=new BufferedReader(new InputStreamReader(System.in));
    
24.                                 String line=null;
    
25.                                 while ((line=bfr.readLine())!=null)
    
26.                                 {                                                  
    
27.                                         byte[] by=line.getBytes();        
    
28.                                         DatagramPacket dst=new DatagramPacket(by,by.length,InetAddress.getByName("192.168.1.100"),10002);
    
29.                                         dt.send(dst);
    
30.                                         //1.这个if语句从上面挪到这个位置
    
31.                                         if (line.equals("baibai"))
    
32.                                         {
    
33.                                                 break;
    
34.                                         }
    
35.                                 }
    
36.                                 dt.close();
    
37.                                 //bfr.close();
    
38.                         }        
    
39.         catch(Exception e)
    
40.         {
    
41.                 throw new RuntimeException("fasongshibai");
    
42.         }
    
43.         }
    
44. }
    
45. class Receive implements Runnable
    
46. {
    
47.         private DatagramSocket dt;
    
48.         public  Receive(DatagramSocket dt)
    
49.         {
    
50.                 this.dt=dt;
    
51.         }      
    
52.         public void run()
    
53.         {
    
54.                 try
    
55.                 {                               
    
56.                         while(true)
    
57.                         {
    
58.                                 byte [] by=new byte[1024];
    
59.                                 DatagramPacket dpt=new DatagramPacket(by,by.length);
    
60.                                 dt.receive(dpt);
    
61.                                 System.out.println(new String(dpt.getData(),0,dpt.getLength()));
    
62.                                 //2.这里加一个if语句判断，是的接收端线程也能结束
    
63.                                 if(new String(dpt.getData(),0,dpt.getLength()).equals("baibai"))
    
64.                                         break;
    
65.                         }
    
66.                         //dt.close();
    
67.                 }
    
68.                 catch(Exception e)
    
69.                 {
    
70.                         throw new RuntimeException("jieshoushibai");
    
71.                 }
    
72.         }
    
73. }
    

复制代码