[java聊天室]服务器发送消息给客户端守护线程同步锁(三)
![[java聊天室]服务器发送消息给客户端守护线程同步锁(三)](http://pic.ttrar.cn/nice/%5bjava%e8%81%8a%e5%a4%a9%e5%ae%a4%5d%e6%9c%8d%e5%8a%a1%e5%99%a8.jpg)
守护线程
守护线程也称为:后台线程
- 守护线程是通过普通线程调用setDaemon(boolean on)方法设置而来的,因此创建上与普通线程无异.
- 守护线程的结束时机上有一点与普通线程不同,即:进程的结束.
- 进程结束:当一个进程中的所有普通线程都结束时,进程就会结束,此时会杀掉所有正在运行的守护线程.
package thread;/* 守护线程* 守护线程是通过普通线程调用setDaemon(true)设置而转变的。因此守护线程创建上* 与普通线程无异。* 但是结束时机上有一点不同:进程结束。* 当一个java进程中的所有普通线程都结束时，该进程就会结束，此时会强制杀死所有正在* 运行的守护线程。*/
public class DaemonThreadDemo {public static void main(String[] args) {Thread rose = new Thread(){public void run(){for(int i=0;i<5;i++){System.out.println("rose:let me go!");try {Thread.sleep(1000);} catch (InterruptedException e) {}}System.out.println("rose:啊啊啊啊啊啊AAAAAAAaaaaa....");System.out.println("噗通");}};Thread jack = new Thread(){public void run(){while(true){System.out.println("jack:you jump!i jump!");try {Thread.sleep(1000);} catch (InterruptedException e) {}}}};rose.start();jack.setDaemon(true);//设置守护线程必须在线程启动前进行jack.start();}
}通常当我们不关心某个线程的任务什么时候停下来,它可以一直运行,但是程序主要的工作都结束时它应当跟着结束时,这样的任务就适合放在守护线程上执行.比如GC(垃圾回收机制)就是在守护线程上运行的.
多线程并发安全问题
当多个线程并发操作同一临界资源,由于线程切换时机不确定,导致操作临界资源的顺序出现混乱严重时可能导致系统瘫痪.
临界资源:操作该资源的全过程同时只能被单个线程完成.package thread;/* 多线程并发安全问题* 当多个线程并发操作同一临界资源，由于线程切换的时机不确定，导致操作顺序出现* 混乱，严重时可能导致系统瘫痪。* 临界资源:同时只能被单一线程访问操作过程的资源。*/
public class SyncDemo {public static void main(String[] args) {Table table = new Table();Thread t1 = new Thread(){public void run(){while(true){int bean = table.getBean();Thread.yield();System.out.println(getName()+":"+bean);}}};Thread t2 = new Thread(){public void run(){while(true){int bean = table.getBean();/*static void yield()线程提供的这个静态方法作用是让执行该方法的线程主动放弃本次时间片。这里使用它的目的是模拟执行到这里CPU没有时间了，发生线程切换，来看并发安全问题的产生。*/Thread.yield();System.out.println(getName()+":"+bean);}}};t1.start();t2.start();}
}class Table{private int beans = 20;//桌子上有20个豆子public int getBean(){if(beans==0){throw new RuntimeException("没有豆子了!");}Thread.yield();return beans--;}
}synchronized关键字
synchronized有两种使用方式
- 在方法上修饰,此时该方法变为一个同步方法
- 同步块,可以更准确的锁定需要排队的代码片段
同步方法
当一个方法使用synchronized修饰后,这个方法称为"同步方法",即:多个线程不能同时 在方法内部执行.只能有先后顺序的一个一个进行. 将并发操作同一临界资源的过程改为同步执行就可以有效的解决并发安全问题.
package thread;/* 多线程并发安全问题* 当多个线程并发操作同一临界资源，由于线程切换的时机不确定，导致操作顺序出现* 混乱，严重时可能导致系统瘫痪。* 临界资源:同时只能被单一线程访问操作过程的资源。*/
public class SyncDemo {public static void main(String[] args) {Table table = new Table();Thread t1 = new Thread(){public void run(){while(true){int bean = table.getBean();Thread.yield();System.out.println(getName()+":"+bean);}}};Thread t2 = new Thread(){public void run(){while(true){int bean = table.getBean();/*static void yield()线程提供的这个静态方法作用是让执行该方法的线程主动放弃本次时间片。这里使用它的目的是模拟执行到这里CPU没有时间了，发生线程切换，来看并发安全问题的产生。*/Thread.yield();System.out.println(getName()+":"+bean);}}};t1.start();t2.start();}
}class Table{private int beans = 20;//桌子上有20个豆子/* 当一个方法使用synchronized修饰后，这个方法称为同步方法，多个线程不能* 同时执行该方法。* 将多个线程并发操作临界资源的过程改为同步操作就可以有效的解决多线程并发* 安全问题。* 相当于让多个线程从原来的抢着操作改为排队操作。*/public synchronized int getBean(){if(beans==0){throw new RuntimeException("没有豆子了!");}Thread.yield();return beans--;}
}同步块
有效的缩小同步范围可以在保证并发安全的前提下尽可能的提高并发效率.同步块可以更准确的控制需要多个线程排队执行的代码片段.
语法:
synchronized(同步监视器对象){需要多线程同步执行的代码片段
}同步监视器对象即上锁的对象,要想保证同步块中的代码被多个线程同步运行,则要求多个线程看到的同步监视器对象是同一个.
package thread;/* 有效的缩小同步范围可以在保证并发安全的前提下尽可能提高并发效率。 同步块* 语法:* synchronized(同步监视器对象){* 需要多个线程同步执行的代码片段* }* 同步块可以更准确的锁定需要多个线程同步执行的代码片段来有效缩小排队范围。*/
public class SyncDemo2 {public static void main(String[] args) {Shop shop = new Shop();Thread t1 = new Thread(){public void run(){shop.buy();}};Thread t2 = new Thread(){public void run(){shop.buy();}};t1.start();t2.start();}
}class Shop{public void buy(){/*在方法上使用synchronized，那么同步监视器对象就是this。*/
// public synchronized void buy(){Thread t = Thread.currentThread();//获取运行该方法的线程try {System.out.println(t.getName()+":正在挑衣服...");Thread.sleep(5000);/*使用同步块需要指定同步监视器对象，即:上锁的对象这个对象可以是java中任何引用类型的实例，只要保证多个需要排队执行该同步块中代码的线程看到的该对象是"同一个"即可*/synchronized (this) {
// synchronized (new Object()) {//没有效果!System.out.println(t.getName() + ":正在试衣服...");Thread.sleep(5000);}System.out.println(t.getName()+":结账离开");} catch (InterruptedException e) {e.printStackTrace();}}
}在静态方法上使用synchronized
当在静态方法上使用synchronized后,该方法是一个同步方法.由于静态方法所属类,所以一定具有同步效果.
静态方法使用的同步监视器对象为当前类的类对象(Class的实例).
package thread;/* 静态方法上如果使用synchronized，则该方法一定具有同步效果。*/
public class SyncDemo3 {public static void main(String[] args) {Thread t1 = new Thread(){public void run(){Boo.dosome();}};Thread t2 = new Thread(){public void run(){Boo.dosome();}};t1.start();t2.start();}
}
class Boo{/* synchronized在静态方法上使用是，指定的同步监视器对象为当前类的类对象。* 即:Class实例。* 在JVM中，每个被加载的类都有且只有一个Class的实例与之对应，后续讲反射* 知识点的时候会介绍类对象。*/public synchronized static void dosome(){Thread t = Thread.currentThread();try {System.out.println(t.getName() + ":正在执行dosome方法...");Thread.sleep(5000);System.out.println(t.getName() + ":执行dosome方法完毕!");} catch (InterruptedException e) {e.printStackTrace();}}}
}静态方法中使用同步块时,指定的锁对象通常也是当前类的类对象
public static void dosome(){/*静态方法中使用同步块时，指定同步监视器对象通常还是用当前类的类对象获取方式为:类名.class*/synchronized (Boo.class) {Thread t = Thread.currentThread();try {System.out.println(t.getName() + ":正在执行dosome方法...");Thread.sleep(5000);System.out.println(t.getName() + ":执行dosome方法完毕!");} catch (InterruptedException e) {e.printStackTrace();}}}
}互斥锁
当多个线程执行不同的代码片段,但是这些代码片段之间不能同时运行时就要设置为互斥的.
使用synchronized锁定多个代码片段,并且指定的同步监视器是同一个时,这些代码片段之间就是互斥的.
package thread;/* 互斥锁* 当使用synchronized锁定多个不同的代码片段，并且指定的同步监视器对象相同时，* 这些代码片段之间就是互斥的，即:多个线程不能同时访问这些方法。*/
public class SyncDemo4 {public static void main(String[] args) {Foo foo = new Foo();Thread t1 = new Thread(){public void run(){foo.methodA();}};Thread t2 = new Thread(){public void run(){foo.methodB();}};t1.start();t2.start();}
}
class Foo{public synchronized void methodA(){Thread t = Thread.currentThread();try {System.out.println(t.getName()+":正在执行A方法...");Thread.sleep(5000);System.out.println(t.getName()+":执行A方法完毕!");} catch (InterruptedException e) {e.printStackTrace();}}public synchronized void methodB(){Thread t = Thread.currentThread();try {System.out.println(t.getName()+":正在执行B方法...");Thread.sleep(5000);System.out.println(t.getName()+":执行B方法完毕!");} catch (InterruptedException e) {e.printStackTrace();}}
}注:
同步监视器对象的选取:
对于同步的成员方法而言，同步监视器对象不可指定，只能是this
对于同步的静态方法而言，同步监视器对象也不可指定，只能是类对象
对于同步块而言，需要自行指定同步监视器对象，选取原则:
1.必须是引用类型
2.多个需要同步执行该同步块的线程看到的该对象必须是同一个
聊天室(续)
实现服务端发送消息给客户端
在服务端通过Socket获取输出流,客户端获取输入流,实现服务端将消息发送给客户端.
这里让服务端直接将客户端发送过来的消息再回复给客户端来进行测试.
服务端代码:
package socket;import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;/* 聊天室服务端*/
public class Server {/* 运行在服务端的ServerSocket主要完成两个工作:* 1:向服务端操作系统申请服务端口，客户端就是通过这个端口与ServerSocket建立链接* 2:监听端口，一旦一个客户端建立链接，会立即返回一个Socket。通过这个Socket* 就可以和该客户端交互了 我们可以把ServerSocket想象成某客服的"总机"。用户打电话到总机，总机分配一个* 电话使得服务端与你沟通。*/private ServerSocket serverSocket;/* 服务端构造方法，用来初始化*/public Server(){try {System.out.println("正在启动服务端...");/*实例化ServerSocket时要指定服务端口，该端口不能与操作系统其他应用程序占用的端口相同，否则会抛出异常:java.net.BindException:address already in use端口是一个数字，取值范围:0-65535之间。6000之前的的端口不要使用，密集绑定系统应用和流行应用程序。*/serverSocket = new ServerSocket(8088);System.out.println("服务端启动完毕!");} catch (IOException e) {e.printStackTrace();}}/* 服务端开始工作的方法*/public void start(){try {while(true) {System.out.println("等待客户端链接...");/*ServerSocket提供了接受客户端链接的方法:Socket accept()这个方法是一个阻塞方法，调用后方法"卡住"，此时开始等待客户端的链接，直到一个客户端链接，此时该方法会立即返回一个Socket实例通过这个Socket就可以与客户端进行交互了。可以理解为此操作是接电话，电话没响时就一直等。*/Socket socket = serverSocket.accept();System.out.println("一个客户端链接了！");//启动一个线程与该客户端交互ClientHandler clientHandler = new ClientHandler(socket);Thread t = new Thread(clientHandler);t.start();}} catch (IOException e) {e.printStackTrace();}}public static void main(String[] args) {Server server = new Server();server.start();}/* 定义线程任务* 目的是让一个线程完成与特定客户端的交互工作*/private class ClientHandler implements Runnable{private Socket socket;private String host;//记录客户端的IP地址信息public ClientHandler(Socket socket){this.socket = socket;//通过socket获取远端计算机地址信息host = socket.getInetAddress().getHostAddress();}public void run(){try{/*Socket提供的方法:InputStream 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();}}}}客户端代码:
package socket;import java.io.*;
import java.net.Socket;
import java.util.Scanner;/* 聊天室客户端*/
public class Client {/*java.net.Socket 套接字Socket封装了TCP协议的通讯细节，我们通过它可以与远端计算机建立链接，并通过它获取两个流(一个输入，一个输出)，然后对两个流的数据读写完成与远端计算机的数据交互工作。我们可以把Socket想象成是一个电话，电话有一个听筒(输入流)，一个麦克风(输出流)，通过它们就可以与对方交流了。*/private Socket socket;/* 构造方法，用来初始化客户端*/public Client(){try {System.out.println("正在链接服务端...");/*实例化Socket时要传入两个参数参数1:服务端的地址信息可以是IP地址，如果链接本机可以写"localhost"参数2:服务端开启的服务端口我们通过IP找到网络上的服务端计算机，通过端口链接运行在该机器上的服务端应用程序。实例化的过程就是链接的过程，如果链接失败会抛出异常:java.net.ConnectException: Connection refused: connect*/socket = new Socket("localhost",8088);System.out.println("与服务端建立链接!");} catch (IOException e) {e.printStackTrace();}}/* 客户端开始工作的方法*/public void start(){try {/*Socket提供了一个方法:OutputStream getOutputStream()该方法获取的字节输出流写出的字节会通过网络发送给对方计算机。*///低级流，将字节通过网络发送给对方OutputStream out = socket.getOutputStream();//高级流，负责衔接字节流与字符流，并将写出的字符按指定字符集转字节OutputStreamWriter osw = new OutputStreamWriter(out,"UTF-8");//高级流，负责块写文本数据加速BufferedWriter bw = new BufferedWriter(osw);//高级流，负责按行写出字符串，自动行刷新PrintWriter pw = new PrintWriter(bw,true);//通过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);}} catch (IOException e) {e.printStackTrace();} finally {try {/*通讯完毕后调用socket的close方法。该方法会给对方发送断开信号。*/socket.close();} catch (IOException e) {e.printStackTrace();}}}public static void main(String[] args) {Client client = new Client();client.start();}
}服务端转发消息给所有客户端
当一个客户端发送一个消息后,服务端收到后如何转发给所有客户端.
问题:例如红色的线程一收到客户端消息后如何获取到橙色的线程二中的输出流?得不到就无法将消息转发给橙色的客户端(进一步延伸就是无法转发给所有其他客户端)
解决:内部类可以访问外部类的成员,因此在Server类上定义一个集合allOut可以被所有内部类ClientHandler实例访问.从而将这些ClientHandler实例之间想互访的数据存放在这个集合中达到共享数据的目的.对此只需要将所有ClientHandler中的输出流都存入到集合allOut中就可以达到互访输出流转发消息的目的了.
服务端代码:
package socket;import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.Arrays;
import java.util.List;
import java.util.ArrayList;/* 聊天室服务端*/
public class Server {/* 运行在服务端的ServerSocket主要完成两个工作:* 1:向服务端操作系统申请服务端口，客户端就是通过这个端口与ServerSocket建立链接* 2:监听端口，一旦一个客户端建立链接，会立即返回一个Socket。通过这个Socket* 就可以和该客户端交互了 我们可以把ServerSocket想象成某客服的"总机"。用户打电话到总机，总机分配一个* 电话使得服务端与你沟通。*/private ServerSocket serverSocket;/*存放所有客户端输出流，用于广播消息*/private List<PrintWriter> allOut = new ArrayList();/* 服务端构造方法，用来初始化*/public Server(){try {System.out.println("正在启动服务端...");/*实例化ServerSocket时要指定服务端口，该端口不能与操作系统其他应用程序占用的端口相同，否则会抛出异常:java.net.BindException:address already in use端口是一个数字，取值范围:0-65535之间。6000之前的的端口不要使用，密集绑定系统应用和流行应用程序。*/serverSocket = new ServerSocket(8088);System.out.println("服务端启动完毕!");} catch (IOException e) {e.printStackTrace();}}/* 服务端开始工作的方法*/public void start(){try {while(true) {System.out.println("等待客户端链接...");/*ServerSocket提供了接受客户端链接的方法:Socket accept()这个方法是一个阻塞方法，调用后方法"卡住"，此时开始等待客户端的链接，直到一个客户端链接，此时该方法会立即返回一个Socket实例通过这个Socket就可以与客户端进行交互了。可以理解为此操作是接电话，电话没响时就一直等。*/Socket socket = serverSocket.accept();System.out.println("一个客户端链接了！");//启动一个线程与该客户端交互ClientHandler clientHandler = new ClientHandler(socket);Thread t = new Thread(clientHandler);t.start();}} catch (IOException e) {e.printStackTrace();}}public static void main(String[] args) {Server server = new Server();server.start();}/* 定义线程任务* 目的是让一个线程完成与特定客户端的交互工作*/private class ClientHandler implements Runnable{private Socket socket;private String host;//记录客户端的IP地址信息public ClientHandler(Socket socket){this.socket = socket;//通过socket获取远端计算机地址信息host = socket.getInetAddress().getHostAddress();}public void run(){try{/*Socket提供的方法:InputStream 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);//将该输出流存入allOut中 allOut.add(pw);String message = null;while ((message = br.readLine()) != null) {System.out.println(host + "说:" + message);//将消息回复给所有客户端for(PrintWriter o : allOut) {o.println(host + "说:" + message);}}}catch(IOException e){e.printStackTrace();}}}}完善服务端的功能
功能1:广播消息
1:将广播消息的操作提取成一个方法,并取名为sendMessage
2:在线程启动后(ClientHandler的run方法中)当我们将该客户端输出流存入共享集合allOut后 就广播给所有客户端该用户上线了,并且利用allOut集合的size作为当前在线人数.
3:在run方法的异常处理机制最后添加finally,用于处理客户端断开后的操作
3.1:将PrintWriter从try中定义改为在try之前定义,提高它的作用域,以便在finally中将其从 allOut集 合中移除
3.2:广播消息给所有客户端告知该客户端下线了.
public class Server5 {/*java.net.ServerSocket运行在服务端的ServerSocket的主要任务:1.向服务端申请服务端口，客户端就是通过该端口与服务器建立连接的2.监听服务端口，一旦一个客户端连接了就会立即创建一个Socket实例与之交互我们将ServerSocket比喻为某客服中心的"总机"*/private ServerSocket serverSocket;//该集合用于保存所有客户端的输出流,用于广播消息private List<PrintWriter> allOut = new ArrayList<>();public Server5(){try {/*如果端口被其他程序占用了，则会发生java.net.BindException异常: Address already in use解决办法:1.更换端口号2.杀死占用该端口的进程(通常发生在服务端启动两次导致的情况下)*/System.out.println("正在启动服务端");serverSocket = new ServerSocket(8088);System.out.println("服务端启动完毕!");} catch (IOException e) {e.printStackTrace();}}public void start(){/*ServerSocket提供的重要方法:Socket accept()用于接收客户端的连接，并返回一个Socket实例与连接的客户端交互该方法是一个阻塞方法，调用后程序会"卡住"，直到一个客户端连接为止*/try {while(true){System.out.println("等待客户端连接");Socket socket = serverSocket.accept(); //接电话System.out.println("一个客户端连接上了");//启动一个线程负责与该客户端交互ClientHandler handler = new ClientHandler(socket);Thread t = new Thread(handler);t.start();}} catch (IOException e) {e.printStackTrace();}}public static void main(String[] args) {Server5 server = new Server5();server.start();}/* 该线程任务负责与指定的客户端交互*/private class ClientHandler implements Runnable{private Socket socket;private String host;//记录该客户端的IP地址public ClientHandler(Socket socket){this.socket = socket;//通过socket获取远端计算机的IP地址的字符串格式host = socket.getInetAddress().getHostAddress();}public void run() {//提高pw的作用域,以便在finally中可以将其从allOut集合中删除PrintWriter pw = null;try {InputStream in = socket.getInputStream();InputStreamReader isr = new InputStreamReader(in, StandardCharsets.UTF_8);BufferedReader br = new BufferedReader(isr);OutputStream out = socket.getOutputStream();OutputStreamWriter osw = new OutputStreamWriter(out, StandardCharsets.UTF_8);BufferedWriter bw = new BufferedWriter(osw);pw = new PrintWriter(bw,true);allOut.add(pw);sendMessage(host+"上线了!,当前在线人数"+allOut.size());//多线程向集合中添加元素可能产生并发安全问题,因此必须同步String message;while((message=br.readLine())!=null){//V5:读取到客户端消息广播时改为调用sendMessage方法sendMessage(host + "说:" + message);}} catch (IOException e) {//在finally中处理客户端断开后的操作} finally {//将该客户端的输出流从allOut集合中删除synchronized (allOut) {allOut.remove(pw);}//广播该客户端下线了sendMessage(host+"下线了,当前在线人数:"+allOut.size());try {//关闭socket,释放资源socket.close();} catch (IOException e) {e.printStackTrace();}}}/* 功能一,实现广播消息的方法:* 将消息转发给所有客户端* @param message*/private void sendMessage(String message){System.out.println(message);//新循环就是迭代器,迭代器要求遍历过程不能用集合方法增删元素,所以需要和上面的增删互斥synchronized (allOut) {for (PrintWriter o : allOut) {o.println(message);}}}}}上面的客户端start方法中的主要逻辑是先等待用户在控制台上输入一行字符串,然后将其发送给服务端后再读取来自服务端发送过来的消息.
但是由于上面的服务器已经改成了可以将其他客户端的消息也转发给所有有客户端的操作,这会导致有源源不断的新消息发送给客户端,然后如果客户端必须先等待用户输入一行再接收一行来自服务端消息的话,会导致接收消息不畅问题.
为了解决这个问题:
我们应当将发送消息和接收消息的操作分别在不同的线程上运行,才能做到互不干涉.
实现:
我们将发送消息还定义在start方法中由客户端的主线程执行即可,将读取消息单独定义到一个线程上执行
1:定义内部类ServerHandler,这是一个线程任务,主要工作就是读取来自服务端发送的消息并输出到客户端的控制台上
2:在start方法一开始就启动一个线程来执行ServerHandler这个任务,不断接收来自服务端的消息.
客户端代码如下:
public class Client4 {private Socket socket;public Client4(){try {/*实例化Socket时就是与远程服务器建立连接的过程需要传递两个参数:1.服务器的IP地址，用于找到网络上对方的计算机2.服务端口，用于找到服务器计算机上的服务端的应用程序(软件)*/System.out.println("正在连接服务器...");socket=new Socket("176.223.2.38",8086);//socket = new Socket("localhost",8088); //localhost表示本机IPSystem.out.println("与服务器建立连接成功!");} catch (IOException e) {e.printStackTrace();}}public void start(){try {//V4:启动用于接收服务端消息的线程ServerHandler handler = new ServerHandler();Thread t = new Thread(handler);t.start();//低级流，作用:将写出的字节发送给建立连接的远程计算机OutputStream out = socket.getOutputStream();OutputStreamWriter osw = new OutputStreamWriter(out, StandardCharsets.UTF_8);BufferedWriter bw = new BufferedWriter(osw);PrintWriter pw = new PrintWriter(bw,true); //自动行刷新Scanner scan = new Scanner(System.in);while(true){String line = scan.nextLine();if("exit".equals(line)){break;}pw.println(line);}} catch (IOException e) {e.printStackTrace();} finally {try {socket.close(); //与服务端断开连接} catch (IOException e) {e.printStackTrace();}}}public static void main(String[] args) {Client4 client = new Client4();client.start();}/* V4:该线程任务是负责不断接收来自服务端发送过来的消息并输出到控制台*/private class ServerHandler implements Runnable{public void run(){try {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) {e.printStackTrace();}}}
}
