简单的多线程socket

时间：2024-01-21 19:12:46

简单的多线程socket

1.socket 服务器搭建

实例化socket服务器，循环获取请求

package com.orange.util;

import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.Timer;
import java.util.TimerTask;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

/**
 * socket服务器
 * 
 * @author Chengjq
 *
 */
public class SocketServer {

    public static int count = 0;

    public static void main(String[] args) {
        // TODO 自动生成的方法存根
        int port = 4404;
        // 首先直接创建serversocket
        ServerSocket serverSocket = null;
        Socket socket = null;
        try {
            serverSocket = new ServerSocket(port);
            System.out.println("启动socketServer成功,等待客户端的连接");
            while (true) {
                socket = serverSocket.accept();
                System.out.println("有新的客户端请求连接");
                SocketThread st = new SocketThread(socket);
                st.start();
                ChatManager.getChatManager().add(st);
                //启动定时任务，如果10s内没有进程
                /*Runnable runnable = new Runnable() {
                    int clientNum = 0;
                    public void run() {  
                        // task to run goes here  
                        clientNum = ChatManager.getChatManager().vector.size();
                        System.out.println("剩余客户端数量:"+clientNum);
                        if(clientNum ==0 ){
                            System.out.println("连接超时，或者无客户端连接，关闭serverSocket");
                            //关闭socket
                            //.....
                        }
                    }  
                };  
                ScheduledExecutorService service = Executors  
                        .newSingleThreadScheduledExecutor();  
                // 第二个参数为首次执行的延时时间，第三个参数为定时执行的间隔时间  
                service.scheduleAtFixedRate(runnable, 2, 10, TimeUnit.SECONDS);  */
            }
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } finally {
            System.out.println("serverSocket已超时");
            try {
                socket.close();
                serverSocket.close();
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }

        }
    }

}

SocketThread类实现多线程通信

package com.orange.util;

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

/**
 * SocketThread实现多线程通信
 * 
 * @author Administrator
 *
 */
public class SocketThread extends Thread {

	ServerSocket serverSocket = null;

	Socket socket = null;

	public SocketThread(ServerSocket serverSocket,Socket socket) {
		super();
		this.serverSocket = serverSocket;
		this.socket = socket;
	}
	
	public SocketThread(Socket socket) {
		super();
		this.socket = socket;
	}
	
	public void out(String out) {
        try {
            socket.getOutputStream().write(out.getBytes("utf-8"));
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
	
	public void publish(String out){
		ChatManager.getChatManager().publish(this, out);
	}
	

	@Override
	public void run() {
		// TODO Auto-generated method stub
		BufferedReader socketIn = null;
		PrintWriter socketOut = null;
		String inMess = null;
		try {
			socketIn = new BufferedReader(new InputStreamReader(socket.getInputStream()));
			socketOut = new PrintWriter(socket.getOutputStream());
			while (true) {
				inMess = socketIn.readLine();
				publish(inMess);
				if("bye".equals(inMess)){
					ChatManager.getChatManager().remove(this);
				}
			}
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} finally {
			try {
				System.out.println("已结束当前会话");
				socketOut.close();
				socketIn.close();
				socket.close();
			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}

	}

}

　　单例Chatmanage，对所有客户端线程管控处理

package com.orange.util;

import java.util.Vector;

public class ChatManager {
    // 实现单例化
    private ChatManager() {
    };

    private static final ChatManager cm = new ChatManager();

    public static ChatManager getChatManager() {// 返回值为ChatManager
        return cm;
    }

    // 单例化完成
    Vector<SocketThread> vector = new Vector<SocketThread>();

    public void add(SocketThread st) {// 为当前集合添加SocketThread对象
        vector.add(st);
    }
    
    public void remove(SocketThread st) {// 当前客户端关闭连接
        vector.remove(st);
    }
    
    public void removeall() {// 关闭所有连接
        for (int i = 0; i < vector.size(); i++) {// 遍历所有的线程
            SocketThread csChatSocket = vector.get(i);
            if(csChatSocket!=null){
                vector.remove(csChatSocket);
            }
                
        }
    }

    // 某一个线程向其他的客户端发送信息
    public void publish(SocketThread st, String out) {
        for (int i = 0; i < vector.size(); i++) {// 遍历所有的线程
            SocketThread csChatSocket = vector.get(i);
            if (csChatSocket != st)// 判断不是当前线程就发送此消息
                csChatSocket.out(out + "\n");
        }
    }

    // 向当前线程发信息
    public void publish_present(SocketThread st, String out) {
        st.out(out + "\n");
    }
}

至此，服务器搭建完成

 

2.客户端（创建两个客户端）

客户端1（监听指定服务器，通过控制台输入消息进行服务器与客户端以及客户端之间的通信，）

package com.orange;

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

/**
 * 客户端1
 * @author Chengjq
 *
 */
public class SocketClient1 {

	@SuppressWarnings("static-access")
	public static void main(String[] args) {
		try {
			//初始化客户端
			Socket socket = new Socket("127.0.0.1", 4404);
			BufferedReader readline = new BufferedReader(new InputStreamReader(System.in));
			//获取输出打印流
			PrintWriter socketOut = new PrintWriter(socket.getOutputStream());
			String outTemp = null;
			System.out.println("开始准备向服务器端发起请求---\n自己:");
			// 已启动连接socket服务器，准备实时接收来自其他客户端的消息
			GetMess getMess = new GetMess(socket);
			getMess.start();
			// 通过控制台发送消息给其他客户端，以“bye”为结束语
			while ((outTemp = readline.readLine()) != null) {
				//发送信息
				socketOut.println(outTemp);
				socketOut.flush();
				if("bye".equals(outTemp)){
					break;
				}
			}
			getMess.currentThread().interrupt();
			//依次关闭各种流
			readline.close();
			socketOut.close();
			socket.close();
		} catch (UnknownHostException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}

	}
}

　　客户端2

package com.orange;

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

public class SocketClient2 {
    @SuppressWarnings("static-access")
    public static void main(String[] args) {
        
        try {
            //初始化客户端
            Socket socket = new Socket("127.0.0.1", 4404);
            BufferedReader readline = new BufferedReader(new InputStreamReader(System.in));
            //获取输出打印流
            PrintWriter socketOut = new PrintWriter(socket.getOutputStream());
            String outTemp = null;
            System.out.println("开始准备向服务器端发起请求---\n自己:");
            // 已启动连接socket服务器，准备实时接收来自其他客户端的消息
            GetMess getMess = new GetMess(socket);
            getMess.start();
            // 通过控制台发送消息给其他客户端，以“bye”为结束语
            while ((outTemp = readline.readLine()) != null) {
                //发送信息
                socketOut.println(outTemp);
                socketOut.flush();
                if("bye".equals(outTemp)){
                    break;
                }
            }
            getMess.currentThread().interrupt();
            //依次关闭各种流
            readline.close();
            socketOut.close();
            socket.close();
        } catch (UnknownHostException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

        
    }
}

GetMess（多线程处理获取其他客户端的消息并且展示）

package com.orange;

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

public class GetMess extends Thread {

    Socket socket = null;
    
    public GetMess(Socket socket) {
        super();
        this.socket = socket;
    }

    @Override
    public void run() {
        // TODO Auto-generated method stub
        BufferedReader socketIn = null;
        try {
            InputStream is = socket.getInputStream();
            InputStreamReader isr = new InputStreamReader(is);
            socketIn = new BufferedReader(isr);
            String inTemp = null;
            while(true){
                inTemp = socketIn.readLine();
                if(inTemp != null && !"bye".equals(inTemp) ){
                    System.out.println("好友:\n"+inTemp);
                }else{
                    System.out.println("好友:\n已下线，关闭当前回话");
                    break;
                } 
            }
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }finally {
            try {
                Thread.currentThread().interrupt();
                socketIn.close();
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            
        }
        
    }

    
    
    
}

ok，简单的sockte服务与客户端完成了

先启动server

在分别启动client

输入结束bye,关闭当前会话

posted on 2018-09-25 09:23 Mr.chengJQ 阅读(...) 评论(...) 编辑 收藏

相关文章