多线程、socket、全局静态变量、聊天室

最新推荐文章于 2022-11-27 10:54:55 发布
最新推荐文章于 2022-11-27 10:54:55 发布
阅读量1.1k 收藏 1
点赞数
分类专栏： 中国iOS开发 Objective-c 文章标签： ios socket
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jh_966996/article/details/22959115
版权



 

本程序虽然不是很完善，但是基本要求达到了。

功能：实现多个人同时聊天。类似于群聊天室

 

 

Java代码 复制代码  收藏代码
  1. package com.xiva.bean;  
  2.   
  3. import java.io.*;  
  4. import java.net.ServerSocket;  
  5. import java.net.Socket;  
  6. import java.util.ArrayList;  
  7. import java.util.List;  
  8.   
  9. public class SocketServer {  
  10.     public static List<Socket> socketList = new ArrayList<Socket>();  
  11.     public static int number = 0;  
  12.     public static void main(String[] args) {  
  13.   
  14.         try{  
  15.                     //绑定服务端在8080端口  
  16.             ServerSocket server = new ServerSocket(8080);  
  17.             Socket socket;  
  18.             int count = 0;  
  19.               
  20.             while (true) {  
  21.                   
  22.                 //监听客户端程序  
  23.                 socket = server.accept();  
  24.                 count = count + 1;  
  25.                   
  26.                 System.out.println(socket.getInetAddress().getHostAddress());  
  27.                   
  28.                 //一个客户端连接后启动一个线程进行监听客户端消息  
  29.                   
  30.                 ReadThread readThread = new ReadThread(socket);  
  31.                 readThread.start();  
  32.                   
  33.                 socketList.add(socket);  
  34.             }  
  35.         } catch(IOException e){  
  36.             e.printStackTrace();  
  37.         }  
  38.     }  
  39. }  
  40.   
  41. class ThreadSocketServer extends Thread {  
  42.   
  43.     Socket server;  
  44.       
  45.     public ThreadSocketServer(){  
  46.           
  47.     }  
  48.       
  49.     public ThreadSocketServer(Socket s) {  
  50.         this.server = s;  
  51.     }  
  52.       
  53.     public void run() {  
  54.         try {  
  55.               
  56.             BufferedReader br = new BufferedReader(new InputStreamReader(  
  57.                     System.in));  
  58.             PrintWriter pw = new PrintWriter(server.getOutputStream());  
  59.               
  60.             //循环发送信息给客户端  
  61.             while (true) {  
  62.                 String s = br.readLine();  
  63.                 pw.println(s);  
  64.                 pw.flush();  
  65.                 System.out.println("Server:" + s);  
  66.             }  
  67.         } catch (IOException e) {  
  68.             e.printStackTrace();  
  69.         }  
  70.   
  71.     }  
  72.   
  73. }  
  74.   
  75. class ReadThread extends Thread {  
  76.   
  77.     private Socket socket;  
  78.     public ReadThread(Socket socket){  
  79.         this.socket = socket;  
  80.     }  
  81.     public void run() {  
  82.         try {  
  83.             BufferedReader br=new BufferedReader(new InputStreamReader(socket.getInputStream()));  
  84.             String read=new String();  
  85.               
  86.             //循环接受客户端信息  
  87.             while(true)  
  88.             {  
  89.                   
  90.                 read=br.readLine();  
  91.                 System.out.println(socket.getInetAddress().getHostAddress() +"client说："+read);  
  92.                 ArrayList<Socket> socketList = SocketServer.socketList;  
  93.                 for(int i = 0; i < socketList.size(); i ++){  
  94.                     Socket socket = socketList.get(i);  
  95.                     PrintWriter pw = new PrintWriter(socket.getOutputStream());  
  96.                     pw.println(read);  
  97.                     pw.flush();  
  98.                 }  
  99.                   
  100.                 if(read.equals("bye"))  
  101.                 {  
  102.                     break;  
  103.                 }  
  104.             }  
  105.             br.close();  
  106.             socket.close();  
  107.               
  108.         } catch (IOException e) {  
  109.             // TODO Auto-generated catch block  
  110.             e.printStackTrace();  
  111.         }  
  112.     }  
  113. }  
package com.xiva.bean;

import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.ArrayList;
import java.util.List;

public class SocketServer {
	public static List<Socket> socketList = new ArrayList<Socket>();
	public static int number = 0;
	public static void main(String[] args) {

		try{
					//绑定服务端在8080端口
			ServerSocket server = new ServerSocket(8080);
			Socket socket;
			int count = 0;
			
			while (true) {
				
				//监听客户端程序
				socket = server.accept();
				count = count + 1;
				
				System.out.println(socket.getInetAddress().getHostAddress());
				
				//一个客户端连接后启动一个线程进行监听客户端消息
				
				ReadThread readThread = new ReadThread(socket);
				readThread.start();
				
				socketList.add(socket);
			}
		} catch(IOException e){
			e.printStackTrace();
		}
	}
}

class ThreadSocketServer extends Thread {

	Socket server;
	
	public ThreadSocketServer(){
		
	}
	
	public ThreadSocketServer(Socket s) {
		this.server = s;
	}
	
	public void run() {
		try {
			
			BufferedReader br = new BufferedReader(new InputStreamReader(
					System.in));
			PrintWriter pw = new PrintWriter(server.getOutputStream());
			
			//循环发送信息给客户端
			while (true) {
				String s = br.readLine();
				pw.println(s);
				pw.flush();
				System.out.println("Server:" + s);
			}
		} catch (IOException e) {
			e.printStackTrace();
		}

	}

}

class ReadThread extends Thread {

	private Socket socket;
	public ReadThread(Socket socket){
		this.socket = socket;
	}
    public void run() {
		try {
			BufferedReader br=new BufferedReader(new InputStreamReader(socket.getInputStream()));
			String read=new String();
			
			//循环接受客户端信息
			while(true)
			{
				
				read=br.readLine();
				System.out.println(socket.getInetAddress().getHostAddress() +"client说："+read);
				ArrayList<Socket> socketList = SocketServer.socketList;
				for(int i = 0; i < socketList.size(); i ++){
					Socket socket = socketList.get(i);
					PrintWriter pw = new PrintWriter(socket.getOutputStream());
					pw.println(read);
					pw.flush();
				}
				
				if(read.equals("bye"))
				{
					break;
				}
			}
			br.close();
			socket.close();
			
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
    }
}

 

不用说了上面是socket的server端。

标题中提到了，全局静态变量；就是上面程序中的socketList。用来存储每一个连接到server端的socket.

在read线程中，同时向所有的client端发送信息。

 

 

其中类ThreadSocketServer ，可以启动用来和用户一对一的对话。

 

 

 

Java代码 复制代码  收藏代码
  1. package com.xiva.bean;  
  2.   
  3. import java.io.*;  
  4. import java.net.*;  
  5.   
  6.   
  7. public class TalkClient {  
  8.     public static void main(String args[]) {  
  9.         try{  
  10.             Socket socket=new Socket("192.168.0.64",8080);  
  11.           
  12.             ReadString read = new ReadString(socket);  
  13.             read.start();  
  14.               
  15.             BufferedReader sin=new BufferedReader(new InputStreamReader(System.in));  
  16.               
  17.             PrintWriter os=new PrintWriter(socket.getOutputStream());  
  18.       
  19.             String readline=sin.readLine();  
  20.               
  21.             while(!readline.equals("bye")){  
  22.                 os.println(readline);  
  23.                 os.flush();  
  24.                 System.out.println("Client:"+readline);  
  25.                   
  26.                 readline=sin.readLine();  
  27.             }  
  28.             os.close();  
  29.   
  30.             socket.close();  
  31.         }catch(Exception e) {  
  32.             System.out.println("Error"+e);  
  33.         }  
  34.     }  
  35. }  
  36.   
  37. class ReadString extends Thread {  
  38.   
  39.     private Socket socket;  
  40.     public ReadString(Socket socket){  
  41.         this.socket = socket;  
  42.     }  
  43.     public void run() {  
  44.         try {  
  45.             BufferedReader is=new BufferedReader(new InputStreamReader(socket.getInputStream()));  
  46.             //循环接受服务端信息  
  47.             while(true)  
  48.             {  
  49.                 String read = is.readLine();  
  50.                 System.out.println("Server:"+read);  
  51.                   
  52.                 if(read.equals("bye"))  
  53.                 {  
  54.                     break;  
  55.                 }  
  56.             }  
  57.             is.close();  
  58.             socket.close();  
  59.               
  60.         } catch (IOException e) {  
  61.             e.printStackTrace();  
  62.         }  
  63.     }  
  64. }  
package com.xiva.bean;

import java.io.*;
import java.net.*;


public class TalkClient {
	public static void main(String args[]) {
		try{
			Socket socket=new Socket("192.168.0.64",8080);
		
			ReadString read = new ReadString(socket);
			read.start();
			
			BufferedReader sin=new BufferedReader(new InputStreamReader(System.in));
			
			PrintWriter os=new PrintWriter(socket.getOutputStream());
	
			String readline=sin.readLine();
			
			while(!readline.equals("bye")){
				os.println(readline);
				os.flush();
				System.out.println("Client:"+readline);
				
				readline=sin.readLine();
			}
			os.close();

			socket.close();
		}catch(Exception e) {
			System.out.println("Error"+e);
		}
	}
}

class ReadString extends Thread {

	private Socket socket;
	public ReadString(Socket socket){
		this.socket = socket;
	}
    public void run() {
		try {
			BufferedReader is=new BufferedReader(new InputStreamReader(socket.getInputStream()));
			//循环接受服务端信息
			while(true)
			{
				String read = is.readLine();
				System.out.println("Server:"+read);
				
				if(read.equals("bye"))
				{
					break;
				}
			}
			is.close();
			socket.close();
			
		} catch (IOException e) {
			e.printStackTrace();
		}
    }
}

 

客户端程序，在于启动一个线程监视server端传过来的message，同时可以不断的发送信息给server端。

 

 

这样多人聊天室，便实现了。

 

扩展方向，可以在list中绑定其他信息，比如userInfo。当客户端连接时，发送给客户端有哪些其它客户在线。同样绑定了userInfo后，这样就可以for循环时，判断线程中和那个用户绑定了，也不需要得到线程里面的具体信息了。这样一对一的聊天也很容易就实现了，这些只要有了这个主干下面的程序就好延伸了。

还有需要注意的就是线程存在的时间，我们可能需要写一个定时器，不断唤醒程序，以及让其睡眠。

南宫辞迁
关注
专栏目录
03----3小时 用 websocket 实现聊天室 之项目静态页面搭建
weixin_43964148的博客
08-19 575
创建一个public文件夹，把所有静态资源都放进public文件夹中，如图所示 由于要使用public的静态资源，必须使用express 中的语句 // express使用静态资源 app.use(require('express').static('public')); 此时index .html <!DOCTYPE html> <html lang="en"> ...
孙鑫VC视频教程笔记之第十五课“多线程与聊天室”
Roger Ge 的专栏
09-08 5778
  代码1分析：说明：对于单核cpu的电脑来说，线程都在自己的时间片中运行，单位时间内，系统只能运行一个线程，交替运行；对于多核cpu或多cpu的电脑来说，才是真正意义上的单位时间内运行多个线程 说明：如果采用向导创建的Win32 Console程序选择的是空项目时，则以下使用方式是正确的，如果选择是”hello world”的简单应用程序时，则在main函数中想要使用输入输出流，
node.js静态网页聊天系统
03-02
本章会构建一个在线聊天程序， 用户可以在一个简单的表单中输入消息， 相互聊天， 如图2-1 所示。消息输入后会发送给同一个聊天室内的其他所有用户。
基于html,css写的web端静态聊天页面简单实用
10-17
基于html,css写的web端静态聊天页面简单实用,web页面聊天窗口的html、css、js，界面简单清晰
Qt中的多线程网络编程技术
## 第一章：Qt中的多线程基础 ### 1.1 多线程概述 在现代计算机系统中，多线程编程已经成为一种常见的技术手段。通过多线程编程，程序能够更好地利用多核处理器的计算能力，提高程序的并发性和响应速度。然而，多...
LINUX、JAVA垃圾回收和多线程
qq_44241861的博客
04-15 1662
Linux常见命令 JAVA垃圾回收 查看默认垃圾收集器 GC垃圾回收算法：四种引用计数、复制、标记清除、 java垃圾回收的方式： serial：暂停所有用户线程，只使用一个线程进行垃圾回收。程序–>GC–>程序 不适合服务器环境 Paralleo：多个垃圾收集线程并行工作，用户线程是暂停的。节省了程序暂停的时间。适合大数据科学计算 ，少量前后端交互的环境 CMS：用户和垃圾收集同时进行，不需要停顿用户线程 G1：将堆内存分割成不同的区域，并发的进行垃圾回收 gc启动，
手动搭建I/O网络通信框架3：NIO编程模型，升级改造聊天室
耶low的博客
04-14 171
第一章：手动搭建I/O网络通信框架1：Socket和ServerSocket入门实战，实现单聊 第二章：手动搭建I/O网络通信框架2：BIO编程模型实现群聊 第四章：手动搭建I/O网络通信框架4：AIO编程模型，聊天室终极改造 　　在第二章中用BIO编程模型，简单的实现了一个聊天室。但是其最大的问题在解释BIO时就已经说了：ServerSocket接收请求时（accept()方法）、...
python 从入门到精通——多任务、多线程编程
weixin_42933882的博客
06-09 770
文章目录4.1多任务编程4.3 基于fork的多进程编程4.3.2进程相关函数4.3.3孤儿和僵尸4.3.4群聊聊天室4.4 multiprocessing 模块创建进程4.4.1 进程创建方法4.4.2 进程池实现4.5 进程间通信（IPC）4.5.1 管道通信（pipe)4.5.2 消息队列4.5.3 共享内存4.5.4 本地套接字4.5.5 信号量（信号灯集）4.6 线程编程（Thread）4.6.1 线程基本概念4.6.2 Threading 模块创建线程4.6.3 线程对象属性4.6.4 自定义线
基于html5的简单聊天室
10-11
基于html5的简单聊天室，使用EXT4框架实现窗口视图。
聊天室三种写法
SHIKIO的博客
07-18 880
第一种 net-socket const net = require( 'net' ) //引入net模块 const socket = net.Socket() //创建客户端 const host = 'localhost' const port = 5000 const readline = require( 'readline') // 读取命令行 // 客户端连接服务器 soc...
网络编程socket、数据结构、网络协议
qq_53391144的博客
10-12 1302
2，connect连接服务器套接字（指定服务器ip和端口号）blind ( " ip地址 "， 端口号);2，绑定套接字（指定ip和端口号）3，listen（进入监听状态）4，accept接受客户端请求。1，建立socket套接字。1，建立socket套接字。
SOCKET自学
最新发布
wanglu22006281的博客
11-27 90
比如你只是想连接到一个远程主机上面进行通讯，你并不在乎你究竟是用的自己机器上的哪个端口进行通讯（比如Telnet），那么你可以简单的直接调用connect()函数，connect()将自动寻找出本地机器上的一个未使用的端口，然后调用 bind()来将其socket 绑定到那个端口上。因为如果你给send()的参数中包含的数据的长度远远大于send()所能一次发送的数据，则send()函数只发送它所能发送的最大数据长度，然后它相信你会把剩下的数据再次调用它来进行第二次发送。这个过程是不需要建立连接的。
socket ( java ) 简单多个客户端、服务端通信（多线程）
一个Java菜鸟(同微信公众号)
08-22 9348
原创作品，允许转载，转载时请务必以超链接形式标明文章 原始出处 、作者信息和本声明。否则将追究法律责任。http://blog.csdn.net/love254443233/article/details/7897269   实现:   客户端：多个socket（多个端口），其中一个客户端的一个端口用于接收服务端发送过来的消息，其一个用于向服务端发送消息。其它客户端只有发消息的功能。 服...
Socket多线程实现服务端与多个客户端通信以及客户端之间的通信
热门推荐
b183385676的博客
01-21 2万+
使用Socket实现服务端与客户端通信 Socket socket一般指套接字，将TCP/IP协议封装为几个简单的接口，应用层调用接口就能实现进程间的通信。通信的两个进程各自持有一个socket，双方通过socket提供的接口进行通信，socket是成对出现的。 socket通信实现过程 服务端创建ServerSocket对象，调用accept()方法监听请求，当接收到请求时，返回一个socket对象。 ServerSocket serverSocket = new ServerSocket(8888);/
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值