[置顶] Socket，Thread，多线程Socket

1.Socket

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

 

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

 

服务端

 

 

 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.*;

 /**
  * 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方法

 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接口方法

 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来编写一个可以实现多连接服务端的程序

服务端程序如下：

 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 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 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();
     }
 }