JAVA自动关闭服务器的方法 代码分享

2021-06-30 10:34:28 浏览数 (2721)

普通实现的服务器都无法关闭自身，只有依靠操作系统来强行终止服务程序。这种强行终止服务程序的方式尽管简单方便，但会导致服务器中正在执行的任务突然中断。如果服务器处理的任务非常重要，不允许被突然中断，应该由服务器自身在恰当的时刻关闭自己

代码如下：

  • EchoServer类
  1. package ShutdownServer;
  2. import java.io.*;
  3. import java.net.ServerSocket;
  4. import java.net.Socket;
  5. import java.net.SocketException;
  6. import java.net.SocketTimeoutException;
  7. import java.util.concurrent.ExecutorService;
  8. import java.util.concurrent.Executors;
  9. import java.util.concurrent.RejectedExecutionException;
  10. import java.util.concurrent.TimeUnit;
  11. public class EchoServer {
  12.     private int port=8000;
  13.     private ServerSocket serverSocket;
  14.     private ExecutorService executorService; //线程池
  15.     private final int POOL_SIZE=4; //单个CPU时线程池中工作线程的数目
  16.     private int portForShutdown=8001; //用于监听关闭服务器命令的端口
  17.     private ServerSocket serverSocketShutdown;
  18.     private boolean isShutdown=false; //服务器是否已经关闭
  19.     private Thread shutdownThread=new Thread(){
  20.         //负责关闭服务器的线程
  21.         public void run(){
  22.             while(!isShutdown){
  23.                 Socket socketForShutdown=null;
  24.                 try{
  25.                     socketForShutdown=serverSocketShutdown.accept();
  26.                     BufferedReader br=new BufferedReader(
  27.                             new InputStreamReader(socketForShutdown.getInputStream())
  28.                     );
  29.                     String command=br.readLine();
  30.                     if (command.equals("shutdown")){
  31.                         long beginTime=System.currentTimeMillis();
  32.                         socketForShutdown.getOutputStream().write("服务器正在关闭\r\n".getBytes());
  33.                         isShutdown=true;
  34.                         //请求关闭线程池
  35.                         //线程池不再接收新的任务，但会继续执行完工作队列中现有的任务
  36.                         executorService.shutdown();
  37.                         //等待关闭线程池，每次等待的超时时间为30s
  38.                         //当使用awaitTermination时，主线程会处于一种等待的状态，等待线程池中所有的线程都运行完毕后才继续运行。
  39.                         //如果等待的时间超过指定的时间，但是线程池中的线程运行完毕，那么awaitTermination()返回true。执行分线程已结束
  40.                         //如果等待的时间超过指定的时间，但是线程池中的线程未运行完毕，那么awaitTermination()返回false。不执行分线程已结束
  41.                         //如果等待时间没有超过指定时间，等待！
  42.                         //可以用awaitTermination()方法来判断线程池中是否有继续运行的线程。
  43.                         while(!executorService.isTerminated())
  44.                             executorService.awaitTermination(30, TimeUnit.SECONDS);
  45.                             //关闭与EchoClient客户通信的ServerSocket
  46.                             serverSocket.close();
  47.                             long endTime=System.currentTimeMillis();
  48.                             socketForShutdown.getOutputStream().write(("服务器关闭，"+"关闭服务器用了"+(endTime-beginTime)+"ms\r\n").getBytes());
  49.                             socketForShutdown.close();
  50.                             serverSocketShutdown.close();
  51.                             System.out.println("服务器关闭");
  52.                     }
  53.                     else {
  54.                         socketForShutdown.getOutputStream().write("错误的命令\r\n".getBytes());
  55.                         socketForShutdown.close();
  56.                     }
  57.                 } catch (Exception e) {
  58.                     e.printStackTrace();
  59.                 }
  60.             }
  61.         }
  62.     };
  63.     public EchoServer() throws IOException {
  64.         serverSocket=new ServerSocket(port);
  65.         //设定等待客户连接的超时时间为60s
  66.         serverSocket.setSoTimeout(60000);
  67.         serverSocketShutdown=new ServerSocket(portForShutdown);
  68.         //创建线程池
  69.         executorService= Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors() * POOL_SIZE);
  70.         shutdownThread.start();
  71.         System.out.println("服务器启动");
  72.     }
  73.     public void service(){
  74.         while(!isShutdown){
  75.             Socket socket=null;
  76.             try {
  77.                 //可能会抛出SocketTimeoutException和SocketException
  78.                 socket=serverSocket.accept();
  79.                 //把等待客户发送数据的超时时间设为60s
  80.                 socket.setSoTimeout(60000);
  81.                 //可能会抛出RejectedExecutionException
  82.                 executorService.execute(new Handler(socket));
  83.             }catch (SocketTimeoutException e){
  84.                 //不必处理等待客户连接时出现的异常
  85.             }catch (RejectedExecutionException e) {
  86.                 try {
  87.                     if (socket != null)
  88.                         socket.close();
  89.                 } catch (IOException ex) {
  90.                     return;
  91.                 }
  92.             }catch (SocketException e){
  93.                 if (e.getMessage().indexOf("socket closed")!=-1)
  94.                     return;
  95.             }catch (IOException e){
  96.                 e.printStackTrace();
  97.             }
  98.         }
  99.     }
  100.     public static void main(String[] args) throws IOException { //main方法抛出异常，异常直接交给虚拟机，虚拟机直接结束异常
  101.         new EchoServer().service();
  102.     }
  103. }
  104.  
  105. //负责与单个客户通信的任务
  106. class Handler implements Runnable{
  107.     private Socket socket;
  108.     public Handler(Socket socket){
  109.         this.socket=socket;
  110.     }
  111.     private PrintWriter getWriter(Socket socket) throws IOException{
  112.         OutputStream socketOut=socket.getOutputStream();
  113.         return new PrintWriter(socketOut,true);
  114.     }
  115.     private BufferedReader getReader(Socket socket) throws IOException{
  116.         InputStream socketIn=socket.getInputStream();
  117.         return new BufferedReader(new InputStreamReader(socketIn));
  118.     }
  119.     public String echo(String msg){
  120.         return "echo: "+msg;
  121.     }
  122.     @Override
  123.     public void run() {
  124.         try{
  125.             System.out.println("New connection accepted "+socket.getInetAddress()+":"+socket.getPort());
  126.             BufferedReader br=getReader(socket);
  127.             PrintWriter pw=getWriter(socket);
  128.             String msg=null;
  129.             //接收和发送数据，直到通信结束
  130.             while((msg=br.readLine())!=null){
  131.                 System.out.println("from "+socket.getInetAddress()+":"+socket.getPort()+">"+msg);
  132.                 pw.println(echo(msg));
  133.                 if (msg.equals("bye"))
  134.                     break;
  135.             }
  136.         } catch (IOException e) {
  137.             e.printStackTrace();
  138.         }finally{
  139.             try{
  140.                 if (socket!=null)
  141.                     socket.close();
  142.             }catch (IOException e){
  143.                 e.printStackTrace();
  144.             }
  145.         }
  146.     }
  147. }
  • AdminClient类（负责向EchoServer发送“shutdown”命令，关闭服务器）
  1. package ShutdownServer;
  2. import java.io.BufferedReader;
  3. import java.io.IOException;
  4. import java.io.InputStreamReader;
  5. import java.io.OutputStream;
  6. import java.net.Socket;
  7. public class AdminClient {
  8.     public static void main(String[] args){
  9.         Socket socket=null;
  10.         try{
  11.             socket=new Socket("localhost",8001);
  12.             //发送关闭命令
  13.             OutputStream socketOut=socket.getOutputStream();
  14.             //Scanner scanner=new Scanner(System.in);
  15.             //String order=scanner.next();
  16.             socketOut.write("shutdown\r\n".getBytes());
  17.             //接收服务器反馈
  18.             BufferedReader br=new BufferedReader(new InputStreamReader(socket.getInputStream()));
  19.             String msg=null;
  20.             while ((msg=br.readLine())!=null){
  21.                 System.out.println(msg);
  22.             }
  23.         } catch (Exception e) {
  24.             e.printStackTrace();
  25.         }finally {
  26.             try{
  27.                 if (socket!=null)
  28.                     socket.close();
  29.             } catch (IOException e) {
  30.                 e.printStackTrace();
  31.             }
  32.         }
  33.     }
  34. }
  • Client类（客户，与服务器进行通讯）
  1. package ShutdownServer;
  2. import java.io.*;
  3. import java.net.Socket;
  4. public class Client {
  5.     private String host="localhost";
  6.     private int port=8000;
  7.     private Socket socket;
  8.     public Client() throws IOException {
  9.         socket=new Socket(host,port);
  10.     }
  11.     private PrintWriter getWriter(Socket socket) throws IOException{
  12.         OutputStream socketOut=socket.getOutputStream();
  13.         return new PrintWriter(socketOut,true);
  14.     }
  15.     private BufferedReader getReader(Socket socket) throws IOException{
  16.         InputStream socketIn=socket.getInputStream();
  17.         return new BufferedReader(new InputStreamReader(socketIn));
  18.     }
  19.     public void talk() throws IOException{
  20.         try{
  21.             BufferedReader br=getReader(socket);
  22.             PrintWriter pw=getWriter(socket);
  23.             BufferedReader localReader=new BufferedReader(new InputStreamReader(System.in));
  24.             String msg=null;
  25.             while((msg=localReader.readLine()) != null){
  26.                 pw.println(msg);
  27.                 System.out.println(br.readLine());
  28.                 if (msg.equals("bye")){
  29.                     break;
  30.                 }
  31.             }
  32.         }catch (IOException e){
  33.             e.printStackTrace();
  34.         }
  35.         finally {
  36.             try{
  37.                 socket.close();
  38.             }catch (IOException e){
  39.                 e.printStackTrace();
  40.             }
  41.         }
  42.     }
  43.     public static void main(String args[]) throws IOException {
  44.         new Client().talk();
  45.     }
  46. }

shutdownThread线程负责关闭服务器，它一直监听8001端口，如果接收到了AdminClient发送的“shutdown”命令，就把isShutdown设置为true。

在关闭服务器时，我们使用了最常用的方法，先调用线程池的shutdown()方法，接着调用线程池的awaitTermination()方法。

  1. executorService.shutdown();
  2.                         //等待关闭线程池，每次等待的超时时间为30s
  3.                         //当使用awaitTermination时，主线程会处于一种等待的状态，等待线程池中所有的线程都运行完毕后才继续运行。
  4.                         //如果等待的时间超过指定的时间，但是线程池中的线程运行完毕，那么awaitTermination()返回true。执行分线程已结束
  5.                         //如果等待的时间超过指定的时间，但是线程池中的线程未运行完毕，那么awaitTermination()返回false。不执行分线程已结束
  6.                         //如果等待时间没有超过指定时间，等待！
  7.                         //可以用awaitTermination()方法来判断线程池中是否有继续运行的线程。
  8.                         while(!executorService.isTerminated())
  9.                             executorService.awaitTermination(30, TimeUnit.SECONDS);

在线程池执行了shutdown()方法后，线程池不会在接收新的任务，同时该线程因为调用awaitTermination()方法而发生阻塞，直到线程池中所有线程的任务执行完毕，该线程才会继续向下

运行结果

先运行EchoServer，Client，AdminClient后，再开启一客户程序Client1，显示Client1无法被加入线程池

  • EchoServer（只显示连接了Client，未连接Client1）
  • Client
  • Client2（向服务器发送消息，收到null）
  • AdminClient（在Client没有运行结束时，被阻塞）

当Client输入“bye”结束运行后，AdminClient关闭服务器

  • Client类
  • EchoServer类
  • AdminClient类

参考Java网络编程核心技术详解

到此这篇关于教你利用JAVA实现可以自行关闭服务器的方法的文章就介绍到这了,更多相关JAVA自行关闭服务器内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们！