网络编程及多线程-TCP实现聊天（一）

最新推荐文章于 2021-07-19 11:44:56 发布
最新推荐文章于 2021-07-19 11:44:56 发布
阅读量2k 收藏 23
点赞数 3
分类专栏： 网络编程及多线程 文章标签： java 网络 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/napoluen/article/details/107073509
版权

TCP案例-网络编程实现聊天（1）

1.实现单个客户端可以接收和发送多条数据

客户端可以发送给服务端多条消息，服务端将消息重新响应给客户端。

客户端代码：

public class MultiClient {
	public static void main(String[] args) throws UnknownHostException, IOException {
		System.out.println("-----Client-----");
		//1、建立连接: 使用Socket创建客户端 +服务的地址和端口
		Socket client =new Socket("localhost",8888);
		//2、客户端发送消息
		BufferedReader console =new BufferedReader(new InputStreamReader(System.in));
		DataOutputStream dos =new DataOutputStream(client.getOutputStream());		
		DataInputStream dis =new DataInputStream(client.getInputStream());
		boolean isRunning = true;
		while(isRunning) {
			String msg = console.readLine();
			dos.writeUTF(msg);
			dos.flush();
			//3、获取消息
			msg =dis.readUTF();
			System.out.println(msg);
		}
		dos.close();
		dis.close();
		client.close();
	}
}

服务端代码：

public class MultiServer {
	public static void main(String[] args) throws IOException {
		System.out.println("-----Server-----");
		// 1、指定端口 使用ServerSocket创建服务器
		ServerSocket server =new ServerSocket(8888);
		// 2、阻塞式等待连接 accept
		Socket  client =server.accept(); 
		System.out.println("一个客户端建立了连接");
		
		DataInputStream dis =new DataInputStream(client.getInputStream());
		DataOutputStream dos =new DataOutputStream(client.getOutputStream());		
		boolean isRunning = true;
		while(isRunning) {
			//3、接收消息
			String msg =dis.readUTF();
			//4、返回消息
			dos.writeUTF(msg);
			//释放资源
			dos.flush();
		}
		dos.close();
		dis.close();
		client.close();
	}
}

但是这种情况我们只能用于单个客户端的，我们想如何能够实现多客户端的收发消息。

2.实现多个客户端的收发消息

猜想：我们可以在服务端使用while(true)循环去处理多个客户端的情况，代码如下：

客户端代码：

public class MultiClient {
	public static void main(String[] args) throws UnknownHostException, IOException {
		System.out.println("-----Client-----");
		//1、建立连接: 使用Socket创建客户端 +服务的地址和端口
		Socket client =new Socket("localhost",8888);
		//2、客户端发送消息
		BufferedReader console =new BufferedReader(new InputStreamReader(System.in));
		DataOutputStream dos =new DataOutputStream(client.getOutputStream());		
		DataInputStream dis =new DataInputStream(client.getInputStream());
		boolean isRunning = true;
		while(isRunning) {
			String msg = console.readLine();
			dos.writeUTF(msg);
			dos.flush();
			//3、获取消息
			msg =dis.readUTF();
			System.out.println(msg);
		}
		dos.close();
		dis.close();
		client.close();
	}
}

服务端：

public class MultiServer {
	public static void main(String[] args) throws IOException {
		System.out.println("-----Server-----");
		// 1、指定端口 使用ServerSocket创建服务器
		ServerSocket server =new ServerSocket(8888);
		// 2、阻塞式等待连接 accept
		while(true) {
			System.out.println("建立连接之前");
			Socket  client =server.accept(); 
			System.out.println("一个客户端建立了连接");
			DataInputStream dis =new DataInputStream(client.getInputStream());
			DataOutputStream dos =new DataOutputStream(client.getOutputStream());	
			boolean isRunning = true;
			while(isRunning) {
				//3、接收消息
				String msg =dis.readUTF();
				//4、返回消息
				dos.writeUTF(msg);
				//释放资源
				dos.flush();
			}
			dos.close();
			dis.close();
			client.close();
		}
	}
}

奇怪的是，当我们启动了两次客户端以后，服务端运行结果如下:

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-2wTSrzpT-1593613816917)(E:\MarkDown\10.网络编程\images\img1.png)]

可以看到，多次运行客户端代码，却只建立了一个连接，这是什么原因呢?

当我们在服务端去掉如下代码后：

DataInputStream dis =new DataInputStream(client.getInputStream());
DataOutputStream dos =new DataOutputStream(client.getOutputStream());	
boolean isRunning = true;
........

运行结果如下：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-legy8iKJ-1593613816924)(E:\MarkDown\10.网络编程\images\img2.png)]

可以看到建立了两次连接，由此我们可以找到，是由于上一次的客户端的连接建立的输入输出流占用了连接通道导致，所以必须想办法使得每个客户端都需要有一个属于自己的流通道，这个时候自然想到了多线程

3.使用多线程实现多个客户端的接发功能

代码如下：

客户端代码不变：

public class MutiClient {
	public static void main(String[] args) throws IOException{
		Socket socket = new Socket("localhost", 8888);
		BufferedReader reader=new BufferedReader(new InputStreamReader(System.in));
		
		DataInputStream dis=new DataInputStream(socket.getInputStream());
		DataOutputStream dos=new DataOutputStream(socket.getOutputStream());
		boolean flag=true;
		while (flag) {
			String readLine = reader.readLine();
			dos.writeUTF(readLine);
			dos.flush();
			
			//接收服务器返回数据
			String readUTF = dis.readUTF();
			System.out.println(readUTF);
			
		}
		socket.close();
	}
}

服务端代码引入多线程：

public class TMultiChat {
	public static void main(String[] args) throws IOException {
		System.out.println("-----Server-----");
		// 1、指定端口 使用ServerSocket创建服务器
		ServerSocket server =new ServerSocket(8888);
		// 2、阻塞式等待连接 accept
		while(true) {
			Socket  client =server.accept(); 
			System.out.println("一个客户端建立了连接");
			//通过线程的引入使得每个连接都有自己的一个流通道
			new Thread(()->{
				DataInputStream dis=null;
				DataOutputStream dos=null;
				try {
					dis = new DataInputStream(client.getInputStream());
					dos =new DataOutputStream(client.getOutputStream());
				} catch (IOException e1) {
					e1.printStackTrace();
				}					
				boolean isRunning = true;
				while(isRunning) {
					//3、接收消息
					String msg;
					try {
						msg = dis.readUTF();
						//4、返回消息
						dos.writeUTF(msg);
						//释放资源
						dos.flush();
					} catch (IOException e) {
						//e.printStackTrace();
						isRunning = false; //停止线程
					}					
				}
				try {
					if(null==dos) {
						dos.close();
					}
				} catch (IOException e) {
					e.printStackTrace();
				}
				try {
					if(null==dis) {
						dis.close();
					}
				} catch (IOException e) {
					e.printStackTrace();
				}
				try {
					if(null==client) {
						client.close();
					}
				} catch (IOException e) {
					e.printStackTrace();
				}	
			}).start(); 		
			}			
		}
}

这样通过线程的引入使得每个客户端都有自己的一个流通道来实现输入输出。

但是上面的代码仍然存在一些问题：代码冗余，客户端的发送信息和接收都写在了一起，不好维护。想办法来解决：

4.使用多线程实现客户端的读入和写出，同时在服务端使用一个线程去处理读入和写出。同时对代码进行封装利于维护

客户端代码：

/*
 * 1.Send线程专门处理写入到服务器
 * 2.Receive线程处理从服务端返回的数据
 */
public class MutiClient {
	public static void main(String[] args) throws IOException {
		Socket socket=new Socket("localhost",8888);
		//创建两个线程来分别发送和接收消息
		new Thread(new Send(socket)).start();
		new Thread(new Receive(socket)).start();
	}
}

Send线程实现：

public class Send implements Runnable {
	private Socket client;
    //定义输出流
	private DataOutputStream dos;
    //获取键盘录入
	private BufferedReader reader;
    //循环标识
	private boolean running;
    
	public Send(Socket socket) {
		this.client=socket;
		this.running=true;
		try {
            //初始化流对象和键盘缓冲对象
			dos=new DataOutputStream(client.getOutputStream());
			reader=new BufferedReader(new InputStreamReader(System.in));
			
		} catch (IOException e) {
			
			e.printStackTrace();
		}
		
	}

    //线程方法
	@Override
	public void run() {
		while (running) {
			String msg=getConsoleInput();
			if (!msg.equals("")) {
				send(msg);
			}

		}

	}

	//获得键盘输入
	private String getConsoleInput() {
		try {
			String readLine = reader.readLine();
			return readLine;
		} catch (IOException e) {
			System.out.println("获取键盘输入时出错。");
			running=false;
			SxtUtils.close(dos,client);
		}
		return "";
	}
	
	//发送信息至服务端
	private void send(String msg) {
		try {
			dos.writeUTF(msg);
			dos.flush();
		} catch (IOException e) {
			System.out.println(e);
			System.out.println("===3==");
			release();
		}
	}

	//封装释放socket和流对象
	private void release() {
		this.running=false;
		SxtUtils.close(dos,client);
		
	}

}

receive线程实现：

/*
 * 接受服务端响应
 */
public class Receive implements Runnable {
	private Socket client;
	DataInputStream dis;
	boolean running;
	public Receive(Socket client) {
		this.client=client;
		this.running=true;
		try {
			dis=new DataInputStream(client.getInputStream());
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}

    //线程方法
	@Override
	public void run() {
		while (running) {
            //接受响应
			String msg=receive();
			if (!msg.equals("")) {
				System.out.println(msg);
			}
		}

	}

    //接受服务端响应数据
	private String receive() {
		try {
			String msg = dis.readUTF();
			return msg;
		} catch (IOException e) {
			System.out.println("读取响应信息的时候出错");
			realase();
		}
		return "";
	}

    //异常处理
	private void realase() {
		this.running=false;
		SxtUtils.close(dis,client);	
	}
}

封装了一个静态方法用于关闭流对象：

public class SxtUtils {
	public static void close(Closeable... targets) {
		for (Closeable target : targets) {
			try {
				if(null!=target) {
					target.close();
				}
			}catch(Exception e) {
				
			}
		}	
	}
}

服务端方法：

/*
 * 服务端代码
 */
public class MutiServer {
	public static void main(String[] args) throws IOException {
		ServerSocket serverSocket = new ServerSocket(8888);
		while (true) {
			Socket server = serverSocket.accept();
			//新建一个线程来处理读取和写入客户端
			new Thread(new Mychannle(server)).start();
		}
	}
}

服务端通过一个线程处理接收和响应数据：

/*
 * 服务端通过一个线程类处理每个客户端的数据接收和响应问题
 */
public class Mychannle implements Runnable {
	private Socket server;
	private DataInputStream dis;
	private DataOutputStream dos;
	private boolean running;
	public Mychannle(Socket server) {
		this.server=server;
		this.running=true;
		
		try {
			dis=new DataInputStream(server.getInputStream());
			dos=new DataOutputStream(server.getOutputStream());
		} catch (IOException e) {
			System.out.println("服务端初始化流失败");
			realese();
		}
	}

	@Override
	public void run() {
		while (running) {
			String msg=getInputMsg();
			if (!msg.equals("")) {
				send(msg);
			}
		}

	}

	private void send(String msg) {
		try {
			dos.writeUTF(msg);
			dos.flush();
		} catch (IOException e) {
			System.out.println("服务端写回客户端失败");
			realese();
			
		}
		
	}
	private void realese() {
		this.running=false;
		SxtUtils.close(dis,dos,server);
		
	}

	private String getInputMsg() {
		try {
			String msg = dis.readUTF();
			return msg;
		} catch (IOException e) {
			System.out.println("服务端获取传入数据失败");
			realese();
		}
		return "";
	}

}

至此我们完成了多个客户端可以同时启动，并且每个客户端可以接收自己发送给服务端的数据，通过线程的引入解决了客户端需要排队的现象。

接下来我们应该考虑如何实现群聊的功能

下一篇实现群聊及私聊的实现

史蒂夫:王
关注
  • 3
    点赞
  • 踩
  • 23
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
多线程实现的简单网络聊天程序，带注释
10-08
简单的网络聊天程序，用多线程实现数据接收，带详细的注释，可以给初学者学习
网络编程——多线程技术实现网络聊天程序
HeartHelp2013的博客
10-16 742
最近学习了网络编程，在学习多线程技术后，就尝试着用多线程技术写了一个网络聊天程序。下面介绍一下具体的实现过程。 既然是聊天程序，肯定要发送数据和接收数据，这里我新创建了一个线程来接收数据，用主线程来发送数据。同一个进程中的两个线程可以独立运行并相互交通信。因此可以实现数据的接收和发送。 先建立一个基于对话框的应用程序，并在对话框上放置接收数据的编辑框、发送数据...
TCP通信多线程网络聊天程序
91创客学堂
09-12 1723
程序功能 要求：编写一个网络聊天程序，要求采用数据流的套接口编程。程序分为服务器端与客户端。服务器端最大同时连接10个客户端。 服务器端可以响应多个客户端的请求，每个客户端之间可以相互通信，由服务器实现转发。服务器端显示所有客户端的通信，并有脏话过滤功能（比如用户输入“Fuck”，过滤后为“**”）。客户端通过用户名实现不同用户间通信(发送消息格式“用户名” “消息内容””)。 多程线网络
java线程池_程序员：java使用线程池和TCP实现简单多轮聊天系统
weixin_39820158的博客
11-12 138
最近在做物联网项目,需要使用TCP和传感器进行双向交互,通过这种渠道,找到了下面的代码,写成博客主要也是为了记录一下,以后用到随时可以看。代码实现服务端package com.tcp;import java.io.BufferedReader;import java.io.IOException;import java.io.InputStream;import java.io.InputStre...
多线程实现聊天程序
笔尖上的tandaly
06-17 1446
客户端 ChatClient.java： package com.chat.client; import java.awt.BorderLayout; import java.awt.Frame; import java.awt.TextArea; import java.awt.TextField; import java.awt.event.ActionEvent; import java
网络编程 多人聊天 TCP多线程
01-09
该文件具体描述了使用过程，包含源码和编译后的可执行文件。可以实现Linux下私聊、群聊、文件传输和成员管理功能，具体详见我发布的网络编程课程设计文章。
Java代码写的局域网多线程TCP、Socket多人聊天室winsock.zip
06-17
Java代码写的基于TCP和Socket编程的局域网多线程多人聊天室（Java网络编程）实训小例子。
Python Socket编程之多线程聊天室
09-20
主要为大家详细介绍了Python Socket编程之多线程聊天室，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
Python 网络编程 12TCP多线程完成聊天.mp4
02-09
Python 网络编程 12TCP多线程完成聊天.mp4
Python 网络编程 13TCP多线程聊天优化.mp4
02-09
Python 网络编程 13TCP多线程聊天优化.mp4
多线程实现TCP多人聊天室（源码）
03-28
简单的控制台程序，全部代码用C语言实现，可直接运行。使用多线程实现一对多的c/s模型设计，先运行server.c再运行client.c，可同时运行多个client.c
TCP聊天程序与多线程TCP
11-29
TCP聊天程序与多线程TCP的设计文档，关于客户端与服务器的
java程序设计 TCP聊天程序 可以有多个客户端
11-28
java程序设计 TCP聊天程序 可以有多个客户端
网络编程_多线程实现聊天室程序
辐_射的博客
04-11 1645
package cn.itcast_05; import java.io.IOException; import java.net.DatagramSocket; /* * 通过多线程改进聊天室程序,这样就可以实现在一个窗口发送和接收数据了 */ public class ChatRoom { public static void main(String[] args) throws I
多线程+网络编程实现聊天室
hins
07-17 3861
服务器： package com.thread.socket.demo; import java.io.DataInputStream; import java.io.DataOutputStream; import java.io.IOException; import java.net.ServerSocket; import java.net.Socket; import java.ut
Java网络编程：多线程聊天
大唐雨夜的博客
03-23 964
聊天程序如果是单线程，会导致没人只能说一句，并且说了以后，必须等到另一个人的回复，才能说第二句。收发都在主线程中，不能同时进行。 解决方法： 将收发放到两个不同的线程 1. SendThread 发送消息线程 2. RecieveThread 接受消息线程 3. Server一旦接受到连接，就启动收发两个线程 4. Client 一旦建立了连接，就启动收发两个线程
UDP进行聊天
阿柒
07-19 96
交流发送端 public class TalkSend implements Runnable{ DatagramSocket socket = null; BufferedReader reader = null; private int fromPort; private String toIP; private int toPort; public TalkSend(int fromPort, String toIP, int toPort
多线程,网络聊天软件;
总是在想,如果我能坚持2年,会是怎样?
07-08 1888
<br />BOOL CChatDlg::InitSocket(void) { if(INVALID_SOCKET==(m_socket=socket(AF_INET,SOCK_DGRAM,0))) { MessageBox(TEXT("套接字创建失败!")); return FALSE; } SOCKADDR_IN addrSock; addrSock.sin_family=AF_INET; addrSock.sin_port=htons(6000); addrS
多线程实现双人聊天
qq_43750656的博客
11-04 1942
这个demo模拟了老师和学生的对话聊天功能。使用网络编程和多线程方式实现。 实现模拟老师和学生聊天的关键点就是 学生端既可以是发送方，也可以是接收方 老师端同样既可以是发送方，也可以是接收方 这样的话学生端需要同时开启接收和发送程序，老师端也要同时开启接收和发送程序 学生端的发送程序端口对应老师端的接收程序端口，老师端的发送程序端口对应学生端的接收程序端口。 接收方 public class TalkReceive implements Runnable { private String sen
编程实现TCP客户端之间多线程通信以及聊天页面的UI实现
最新发布
06-01
下面是一个简单的Java程序，实现了TCP客户端之间多线程通信以及聊天页面的UI实现。 ```java import java.awt.BorderLayout; import java.awt.EventQueue; import java.awt.event.ActionEvent; import java.awt....

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值