一个Java多线程阻塞模式通信的例子

程序分Server和Client

服务器端打开侦听的端口，一有客户端连接就创建两个新的线程来负责这个连接

一个负责客户端发送的信息(ClientMsgCollectThread 类)，

另一个负责通过该Socket发送数据（ServerMsgSendThread ）

Server.java代码如下:

/*
 * 创建日期 2009-3-7
 *
 * TODO 要更改此生成的文件的模板，请转至
 * 窗口 － 首选项 － Java － 代码样式 － 代码模板
 */
package faue.MutiUser;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;

/**
 * 服务器端
 * 
 * @author Faue
 */
public class Server extends ServerSocket {

 private static final int SERVER_PORT = 10000;

 /**
  * 构造方法，用于实现连接的监听
  * 
  * @throws IOException
  */
 public Server() throws IOException {
  super(SERVER_PORT);

  try {
   while (true) {
    Socket socket = super.accept();

    new Thread(new ClientMsgCollectThread(socket), "getAndShow"
      + socket.getPort()).start();
    new Thread(new ServerMsgSendThread(socket), "send"
      + socket.getPort()).start();

   }
  } catch (IOException e) {
   e.printStackTrace();
  }

 }

 public static void main(String[] args) throws IOException {
  new Server();
 }

 /**
  * 该类用于创建接收客户端发来的信息并显示的线程
  * 
  * @author Faue
  * @version 1.0.0
  */
 class ClientMsgCollectThread implements Runnable {

  private Socket client;

  private BufferedReader in;

  private StringBuffer inputStringBuffer = new StringBuffer("Hello");

  /**
   * 得到Socket的输入流
   * 
   * @param s
   * @throws IOException
   */
  public ClientMsgCollectThread(Socket s) throws IOException {
   client = s;

   in = new BufferedReader(new InputStreamReader(client
     .getInputStream(), "GBK"));
  }

  public void run() {
   try {

    while (!client.isClosed()) {
     inputStringBuffer.delete(0, inputStringBuffer.length());
     inputStringBuffer.append(in.readLine());

     System.out.println(getMsg(inputStringBuffer.toString()));
    }
   } catch (IOException e) {
    //e.printStackTrace();
    System.out.println(client.toString() + " is closed!");

   }
  }

  /**
   * 构造显示的字符串
   * 
   * @param line
   * @return
   */
  private String getMsg(String line) {
   return client.toString() + " says:" + line;
  }

 }

 /**
  * 该类用于创建发送数据的线程
  * 
  * @author Faue
  * @version 1.0.0
  */
 class ServerMsgSendThread implements Runnable {

  private Socket client;

  private PrintWriter out;

  private BufferedReader keyboardInput;

  private StringBuffer outputStringBuffer = new StringBuffer("Hello");

  /**
   * 得到键盘的输入流
   * 
   * @param s
   * @throws IOException
   */
  public ServerMsgSendThread(Socket s) throws IOException {
   client = s;

   out = new PrintWriter(client.getOutputStream(), true);
   keyboardInput = new BufferedReader(new InputStreamReader(System.in));

  }

  public void run() {
   try {

    while (!client.isClosed()) {
     outputStringBuffer.delete(0, outputStringBuffer.length());
     outputStringBuffer.append(keyboardInput.readLine());

     out.println(outputStringBuffer.toString());
    }
   } catch (IOException e) {
    //e.printStackTrace();
    System.out.println(client.toString() + " is closed!");

   }
  }

 }

}

 客户端：

实现基于IP地址的连接，连接后也创建两个线程来实现信息的发送和接收

 

/*
 * 创建日期 2009-3-7
 * 
 */
package faue.MutiUser;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.Socket;

/**
 * 客户端
 * 
 * @author Faue
 */
public class Client {

 private Socket mySocket;

 /**
  * 创建线程的构造方法
  * 
  * @param IP
  * @throws IOException
  */
 public Client(String IP) throws IOException {

  try {
   mySocket = new Socket(IP, 10000);
   new Thread(new ServerMsgCollectThread(mySocket), "getAndShow"
     + mySocket.getPort()).start();
   new Thread(new ClientMsgSendThread(mySocket), "send"
     + mySocket.getPort()).start();

  } catch (IOException e) {
   //e.printStackTrace();
   System.out.println("Server.IP:" + IP
     + " port:10000 can not be Connected");
  }
 }

 public static void main(String[] args) throws IOException {
  try {
   new Client(args[0]);
  } catch (Exception e) {
   System.out.println("输入的IP地址错误");
  }
 }

 /**
  * 该类用于创建接收服务端发来的信息并显示的线程
  * 
  * @author Faue
  * @version 1.0.0
  */
 class ServerMsgCollectThread implements Runnable {

  private Socket client;

  private BufferedReader in;

  private StringBuffer inputStringBuffer = new StringBuffer("Hello");

  /**
   * 得到Socket的输入流
   * 
   * @param s
   * @throws IOException
   */
  public ServerMsgCollectThread(Socket s) throws IOException {
   client = s;

   in = new BufferedReader(new InputStreamReader(client
     .getInputStream(), "GBK"));
  }

  public void run() {
   try {

    while (!client.isClosed()) {
     inputStringBuffer.delete(0, inputStringBuffer.length());
     inputStringBuffer.append(in.readLine());
     System.out.println(getMsg(inputStringBuffer.toString()));
    }
   } catch (IOException e) {
    //e.printStackTrace();
    System.out.println(client.toString() + " is closed!");
    System.exit(0);
   }
  }

  /**
   * 构造输入字符串
   * 
   * @param line
   * @return
   */
  private String getMsg(String line) {
   return client.toString() + " says:" + line;
  }

 }

 /**
  * 该类用于创建发送数据的线程
  * 
  * @author Faue
  * @version 1.0.0
  */
 class ClientMsgSendThread implements Runnable {

  private Socket client;

  private PrintWriter out;

  private BufferedReader keyboardInput;

  private StringBuffer outputStringBuffer = new StringBuffer("Hello");

  /**
   * 得到键盘的输入流
   * 
   * @param s
   * @throws IOException
   */
  public ClientMsgSendThread(Socket s) throws IOException {
   client = s;

   out = new PrintWriter(client.getOutputStream(), true);
   keyboardInput = new BufferedReader(new InputStreamReader(System.in));

  }

  public void run() {
   try {

    while (!client.isClosed()) {
     outputStringBuffer.delete(0, outputStringBuffer.length());
     outputStringBuffer.append(keyboardInput.readLine());

     out.println(outputStringBuffer.toString());
    }
    out.println("--- See you, bye! ---");
   } catch (IOException e) {
    //e.printStackTrace();
    System.out.println(client.toString() + " is closed!");
    System.exit(0);
   }
  }

 }

} 

 

此文主要用来与非阻塞通信作比较