public class Servicer implements Runnable{
                Socket s;

                public Servicer(Socket s) {
                        this.s = s;
                }

                public void run() {
                       
                        try {
                                InputStream ips= s.getInputStream();
                                OutputStream ops= s.getOutputStream();
                                BufferedReader br= new BufferedReader(new InputStreamReader(ips));
                                DataOutputStream dos= new DataOutputStream(ops);
                                while(true){
                                        String str=br.readLine();
                                        if(str.equalsIgnoreCase("quit")){
                                                System.out.println("The Client has been out !");
                                                break;
                                               
                                        }
                                        String strBack=str.toUpperCase();
                                        dos.writeBytes(strBack);
                                        br.close();
                                        dos.close();
                                        s.close();
                                }
                        } catch (IOException e) {
                               
                                e.printStackTrace();
                        }
                        }
}

public class TcpServer {

        public static void main(String[] args) {
                try {
                        ServerSocket ss= new ServerSocket(8000);
                        while(true){
                                Socket s=ss.accept();
                                new Thread(new Servicer(s)).start();
                               
                               
                        }
                } catch (IOException e) {
                        e.printStackTrace();
                }
               
                        }
}
public class TCPClient {
        public static void main(String[] args) {
        try {
                Socket s= new Socket(InetAddress.getByName("172.16.9.115"),8000);
                InputStream ips=s.getInputStream();
                OutputStream ops= s.getOutputStream();
                BufferedReader brKey= new BufferedReader(new InputStreamReader(System.in));
                DataOutputStream dos= new DataOutputStream(ops);
                BufferedReader brNet= new BufferedReader(new InputStreamReader(ips));
                while(true){
                        String str= brKey.readLine();
            dos.writeBytes(str+System.getProperty("line.separator"));
                        if(str.equalsIgnoreCase("quit")){
                                break;
                                }else
                                {
                                        System.out.println(brNet.readLine());
                                       
                                }
                         
                        }
                   dos.close();
                   brKey.close();
                   brNet.close();
                   s.close();
               
        } catch (Exception e) {
                e.printStackTrace();
        }
               
        }
}
请问为什么客户端和服务端只能通信一次，客户端还没退出就自己死掉了呢？有时还返回null

想要多通信几次的话，就要用到循环，一直等待客户端的输入

要用到while（）的

在service端，你将关闭的通道代码写在了while循环内，当然执行一次后，链接就被断开，同时，service端和Client端你都使用的是readLine（）方法，该方法是阻塞式的，你在Client写了结束标记（System.getProperty("line.separator")），但在service端却没用写，因加上。

你这段代码好多错误，我修改了下，你可以复制运行。
1.close() 关闭的地方不对，应该是在程序结束才关闭，不应该放在循环，所以导致你的刚连接上发信息就退出。
2. 服务器回写客户端的时候也应该加System.getProperty("line.separator")。
3.  Client  用了两次读取 导致也无法打印，使得程序阻塞，打印的应该是服务器回显的。大写。
String str= brKey.readLine();
   dos.writeBytes(str+System.getProperty("line.separator"));
              if(str.equalsIgnoreCase("quit")){
             break;
             }else
      {
             System.out.println(brNet.readLine());
     }
具体解决方案见下面代码。

4 资源关闭前应该判断是否为空，否则抛空指针异常。

1. import java.io.IOException;
   
2. import java.net.ServerSocket;
   
3. import java.net.Socket;
   
4. 
   
5. public class TcpServer {
   
6. 
   
7.         public static void main(String[] args) {
   
8.                 try {
   
9.                         ServerSocket ss = new ServerSocket(8000);
   
10.                         while (true) {
    
11.                                 Socket s = ss.accept();
    
12.                                 new Thread(new Servicer(s)).start();
    
13.                         }
    
14.                 } catch (IOException e) {
    
15.                         e.printStackTrace();
    
16.                 }
    
17.         }
    
18. }
    
19. 
    
20. 
    
21. 
    
22. 
    
23. 
    
24. import java.io.BufferedReader;
    
25. import java.io.DataOutputStream;
    
26. import java.io.IOException;
    
27. import java.io.InputStream;
    
28. import java.io.InputStreamReader;
    
29. import java.io.OutputStream;
    
30. import java.net.Socket;
    
31. 
    
32. public class Servicer implements Runnable {
    
33.         Socket s;
    
34. 
    
35.         public Servicer(Socket s) {
    
36.                 this.s = s;
    
37.         }
    
38. 
    
39.         public void run() {
    
40.                 BufferedReader br = null;
    
41.                 DataOutputStream dos = null;
    
42.                 try {
    
43.                         InputStream ips = s.getInputStream();
    
44.                         OutputStream ops = s.getOutputStream();
    
45.                         br = new BufferedReader(new InputStreamReader(ips));
    
46.                         dos = new DataOutputStream(ops);
    
47.                         while (true) {
    
48.                                 String str = br.readLine();
    
49.                                 if (str.equalsIgnoreCase("quit")) {
    
50.                                         System.out.println("The Client has been out !");
    
51.                                         break;
    
52.                                 }
    
53.                                 String strBack = str.toUpperCase();
    
54.                                 System.out.println(strBack);
    
55.                                
    
56.                                 dos.writeBytes(strBack +  System.getProperty("line.separator"));
    
57.                                 dos.flush();
    
58. 
    
59.                         }
    
60.                 } catch (IOException e) {
    
61.                         e.printStackTrace();
    
62.                 } finally {
    
63.                         try {
    
64.                                 if (br != null) {
    
65.                                         br.close();
    
66.                                 }
    
67.                                 if (dos != null) {
    
68.                                         dos.close();
    
69.                                 }
    
70.                                 if (s != null) {
    
71.                                         s.close();
    
72.                                 }
    
73.                         } catch (IOException e1) {
    
74.                                 e1.printStackTrace();
    
75.                         }
    
76.                 }
    
77.         }
    
78. }
    
79. 
    
80. 
    
81. 
    
82. import java.io.BufferedReader;
    
83. import java.io.DataOutputStream;
    
84. import java.io.IOException;
    
85. import java.io.InputStream;
    
86. import java.io.InputStreamReader;
    
87. import java.io.OutputStream;
    
88. import java.net.InetAddress;
    
89. import java.net.Socket;
    
90. 
    
91. public class TCPClient {
    
92.         public static void main(String[] args) {
    
93.                 BufferedReader brKey = null;
    
94.                 DataOutputStream dos = null;
    
95.                 BufferedReader brNet = null;
    
96.                 Socket s = null;
    
97.                 try {
    
98.                         s = new Socket(InetAddress.getByName("127.0.0.1"), 8000);
    
99.                         InputStream ips = s.getInputStream();
    
100.                         OutputStream ops = s.getOutputStream();
     
101.                         brKey = new BufferedReader(new InputStreamReader(System.in));
     
102.                         dos = new DataOutputStream(ops);
     
103.                         brNet = new BufferedReader(new InputStreamReader(ips));
     
104.                         while (true) {
     
105.                                 String str = brKey.readLine();
     
106.                                 dos.writeBytes(str + System.getProperty("line.separator"));
     
107.                                 if (str.equalsIgnoreCase("quit")) {
     
108.                                         break;
     
109.                                 }  
     
110.                                 dos.flush();
     
111.                                 System.out.println(brNet.readLine());
     
112.                         }
     
113.                 } catch (Exception e) {
     
114.                         e.printStackTrace();
     
115.                 } finally {
     
116.                         try {
     
117.                                 if (dos != null) {
     
118.                                         dos.close();
     
119.                                 }
     
120.                                 if (brKey != null) {
     
121.                                         brKey.close();
     
122.                                 }
     
123.                                 if (brNet != null) {
     
124.                                         brNet.close();
     
125.                                 }
     
126.                                 if (s != null) {
     
127.                                         s.close();
     
128.                                 }
     
129.                         } catch (IOException e1) {
     
130.                                 e1.printStackTrace();
     
131.                         }
     
132.                 }
     
133. 
     
134.         }
     
135. }
     

复制代码

楼主的问题应该是出在客户端和服务端都在等待，因为都有阻塞式方法readLine（），导致两端都在等待，比如客户端向服务端发送中并只是把回车符之前的发送给服务端，服务端没收到结束标志，导致停在那了，应该客户端 dos.writeBytes(str+System.getProperty("line.separator"));String str= brKey.readLine();再加上写过去换行。同样在服务端中也没有回车符的结束标志，也应该在dos.writeBytes(strBack);后再加换行符写过去给客户端。