项目需求:
基于TCP协议,使用Java完成客户端和服务端的编写, 实现网络实时聊天.
技术点:
IO, 多线程, 网络编程socket, 内部类, 集合容器, 异常处理机制
相关技术
IO流
PrintWriter具有自动行刷新功能的缓冲字符输出流,其内部总是连接这BufferedWriter, 自动行刷新需要使用特定构造器PrintWriter pw = new PrintWriter(osw, true)
Socket
套接字封装了TCP协议的通讯细节，使用它可以与服务端建立网络链接，并通过它获取两个流，然后使用这两个流的读写操作完成与服务端的数据交互
- getOutputStream()该方法获取的字节输出流写出的字节会通过网络发送给对方计算机
- getInputStream()该方法获取的字节输入流会接受对方计算机通过网络(socket)发送的数据
ServerSocket
运行在服务端，作用有两个:
- 向系统申请服务端口，客户端的Socket就是通过这个端口与服务端建立连接的。
- 监听服务端口，一旦一个客户端通过该端口建立连接则会自动创建一个Socket，并通过该Socket与客户端进行数据交互.
多线程
线程:一个顺序的单一的程序执行流程就是一个线程。代码一句一句的有先后顺序的执行。
多线程:多个单一顺序执行的流程并发运行。造成"感官上同时运行"的效果。
并发:
多个线程实际运行是走走停停的。线程调度程序会将CPU运行时间划分为若干个时间片段并
尽可能均匀的分配给每个线程，拿到时间片的线程被CPU执行这段时间。当超时后线程调度
程序会再次分配一个时间片段给一个线程使得CPU执行它。如此反复。由于CPU执行时间在
纳秒级别，我们感觉不到切换线程运行的过程。所以微观上走走停停，宏观上感觉一起运行
的现象成为并发运行!
用途:
-
当出现多个代码片段执行顺序有冲突时，希望它们各干各的时就应当放在不同线程上"同时"运行
-
一个线程可以运行，但是多个线程可以更快时，可以使用多线程运行
开发过程相关问题
单线程的多客户端连接阻塞问题
服务端只调用过一次accept方法，因此只有第一个客户端链接时服务端接受了链接并返回了Socket,此时可以与其交互。而第二个客户端建立链接时，由于服务端没有再次调用accept，因此无法与其交互。
原方案:外层添加循环操作,依然无法实现多客户端连接
while(true) {
System.out.println("等待客户端链接...");
Socket socket = serverSocket.accept();
System.out.println("一个客户端链接了！");
/*
Socket提供的方法:
InputStream getInputStream()
获取的字节输入流读取的是对方计算机发送过来的字节
*/
InputStream in = socket.getInputStream();
InputStreamReader isr = new InputStreamReader(in, "UTF-8");
BufferedReader br = new BufferedReader(isr);
String message = null;
while ((message = br.readLine()) != null) {
System.out.println("客户端说:" + message);
}
}原因: 外层的while循环里面嵌套了一个内层循环(循环读取客户端发送消息)，而循环执行机制决定了里层循环不结束，外层循环则无法进入第二次操作.
解决方案:使用多线程将服务端与多客户端交互部分定义为线程任务
服务端发送消息给客户端
在服务端通过Socket获取输出流,客户端获取输入流,实现服务端将消息发送给客户端.此处让服务端直接将客户端发送过来的消息再回复给客户端来进行测试.
服务器端代码:
public void run(){
try{
/*Socket提供的方法:getInputStream()
获取的字节输入流读取的是对方计算机发送过来的字节*/
InputStream in = socket.getInputStream();
InputStreamReader isr = new InputStreamReader(in, "UTF-8");
BufferedReader br = new BufferedReader(isr);
OutputStream out = socket.getOutputStream();
OutputStreamWriter osw = new OutputStreamWriter(out,"UTF-8");
BufferedWriter bw = new BufferedWriter(osw);
PrintWriter pw = new PrintWriter(bw,true);
String message = null;
while ((message = br.readLine()) != null) {
System.out.println(host + "说:" + message);
//将消息回复给客户端
pw.println(host + "说:" + message);
}
}catch(IOException e){
e.printStackTrace();
}
}客户端代码
//通过socket获取输入流读取服务端发送过来的消息
InputStream in = socket.getInputStream();
InputStreamReader isr = new InputStreamReader(in,"UTF-8");
BufferedReader br = new BufferedReader(isr);
Scanner scanner = new Scanner(System.in);
while(true) {
String line = scanner.nextLine();
if("exit".equalsIgnoreCase(line)){
break;
}
pw.println(line);
line = br.readLine();
System.out.println(line);
}服务端转发消息给所有客户端
方案: 内部类可以访问外部类的成员,因此在Server类上定义一个数组allOut可以被所有内部类ClientHandler实例访问.从而将这些ClientHandler实例之间想互访的数据存放在这个数组中达到共享数据的目的.对此只需要将所有ClientHandler中的输出流都存入到数组allOut中就可以达到互访输出流转发消息的目的了
/**广播消息给每个客户端*/
private void sendMessage(String line){
synchronized (ServerV4.this){/**这里也必须加锁,带来问题:互斥太多,性能太差-->后续讲到消息队列,集群服务器解决!!*/
for(PrintWriter pw : allOut){
pw.println(line);/*注意此处遍历是为了实现广播的目的!,因为每个pw对应的客户端都不同,所以必须遍历*/
}
}
}客户端解决收发消息的冲突问题
方案: 由于客户端start方法中循环进行的操作顺序是先通过控制台输入一句话后将其发送给服务端,然后再读取服务端发送回来的一句话.这导致如果客户端不输入内容就无法收到服务端发送过来的其他信息(其他客户端的聊天内容).因此要将客户端中接收消息的工作移动到一个单独的线程上执行,才能保证收发消息互不打扰.
private class ServerHandler implements Runnable{
public void run(){
try {
/*
通过socket获取输入流读取服务端发送过来的消息
*/
InputStream in = socket.getInputStream();
InputStreamReader isr = new InputStreamReader(in, StandardCharsets.UTF_8);
BufferedReader br = new BufferedReader(isr);
String line;
while((line = br.readLine())!=null){
System.out.println(line);
}
} catch (IOException e) {
/**当客户端强行关闭,finally的socket close上面readline会报错,这里就可以catch异常,但实际不必要,因为摸个客户端是都不重要也没办法干涉,所以可以无视并且设置ServerHandler为守护线程!!*/
}
}
}服务端解决多线程并发安全问题
为了让能叫消息转发给所有客户端 在Server上添加了一个数组类型的属性allOut,并且共所有线程ClientHandler使用，这时对数组的操作要考虑并发安全问题,需要加锁
原方案1:this, 大多数情况下可以选择临界资源作为锁对象, 但是这里不行。由于数组是定长的，扩容实际是创建新数组，因此扩容后赋值给allOut时，之前锁定的对象就被GC回收了！而新扩容的数组并没有锁。
解决方案:选取外部类对象作为锁对象，因为这些内部类ClientHandler都从属于这个外部类对象Server.this. 还要考虑对数组的不同操作之间的互斥问题，道理同上。因此，对allOut数组的扩容，缩容和遍历操作要进行互斥
客户端异常断开连接问题
1:当客户端不再与服务端通讯时，需要调用socket.close()断开链接，此时会发送断开链接的信号给服务端。这时服务端的br.readLine()方法会返回null，表示客户端断开了链接。
2:当客户端链接后不输入信息发送给服务端时，服务端的br.readLine()方法是出于阻塞状态的，直到读取了一行来自客户端发送的字符串。
客户端
finally {
try {
/*
最终调用socket.close()与服务端进行TCP的挥手断开操作。
关闭socket的同时，通过socket获取的输入流或输出流也就自动关闭了
*/
socket.close();
} catch (IOException e) {
e.printStackTrace();
}服务端
} catch (IOException e) {
/**当客户端强行关闭,服务端这里readline会报错,这里就可以catch异常,但实际不必要,因为摸个客户端是都不重要也没办法干涉,所以可以无视并且设置server为守护线程!!*/
}finally {
/**将当前pw从输出流数组中删除*/
synchronized (ServerV4.this){/**增删必须互斥,即用同一个同步监视器,否则出现互斥异常*/
allOut.remove(pw);
}
System.out.println(host + "下线了,当前在线人数:" + allOut.size());
try {
socket.close();
} catch (IOException e) {
e.printStackTrace();
}
}完整代码
服务端:
package socket.server;
import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
import java.nio.charset.StandardCharsets;
import java.util.ArrayList;
import java.util.Collection;
public class ServerV4 {
private ServerSocket serverSocket;
/**private PrintWriter[] allOut = {};*/
private Collection<PrintWriter> allOut = new ArrayList<>();
public ServerV4() {
try {
System.out.println("正在启动服务端...");
serverSocket = new ServerSocket(8088);
System.out.println("服务端启动完毕!");
System.out.println("等待客户端链接");
} catch (IOException e) {
e.printStackTrace();
}
}
public void start(){
while (true){
try {
Socket socket = serverSocket.accept();//一直在监听
Runnable handler = new ClientHandler(socket);//局部内部类
Thread t = new Thread(handler);
t.start();
} catch (IOException e) {
e.printStackTrace();
}
}
}
public static void main(String[] args) {
ServerV4 server = new ServerV4();
server.start();
}
/**该线程任务是与指定客户端交互,内部类的目的是共享内部类之间要共享对方的输出流:外部类的私有属性allOut被内部类共享*/
private class ClientHandler implements Runnable{
private String host;//记录客户端的IP
private Socket socket;
public ClientHandler(Socket socket){
this.socket = socket;
host = socket.getInetAddress().getHostAddress();
}
@Override
public void run() {
PrintWriter pw = null;
try (InputStream iut = socket.getInputStream();
InputStreamReader isr = new InputStreamReader(iut, StandardCharsets.UTF_8);
BufferedReader br = new BufferedReader(isr);
/**
* 服务端这边通过socket获取输出流并用于发送消息给客户端
*/
OutputStream out = socket.getOutputStream();
OutputStreamWriter osw = new OutputStreamWriter(out,StandardCharsets.UTF_8);
BufferedWriter bw = new BufferedWriter(osw);
){
pw = new PrintWriter(bw,true);
synchronized (ServerV4.this){
allOut.add(pw);
}
System.out.println(host+"上线了，当前在线人数:"+allOut.size());
String line;/**BufferedReader的readline试图读取来自远端计算机的字符串,存在阻塞,用多线程解决此问题,输出到控制台*/
while ((line = br.readLine()) != null) {
sendMessage(host + "说" + line);
}
} catch (IOException e) {
/**当客户端强行关闭,服务端这里readline会报错,这里就可以catch异常,但实际不必要,因为摸个客户端是都不重要也没办法干涉,所以可以无视并且设置server为守护线程!!*/
}finally {
/**将当前pw从输出流数组中删除*/
synchronized (ServerV4.this){/**增删必须互斥,即用同一个同步监视器,否则出现互斥异常*/
allOut.remove(pw);
}
System.out.println(host + "下线了,当前在线人数:" + allOut.size());
try {
socket.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
/**广播消息给每个客户端*/
private void sendMessage(String line){
synchronized (ServerV4.this){/**这里也必须加锁,带来问题:互斥太多,性能太差-->后续讲到消息队列,集群服务器解决!!*/
for(PrintWriter pw : allOut){
pw.println(line);/*注意此处遍历是为了实现广播的目的!,因为每个pw对应的客户端都不同,所以必须遍历*/
}
}
}
}
}
客户端
package socket.client;
import java.io.*;
import java.net.Socket;
import java.nio.charset.StandardCharsets;
import java.util.Scanner;
/**
* 聊天室客户端
*/
public class Client_V3 {
/*
java.net.Socket 套接字
Socket封装了TCP协议的通讯细节，使得我们使用它就可以和服务端建立链接并
基于两条流的读写操作完成与远端计算机的交互。
我们可以把Socket想象为"电话"。
*/
private Socket socket;
public Client_V3(){
try {
/*
Socket提供的常用构造器:
Socket(String host,int port)
通过给定的IP地址与端口与远端计算机建立TCP链接。
参数1:远端计算机的IP地址信息
参数2:远端计算机打开的服务端口
我们通过IP可以找到网络上的该计算机，通过端口找到运行在该机器上的
服务端应用程序
*/
System.out.println("正在链接服务端...");
socket = new Socket("localhost",8088);
System.out.println("与服务端建立链接!");
} catch (IOException e) {
e.printStackTrace();
}
}
public void start(){/**守护线程类似于整个进程的一个默默无闻的小喽喽；它的生死无关重要，它却依赖整个进程而运行；哪天其他线程结束了，没有要执行的了，程序就结束了，理都没理守护线程，就把它中断了；
如果守护线程自己识时务，自己早点执行完毕，那就自己早点结束；整个程序也不必因此而挽留它；意： 由于守护线程的终止是自身无法控制的，因此千万不要把IO、File等重要操作逻辑分配给它；因为它不靠谱*/
try {
//启动一个线程用来读取服务端发送过来的消息
ServerHandler serverHandler = new ServerHandler();
Thread t = new Thread(serverHandler);
t.setDaemon(true); /**设置守护线程,当Java京城结束,所有线程生命周期结束时,结束该(多)线程*/
t.start();/**拓展:socket close是踢人;*/
/**防灌水:阻塞,但是阻塞给用户带来卡住的感觉所以不能用sleep,正确做法:对比两次发言时间够不够3秒?就行*/
OutputStream out = socket.getOutputStream();
OutputStreamWriter osw = new OutputStreamWriter(out, StandardCharsets.UTF_8);
BufferedWriter bw = new BufferedWriter(osw);
PrintWriter pw = new PrintWriter(bw,true);
Scanner scanner = new Scanner(System.in);
while(true) {
String line = scanner.nextLine();
if("exit".equals(line)){
break;
}
pw.println(line);
}
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
/*
最终调用socket.close()与服务端进行TCP的挥手断开操作。
关闭socket的同时，通过socket获取的输入流或输出流也就自动关闭了
*/
socket.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
public static void main(String[] args) {
Client_V3 client = new Client_V3();
client.start();
}
/**该线程负责读取服务端发送过来的消息,否则不写就不读太不合理,卡在while循环那里,即线程不能又读又写,现需要粪凯来*/
private class ServerHandler implements Runnable{
public void run(){
try {
/*
通过socket获取输入流读取服务端发送过来的消息
*/
InputStream in = socket.getInputStream();
InputStreamReader isr = new InputStreamReader(in, StandardCharsets.UTF_8);
BufferedReader br = new BufferedReader(isr);
String line;
while((line = br.readLine())!=null){
System.out.println(line);
}
} catch (IOException e) {
/**当客户端强行关闭,finally的socket close上面readline会报错,这里就可以catch异常,但实际不必要,因为摸个客户端是都不重要也没办法干涉,所以可以无视并且设置ServerHandler为守护线程!!*/
}
}
}
}FAQ:
什么是多线程并发安全问题?
当多个线程并发操作同一临界资源，由于线程切换时机不确定，导致执行顺序出现混乱。
解决办法:将并发操作改为同步操作就可有效的解决多线程并发安全问题.
同步监视器对象的选取?
对于同步的成员方法而言，同步监视器对象不可指定，只能是this
对于同步的静态方法而言，同步监视器对象也不可指定，只能是类对象
对于同步块而言，需要自行指定同步监视器对象，选取原则:
- 必须是引用类型
- 多个需要同步执行该同步块的线程看到的该对象必须是同一个
什么是互斥性?
当使用多个synchronized修饰了多个代码片段，并且指定的同步监视器都是同一个对象时，这些代码片段就是互斥的，多个线程不能同时在这些代码片段上执行。
497
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
