Android使用多线程进行网络聊天室通信

package com.fukaimei.multithreadclient;

import android.os.Bundle;
import android.os.Handler;
import android.os.Message;
import android.support.v7.app.AppCompatActivity;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;
import android.widget.EditText;
import android.widget.TextView;

public class MainActivity extends AppCompatActivity {

 // 定义界面上的两个文本框
 EditText input;
 TextView show;
 // 定义界面上的一个按钮
 Button send;
 Handler handler;
 // 定义与服务器通信的子线程
 ClientThread clientThread;

 @Override
 public void onCreate(Bundle savedInstanceState) {
  super.onCreate(savedInstanceState);
  setContentView(R.layout.activity_main);
  input = (EditText) findViewById(R.id.input);
  send = (Button) findViewById(R.id.send);
  show = (TextView) findViewById(R.id.show);
  handler = new Handler() // ②
  {
   @Override
   public void handleMessage(Message msg) {
    // 如果消息来自于子线程
    if (msg.what == 0x123) {
     // 将读取的内容追加显示在文本框中
     show.append("n" + msg.obj.toString());
    }
   }
  };
  clientThread = new ClientThread(handler);
  // 客户端启动ClientThread线程创建网络连接、读取来自服务器的数据
  new Thread(clientThread).start(); // ①
  send.setOnClickListener(new OnClickListener() {
   @Override
   public void onClick(View v) {
    try {
     // 当用户按下发送按钮后，将用户输入的数据封装成Message
     // 然后发送给子线程的Handler
     Message msg = new Message();
     msg.what = 0x234;
     msg.obj = input.getText().toString();
     clientThread.revHandler.sendMessage(msg);
     // 清空input文本框
     input.setText("");
    } catch (Exception e) {
     e.printStackTrace();
    }
   }
  });
 }
}

package com.fukaimei.multithreadclient;

import android.os.Handler;
import android.os.Looper;
import android.os.Message;
import android.util.Log;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.net.Socket;
import java.net.SocketTimeoutException;

public class ClientThread implements Runnable {

 private static final String TAG = "ClientThread";
 private Socket s;
 // 定义向UI线程发送消息的Handler对象
 private Handler handler;
 // 定义接收UI线程的消息的Handler对象
 public Handler revHandler;
 // 该线程所处理的Socket所对应的输入流
 BufferedReader br = null;
 OutputStream os = null;

 public ClientThread(Handler handler) {
  this.handler = handler;
 }

 public void run() {
  try {
   s = new Socket("172.xx.xx.xxx", 30000);
   br = new BufferedReader(new InputStreamReader(
     s.getInputStream()));
   os = s.getOutputStream();
   // 启动一条子线程来读取服务器响应的数据
   new Thread() {
    @Override
    public void run() {
     String content = null;
     // 不断读取Socket输入流中的内容
     try {
      while ((content = br.readLine()) != null) {
       // 每当读到来自服务器的数据之后，发送消息通知程序
       // 界面显示该数据
       Message msg = new Message();
       msg.what = 0x123;
       msg.obj = content;
       handler.sendMessage(msg);
      }
     } catch (IOException e) {
      e.printStackTrace();
     }
    }
   }.start();
   // 为当前线程初始化Looper
   Looper.prepare();
   // 创建revHandler对象
   revHandler = new Handler() {
    @Override
    public void handleMessage(Message msg) {
     // 接收到UI线程中用户输入的数据
     if (msg.what == 0x234) {
      // 将用户在文本框内输入的内容写入网络
      try {
       os.write((msg.obj.toString() + "rn")
         .getBytes("utf-8"));
      } catch (Exception e) {
       e.printStackTrace();
      }
     }
    }
   };
   // 启动Looper
   Looper.loop();
  } catch (SocketTimeoutException e1) {
   Log.d(TAG, "网络连接超时！");
  } catch (Exception e) {
   e.printStackTrace();
  }
 }
}

import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.ArrayList;

public class MyServer {

 // 定义保存所有Socket的ArrayList
 public static ArrayList socketList = new ArrayList();

 public static void main(String[] args) throws IOException {
  ServerSocket ss = new ServerSocket(30000);
  while (true) {
   // 此行代码会阻塞，将一直等待别人的连接
   Socket s = ss.accept();
   socketList.add(s);
   // 每当客户端连接后启动一条ServerThread线程为该客户端服务
   new Thread(new ServerThread(s)).start();
  }
 }
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.net.Socket;
import java.util.Iterator;

// 负责处理每条线程通信的线程类
public class ServerThread implements Runnable {
 // 定义当前线程所处理的Socket
 Socket s = null;
 // 该线程所处理的Socket所对应的输入流
 BufferedReader br = null;
 public ServerThread(Socket s) throws IOException {
  this.s = s;
  // 初始化该Socket对应的输入流
  br = new BufferedReader(new InputStreamReader(s.getInputStream(), "utf-8"));
 }
 @Override
 public void run() {
  String content = null;
  // 采用循环不断从Socket中读取客户端发送过来的数据
  while ((content = readFromClient()) != null) {
   // 遍历socketList中的每个Socket
   // 将读取的内容向每个Socket发送一次
   for (Iterator it = MyServer.socketList.iterator(); it.hasNext();) {
    Socket s = it.next();
    try {
     OutputStream os = s.getOutputStream();
     os.write((content + "n").getBytes("utf-8"));
    } catch (Exception e) {
     e.printStackTrace();
     // 删除该Socket
     it.remove();
     System.out.println(MyServer.socketList);
    }
   }
  }
 }
 // 定义读取客户端数据的方法
 private String readFromClient() {
  try {
   return br.readLine();
  } catch (IOException e) { // 如果捕获到异常，表明该Socket对应的客户端已经关闭
   e.printStackTrace();
   // 删除该Socket
   MyServer.socketList.remove(s);
  }
  return null;
 }
}