实际应用中的客户端可能需要和服务器端保持长时间通信，即服务器需要不断地读取客户端数据，并向客户端写入数据；客户端也需要不断地读取服务器数据，并向服务器写入数据。
当使用传统BufferedReader的readLine()方法读取数据时，当该方法成功返回之前，线程被阻塞，程序无法继续执行。考虑到这个原因，服务器应该为每个Socket单独启动一条线程，每条线程负责与一个客户端进行通信。
客户端读取服务器数据的线程同样会被阻塞，所以系统应该单独启动一条线程，该线程专门负责读取服务器数据。
下面考虑实现一个简单的C/S聊天室应用，服务器端则应该包含多条线程，每个Socket对应一条线程，该线程负责读取Socket对应输入流的数据(从客户端发送过来的数据)，并将读到的数据向每个Socket输出流发送一遍(将一个客户端发送的数据"广播"给其他客户端)，因此需要在服务器端使用List来保存所有的Socket。
下面是服务器端的实现代码，程序为服务器提供了两个类，一个是创建ServerSocket监听的主类，另一个是负责处理每个Socket通信的线程类。
import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.ArrayList;
public class MyServer {
//定义保存所有Socket的ArrayList
public static ArrayList<Socket> socketList = new ArrayList<Socket>();
public static void main(String[] args) throws IOException {
ServerSocket ss = new ServerSocket();
while(true){
//此行代码会阻塞，将一直等待别人的连接
Socket s = ss.accept();
socketList.add(s);
//每当客户端连接后启动一条ServerTread线程为该客户服务
new Thread(new ServerThread(s)).start();
}
}
}
上面的程序是服务器端只负责接收客户端Socket的连接请求，每当客户端Socket连接到该ServerSocket之后，程序将对应Socket假如socketList集合中保存，并为该Socket启动一条线程，该线程负责处理该Socket所有的通信任务。
服务器端线程类的代码如下：
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.UnsupportedEncodingException;
import java.net.Socket;
//负责处理每个线程通信的线程类
public class ServerThread implements Runnable {
//定义当前线程所处理的Socket
Socket s = null;
//该线程处理的Socket所对应的输入流
BufferedReader br = null;
public ServerThread(Socket s) throws UnsupportedEncodingException, IOException{
this.s = s;
//初始化该Socket对应的输入流
br = new BufferedReader(new InputStreamReader(s.getInputStream(),"utf-8"));
}
@Override
public void run() {
try {
String content = null;
//采用循环不断从Socket中读取客户端发送过来的数据
while((content = readFromClient()) != null){
//遍历socketList中的每个Socket
//将读到的内容向每个Socket发送一次
for(Socket s: MyServer.socketList){
OutputStream os = s.getOutputStream();
os.write((content+"\n").getBytes("utf-8"));
}
}
} catch (Exception e) {
e.printStackTrace();
}
}
//定义读取客户端数据的方法
private String readFromClient(){
try {
return br.readLine();
}
//如果捕捉到异常，表明该Socket对应的客户端已经关闭
catch (IOException e) {
// 删除该Socket
MyServer.socketList.remove(s);
}
return null;
}
}
上面的服务器端线程类不断读取客户端数据，程序使用readFromClient()方法来读取客户端数据，如果读取数据过程中捕获到IOException异常，则表明该Socket对应的客户端Socket出现了问题，程序就将该Socket从socketList中删除。
当服务器线程读到客户端数据之后，程序遍历socketList集合，并将该数据向socketList集合中的每个Socket发送一次-----该服务器线程将把从Socket中读到的数据向socketList中的每个Socket转发一次，如run()线程执行体中的代码所示。
上面的程序中的代码将网络的字节输入流转换为字符输入流时，指定了转换所用的字符串：UTF-8，这也是由于客户端写过来的数据是采用UTF-8字符集进行编码的，所以此处的服务器端也要使用UTF-8字符集进行解码。当需要编写跨平台的网络通信程序时，使用UTF-8字符集进行编码、解码是一种较好的解决方案。
每个客户端应该包含两条线程：一条负责生成主界面，并响应用户动作，并将用户输入的数据写入Socket对应的输出流；另一条负责读取Socket对应输入流中的数据(从服务器发送过来的数据)，并负责将这些数据在程序界面上显示出来。
客户端程序的界面布局代码如下：
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:tools="http://schemas.android.com/tools"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:orientation="vertical"
tools:context=".MutilTreadClient" >
<LinearLayout
android:layout_width="match_parent"
android:layout_height="match_parent"
android:orientation="vertical"
>
<!-- 定义一个文本框，它用于接收用户的输入 -->
<EditText
android:id="@+id/input"
android:layout_width="240px"
android:layout_height="wrap_content"
/>
<Button
android:id="@+id/send"
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:paddingLeft="8px"
android:text="@string/send"
/>
</LinearLayout>
<!-- 定义一个文本框。它用于显示来自服务器的信息 -->
<EditText
android:id="@+id/show"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:gravity="top"
android:editable="false"
android:cursorVisible="false"
/>
</LinearLayout>
客户端的Activity负责生成程序界面，并为程序的按钮单击事件绑定事件监听器，当用户单击按钮时向服务器发送信息。客户端的Activity代码如下：
import java.io.InputStream;
import java.io.OutputStream;
import java.net.Socket;
import android.os.Bundle;
import android.os.Handler;
import android.os.Message;
import android.app.Activity;
import android.view.Menu;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;
import android.widget.EditText;
public class MutilTreadClient extends Activity {
//定义界面上的两个文本框
EditText input ;
EditText show;
//定义界面上的一个按钮
Button send;
OutputStream os;
Handler handler;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_mutil_tread_client);
input = (EditText) findViewById(R.id.input);
send = (Button) findViewById(R.id.send);
show = (EditText) findViewById(R.id.show);
Socket s ;
handler = new Handler(){
@Override
public void handleMessage(Message msg) {
// 如果消息来自于子线程
if(msg.what == 0x123){
//将读取的内容追加显示在文本框中
show.append("\n"+msg.obj.toString());
}
}
};
try {
s = new Socket("172.18.5.198", 30000);
//客户端启动ClientTread线程不断读取来自服务器的数据
new Thread(new ClientThread(s,handle)).start();
os = s.getOutputStream();
} catch (Exception e) {
e.printStackTrace();
}
send.setOnClickListener(new OnClickListener() {
@Override
public void onClick(View v) {
try {
//将用户在文本框内输入的内容写入网络
os.write((input.getText().toString()+"\r\n").getBytes("utf-8"));
//清空input文本框
input.setText("");
} catch (Exception e) {
e.printStackTrace();
}
}
});
}
}
当用户单击该程序界面中的“发送”按钮之后，程序将会把input输入框中的内容写入该Socket对应的输出流。
除此之外，当主线程使用Socket连接到服务器之后，并启动ClientThread来处理该线程的Socket通信。ClientThread线程负责读取Socket输入流中的内容，并将读到的这些内容在界面上的文本框内显示出来。由于Android不允许子线程访问界面组件，因此上面的程序定义了一个Handler来处理来自子线程的消息。
程序的子线程负责读取来自网络的数据，读到数据之后便通过Handler对象发送一条消息，该程序的子线程代码如下：
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.Socket;
import android.os.Handler;
import android.os.Message;
public class ClientThread implements Runnable{
//该程序负责处理的Socket
private Socket s;
private Handler handler;
//该线程所处理的Socket所对应的输入流
BufferedReader br = null;
public ClientThread(Socket s , Handler handler) throws IOException{
this.s = s;
this.handler = handler;
br = new BufferedReader(new InputStreamReader(s.getInputStream()));
}
@Override
public void run() {
try {
String content = null;
//不断读取Socket输入流中的内容
while((content = br.readLine()) != null){
//每当读到来自服务器的数据后，发送消息通知程序界面显示该数据
Message msg = new Message();
msg.what = 0x123;
msg.obj = content;
handler.sendMessage(msg);
}
} catch (Exception e) {
e.printStackTrace();
}
}
}
上面的线程只是不断获取Socket输入流中的内容，当读到Socket输入流中的内容后，便通过Handler对象那个发送一条消息，消息负责携带读到的数据。
先运行上面程序中的MyServer类，该类运行后只是作为服务器，看不到任何输出，接着可以运行Android客户端-----相当于启动聊天室客户端登录该服务器，接着可以看到在任何一个Android客户端输入一些内容后单击“发送”按钮，将可看到所有客户端(包括自己)都会收到他刚刚输入的内容。
