java代码实现 多线程tcp协议传输数据 java多线程socket

1.Socket

Java的服务端和客户端编写都非常简单，创建服务端使用的是ServerSocket的，然后使用accept()的方法进行监听，并返回一个Socket的对象。客户端的话直接使用Socket类进行连接服务端。连接就这么简单。但我个人觉得难点在于传输信息上，Java本来封装好了很多输入输出流来方便程序员调用，但它的类的初始化中在嵌套各类的方法就觉得恶心了，对于初学者很难马上掌握。而我是这样理解的，Socket下我们通过getInputStream()方法来获得信息，通过getOutputSteram()方法来发送信息。

 

下面我们简单的实现一个单向的，客户端向服务端发送信息，只能单个连接的简单网络程序，最主要是来感受一下Java中的网络编程。

 

服务端

 

[java] view plaincopyprint?package src;  
   
 import java.io.*;  
 import java.net.*;  
   
 /** 
  * Server 
  *  
  * @author heqichang 服务端 
  *  
  * */  
 public class Server {  
   
     public static void main(String[] args) {  
         try {  
             // 创建一个服务端，绑定在8899端口   
             ServerSocket serverSocket = new ServerSocket(8899);  
   
             // 开始在服务端开始监听   
             Socket socket = serverSocket.accept();  
   
             // 定义一个流来接收信息   
             BufferedReader br = new BufferedReader(new InputStreamReader(socket  
                     .getInputStream()));  
   
             while (true) {  
                 //利用循环来不断输出获得的信息   
                 System.out.println(br.readLine());  
             }  
         } catch (IOException e) {  
             // TODO Auto-generated catch block   
             e.printStackTrace();  
         }  
     }  
 }  
 package src;import java.io.*;
 import java.net.*;/**
  * Server
  * 
  * @author heqichang 服务端
  * 
  * */
 public class Server { public static void main(String[] args) {
   try {
    // 创建一个服务端，绑定在8899端口
    ServerSocket serverSocket = new ServerSocket(8899);   // 开始在服务端开始监听
    Socket socket = serverSocket.accept();   // 定义一个流来接收信息
    BufferedReader br = new BufferedReader(new InputStreamReader(socket
      .getInputStream()));   while (true) {
     //利用循环来不断输出获得的信息
     System.out.println(br.readLine());
    }
   } catch (IOException e) {
    // TODO Auto-generated catch block
    e.printStackTrace();
   }
  }
 }
   
客户端
 [java] view plaincopyprint?package src;  
   
 import java.io.*;  
 import java.net.*;  
   
 /** 
  * Client 
  *  
  * @author heqichang 客户端 
  *  
  * */  
 public class Client {  
   
     public static void main(String[] args) {  
         try {  
             // 向本地的8899发出客户连接   
             Socket socket = new Socket("127.0.0.1", 8899);  
   
             //定义一个从标准输入设备输入的流   
             BufferedReader br = new BufferedReader(new InputStreamReader(  
                     System.in));  
               
             //发送的流   
             PrintWriter pw = new PrintWriter(socket.getOutputStream());  
   
             while (true) {  
                   
                 //循环发送信息给服务端   
                 pw.println(br.readLine());  
                   
                 //不要忘记最重要的刷新   
                 pw.flush();  
             }  
         } catch (UnknownHostException e) {  
             // TODO Auto-generated catch block   
             e.printStackTrace();  
         } catch (IOException e) {  
             // TODO Auto-generated catch block   
             e.printStackTrace();  
         }  
   
     }  
 }  
 package src;import java.io.*;
 import java.net.*;/**
  * Client
  * 
  * @author heqichang 客户端
  * 
  * */
 public class Client { public static void main(String[] args) {
   try {
    // 向本地的8899发出客户连接
    Socket socket = new Socket("127.0.0.1", 8899);   //定义一个从标准输入设备输入的流
    BufferedReader br = new BufferedReader(new InputStreamReader(
      System.in));
    
    //发送的流
    PrintWriter pw = new PrintWriter(socket.getOutputStream());   while (true) {
     
     //循环发送信息给服务端
     pw.println(br.readLine());
     
     //不要忘记最重要的刷新
     pw.flush();
    }
   } catch (UnknownHostException e) {
    // TODO Auto-generated catch block
    e.printStackTrace();
   } catch (IOException e) {
    // TODO Auto-generated catch block
    e.printStackTrace();
   } }
 }
   
自己上面所写的例子不怎么好，没有将连接进行关闭的操作。
以后自己再完善。
 
 2.Thread
 在Java语言中实现多线程有两种方法，第一种继承Thread类，重载Run()的方法，并用Start()方法进行调用。但上述这种方法在你需要继承其它类的情况下就不能使用了。第二种方法是实现Runnable的接口。下面都来演示一下代码如何实现。
 第一种，继承Thread方法
[java] view plaincopyprint?package src;  
   
 /** 
  *  
  * @author heqichang 
  *  
  * */  
 public class ThreadRun extends Thread {  
     private int num;  
   
     public ThreadRun(int i) {  
         num = i;  
     }  
   
     public void run() {  
         System.out.println(num);  
     }  
   
     public static void main(String[] args) {  
         for (int i = 0; i < 3; i++) {  
             ThreadRun thread = new ThreadRun(i);  
             thread.start();  
         }  
     }  
 }  
 package src;/**
  * 
  * @author heqichang
  * 
  * */
 public class ThreadRun extends Thread {
  private int num; public ThreadRun(int i) {
   num = i;
  } public void run() {
   System.out.println(num);
  } public static void main(String[] args) {
   for (int i = 0; i < 3; i++) {
    ThreadRun thread = new ThreadRun(i);
    thread.start();
   }
  }
 }
   第二种，实现Runnable接口方法
[java] view plaincopyprint?package src;  
   
 /** 
  *  
  * @author heqichang 
  *  
  * */  
 public class Run implements Runnable {  
   
     private int num;  
   
     public Run(int i) {  
         num = i;  
     }  
   
     @Override  
     public void run() {  
         System.out.println(num);  
     }  
   
     public static void main(String[] args) {  
         for (int i = 0; i < 3; i++) {  
             new Thread(new Run(i)).start();  
         }  
     }  
 }  
 package src;/**
  * 
  * @author heqichang
  * 
  * */
 public class Run implements Runnable { private int num;
 public Run(int i) {
   num = i;
  } @Override
  public void run() {
   System.out.println(num);
  } public static void main(String[] args) {
   for (int i = 0; i < 3; i++) {
    new Thread(new Run(i)).start();
   }
  }
 }
   
 3.下面我们来结合多线程和SOCKET来编写一个可以实现多连接服务端的程序
 服务端程序如下：
 [java] view plaincopyprint?import java.io.*;  
 import java.net.*;  
   
 /** 
  *  
  * @author heqichang 
  * 服务端 
  * */  
 public class ThreadSocketServer extends Thread {  
   
     Socket server;  
       
     //保存服务端的姓名   
     static String name = new String();  
   
     public void run() {  
         try {  
               
             //启动一个线程来接收客户端信息   
             ThreadServer thread = new ThreadServer(server);  
             thread.start();  
   
             BufferedReader br = new BufferedReader(new InputStreamReader(  
                     System.in));  
             PrintWriter pw = new PrintWriter(server.getOutputStream());  
               
             //第一次发送自己的姓名给客户端   
             pw.println(name);  
               
             //循环发送信息给客户端   
             while (true) {  
                 String s = br.readLine();  
                 pw.println(s);  
                 pw.flush();  
             }  
         } catch (IOException e) {  
             e.printStackTrace();  
         }  
   
     }  
   
     public ThreadSocketServer(Socket s) {  
         this.server = s;  
     }  
   
     public static void main(String[] args) throws IOException {  
           
         //绑定服务端在9999端口   
         ServerSocket server = new ServerSocket(9999);  
         Socket socket;  
   
         BufferedReader br = new BufferedReader(new InputStreamReader(System.in)); 
         System.out.print("请输入您的姓名：>");  
         name = br.readLine();  
   
         while (true) {  
               
             //监听客户端程序   
             socket = server.accept();  
               
             //一个客户端连接后启动一个线程进行处理   
             ThreadSocketServer thread = new ThreadSocketServer(socket);  
             thread.start();  
         }  
     }  
 }  
 import java.io.*;
 import java.net.*;/**
  * 
  * @author heqichang
  * 服务端
  * */
 public class ThreadSocketServer extends Thread { Socket server;
  
  //保存服务端的姓名
  static String name = new String(); public void run() {
   try {
    
    //启动一个线程来接收客户端信息
    ThreadServer thread = new ThreadServer(server);
    thread.start();   BufferedReader br = new BufferedReader(new InputStreamReader(
      System.in));
    PrintWriter pw = new PrintWriter(server.getOutputStream());
    
    //第一次发送自己的姓名给客户端
    pw.println(name);
    
    //循环发送信息给客户端
    while (true) {
     String s = br.readLine();
     pw.println(s);
     pw.flush();
    }
   } catch (IOException e) {
    e.printStackTrace();
   } }
 public ThreadSocketServer(Socket s) {
   this.server = s;
  } public static void main(String[] args) throws IOException {
   
   //绑定服务端在9999端口
   ServerSocket server = new ServerSocket(9999);
   Socket socket;  BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
   System.out.print("请输入您的姓名：>");
   name = br.readLine();  while (true) {
    
    //监听客户端程序
    socket = server.accept();
    
    //一个客户端连接后启动一个线程进行处理
    ThreadSocketServer thread = new ThreadSocketServer(socket);
    thread.start();
   }
  }
 }
   [java] view plaincopyprint?import java.io.*;  
 import java.net.*;  
   
 /** 
  *  
  * @author heqichang 
  * 服务端接收信息线程 
  * */  
 public class ThreadServer extends Thread{  
       
     Socket serverSocket;  
       
     public void run()  
     {  
         try {  
             BufferedReader br=new BufferedReader(new InputStreamReader(serverSocket.getInputStream())); 
             String read=new String();  
               
             //接受客户端的姓名信息   
             String name=br.readLine();  
               
             //循环接受客户端信息   
             while(true)  
             {  
                 read=br.readLine();  
                 System.out.println(name+"说："+read);  
                   
                 if(read.equals("bye"))  
                 {  
                     break;  
                 }  
             }  
               
             br.close();  
             serverSocket.close();  
               
         } catch (IOException e) {  
             // TODO Auto-generated catch block   
             e.printStackTrace();  
         }  
     }  
       
     public ThreadServer(Socket server)  
     {  
         serverSocket=server;  
     }  
 }  
 import java.io.*;
 import java.net.*;/**
  * 
  * @author heqichang
  * 服务端接收信息线程
  * */
 public class ThreadServer extends Thread{
  
  Socket serverSocket;
  
  public void run()
  {
   try {
    BufferedReader br=new BufferedReader(new InputStreamReader(serverSocket.getInputStream()));
    String read=new String();
    
    //接受客户端的姓名信息
    String name=br.readLine();
    
    //循环接受客户端信息
    while(true)
    {
     read=br.readLine();
     System.out.println(name+"说："+read);
     
     if(read.equals("bye"))
     {
      break;
     }
    }
    
    br.close();
    serverSocket.close();
    
   } catch (IOException e) {
    // TODO Auto-generated catch block
    e.printStackTrace();
   }
  }
  
  public ThreadServer(Socket server)
  {
   serverSocket=server;
  }
 }
   客户端程序：
 [java] view plaincopyprint?import java.io.*;  
 import java.net.*;  
 /** 
  *  
  * @author heqichang 
  * 客户端 
  * */  
 public class ThreadSocketClient extends Thread{  
       
     static Socket socket;  
       
     public void run()  
     {  
         try {  
             BufferedReader br2=new BufferedReader(new InputStreamReader(socket.getInputStream())); 
             String read=new String();  
               
             //接受来自服务端的姓名信息   
             String name=br2.readLine();  
               
             //接受来自服务端的信息   
             while(true)  
             {  
                 read=br2.readLine();  
                 System.out.println(name+"说："+read);  
             }  
               
         } catch (IOException e) {  
             e.printStackTrace();  
         }  
     }  
        
       
     public static void main(String[] args) throws IOException  
     {  
         socket=new Socket("127.0.0.1",9999);  
           
         BufferedReader inputName=new BufferedReader(new InputStreamReader(System.in)); 
           
         System.out.print("已连接上服务端，请输入你的姓名：");  
         String name=inputName.readLine();  
           
         //启动一个线程进行接收服务端信息   
         ThreadSocketClient thread=new ThreadSocketClient();  
         thread.start();  
           
         BufferedReader br=new BufferedReader(new InputStreamReader(System.in));  
         PrintWriter pw=new PrintWriter(socket.getOutputStream());  
           
         //发送给服务端客户端的姓名信息   
         pw.println(name);  
           
         String info=new String();  
           
         //发送消息给服务端   
         while(!info.equals("bye"))  
         {  
             info=br.readLine();  
             pw.println(info);  
             pw.flush();  
         }  
           
         pw.close();  
         socket.close();  
     }  
 }