用java多线程实现一个控制台聊天室

1. package tf.thread;   
2.   
3. import java.io.BufferedReader;   
4. import java.io.IOException;   
5. import java.io.InputStreamReader;   
6. import java.io.PrintWriter;   
7. import java.net.ServerSocket;   
8. import java.net.Socket;   
9. import java.util.ArrayList;   
10. import java.util.List;   
11. import java.util.concurrent.ExecutorService;   
12. import java.util.concurrent.Executors;   
13.   
14. public class ChatServer {   
15.     private static final int PORT = 8888; // 端口号   
16.     private static List<Socket> list = new ArrayList<Socket>(); // 保存连接对象   
17.     private ExecutorService exec;   
18.     private ServerSocket server;   
19.   
20.     public static void main(String[] args) {   
21.         new ChatServer();   
22.     }   
23.   
24.     public ChatServer() {   
25.         try {   
26.             server = new ServerSocket(PORT);   
27.             exec = Executors.newCachedThreadPool();   
28.             System.out.println("服务器已启动！");   
29.   
30.             Socket client = null;   
31.             while (true) {   
32.                 client = server.accept(); // 接收客户连接   
33.                 list.add(client);   
34.                 exec.execute(new ChatTask(client));   
35.             }   
36.         } catch (IOException e) {   
37.             e.printStackTrace();   
38.         }   
39.     }   
40.   
41.     static class ChatTask implements Runnable {   
42.         private Socket socket;   
43.         private BufferedReader br;   
44.         private PrintWriter pw;   
45.         private String msg;   
46.   
47.         public ChatTask(Socket socket) throws IOException {   
48.             this.socket = socket;   
49.             br = new BufferedReader(new InputStreamReader(socket   
50.                     .getInputStream()));   
51.             msg = "【" + this.socket.getInetAddress() + "】进入聊天室！当前聊天室有【"  
52.                     + list.size() + "】人";   
53.   
54.             sendMessage();   
55.         }   
56.   
57.         public void run() {   
58.             try {   
59.                 while ((msg = br.readLine()) != null) {   
60.                     if (msg.trim().equals("bye")) {   
61.                         list.remove(socket);   
62.                         br.close();   
63.                         pw.close();   
64.                         msg = "【" + socket.getInetAddress() + "】离开聊天室！当前聊天室有【"  
65.                                 + list.size() + "】人";   
66.                         socket.close();   
67.   
68.                         sendMessage();   
69.                         break;   
70.                     } else {   
71.                         msg = "【" + socket.getInetAddress() + "】说：" + msg;   
72.                         sendMessage();   
73.                     }   
74.                 }   
75.             } catch (IOException e) {   
76.                 e.printStackTrace();   
77.             }   
78.         }   
79.   
80.         /**  
81.          * 群发消息给聊天室的所有人  
82.          */  
83.         private void sendMessage() throws IOException {   
84.             System.out.println(msg);   
85.             for (Socket client : list) {   
86.                 pw = new PrintWriter(client.getOutputStream(), true);   
87.                 pw.println(msg);   
88.             }   
89.         }   
90.     }   
91. }  

package tf.thread;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class ChatServer {
	private static final int PORT = 8888; // 端口号
	private static List<Socket> list = new ArrayList<Socket>(); // 保存连接对象
	private ExecutorService exec;
	private ServerSocket server;

	public static void main(String[] args) {
		new ChatServer();
	}

	public ChatServer() {
		try {
			server = new ServerSocket(PORT);
			exec = Executors.newCachedThreadPool();
			System.out.println("服务器已启动！");

			Socket client = null;
			while (true) {
				client = server.accept(); // 接收客户连接
				list.add(client);
				exec.execute(new ChatTask(client));
			}
		} catch (IOException e) {
			e.printStackTrace();
		}
	}

	static class ChatTask implements Runnable {
		private Socket socket;
		private BufferedReader br;
		private PrintWriter pw;
		private String msg;

		public ChatTask(Socket socket) throws IOException {
			this.socket = socket;
			br = new BufferedReader(new InputStreamReader(socket
					.getInputStream()));
			msg = "【" + this.socket.getInetAddress() + "】进入聊天室！当前聊天室有【"
					+ list.size() + "】人";

			sendMessage();
		}

		public void run() {
			try {
				while ((msg = br.readLine()) != null) {
					if (msg.trim().equals("bye")) {
						list.remove(socket);
						br.close();
						pw.close();
						msg = "【" + socket.getInetAddress() + "】离开聊天室！当前聊天室有【"
								+ list.size() + "】人";
						socket.close();

						sendMessage();
						break;
					} else {
						msg = "【" + socket.getInetAddress() + "】说：" + msg;
						sendMessage();
					}
				}
			} catch (IOException e) {
				e.printStackTrace();
			}
		}

		/**
		 * 群发消息给聊天室的所有人
		 */
		private void sendMessage() throws IOException {
			System.out.println(msg);
			for (Socket client : list) {
				pw = new PrintWriter(client.getOutputStream(), true);
				pw.println(msg);
			}
		}
	}
}

聊天室客户端（输入bye可退出聊天室）

Java代码

1. package tf.thread;   
2.   
3. import java.io.BufferedReader;   
4. import java.io.InputStreamReader;   
5. import java.io.PrintWriter;   
6. import java.net.Socket;   
7. import java.util.concurrent.ExecutorService;   
8. import java.util.concurrent.Executors;   
9.   
10. public class ChatClient {   
11.     private static final int PORT = 8888;   
12.     private static ExecutorService exec = Executors.newCachedThreadPool();   
13.   
14.     public static void main(String[] args) throws Exception {   
15.         new ChatClient();   
16.     }   
17.   
18.     public ChatClient() {   
19.         try {   
20.             Socket socket = new Socket("192.168.1.120", PORT);   
21.             exec.execute(new Sender(socket));   
22.             System.out   
23.                     .println("【" + socket.getInetAddress() + "】您好，欢迎来到阿飞聊天室！");   
24.   
25.             BufferedReader br = new BufferedReader(new InputStreamReader(socket   
26.                     .getInputStream()));   
27.             String msg;   
28.             while ((msg = br.readLine()) != null) {   
29.                 System.out.println(msg);   
30.             }   
31.         } catch (Exception e) {   
32.   
33.         }   
34.     }   
35.   
36.     /**  
37.      * 客户端线程获取控制台输入消息  
38.      */  
39.     static class Sender implements Runnable {   
40.         private Socket socket;   
41.   
42.         public Sender(Socket socket) {   
43.             this.socket = socket;   
44.         }   
45.   
46.         public void run() {   
47.             try {   
48.                 BufferedReader br = new BufferedReader(new InputStreamReader(   
49.                         System.in));   
50.                 PrintWriter pw = new PrintWriter(socket.getOutputStream(), true);   
51.                 String msg;   
52.   
53.                 while (true) {   
54.                     msg = br.readLine();   
55.                     pw.println(msg);   
56.   
57.                     if (msg.trim().equals("bye")) {   
58.                         pw.close();   
59.                         br.close();   
60.                         exec.shutdownNow();   
61.                         break;   
62.                     }   
63.                 }   
64.             } catch (Exception e) {   
65.                 e.printStackTrace();   
66.             }   
67.         }   
68.     }   
69. }