Java 使用ThreadPoolExecutor和DiscardPolicy

我需要使用ThreadPoolExecutor创建一个客户机队列，并且如果它超过某个数字（例如5），就能够删除客户机。这是一种DDOS保护。当客户端#6请求我的服务器时，它被丢弃，等等。我得到了我的服务器和客户端代码，但我不知道如何实现ThreadPoolExecutor和DiscardPolicy。想法还是例子

简单服务器：

   import java.io.IOException;
    import java.io.InputStream;
    import java.io.ObjectInputStream;
    import java.io.OutputStream;
    import java.net.ServerSocket;
    import java.net.Socket;
    import java.util.concurrent.ExecutorService;
    import java.util.concurrent.Executors;
    import java.util.concurrent.Semaphore;
    import java.util.logging.Level;
    import java.util.logging.Logger;

    public class Server {

    public static void main(String[] args) throws IOException, ClassNotFoundException, InterruptedException {

        ServerSocket server = new ServerSocket (3000);

        ExecutorService es = Executors.newFixedThreadPool(2);

        Semaphore semaphore = new Semaphore (2);

        while(true){

        semaphore.acquire();

        Socket accept2 = server.accept();

        es.execute(()->{
            try (Socket accept = accept2) {
            serve(accept);
            } catch (Exception exception) {
                Logger.getLogger(Server.class.getName()).log(Level.SEVERE, null, exception);
            } 
            finally {
                semaphore.release();

            }
        });        

        }

    }

    private static void serve(final Socket accept) throws ClassNotFoundException, IOException {
        InputStream inputStream = accept.getInputStream();
        OutputStream outputStream = accept.getOutputStream();

        ObjectInputStream inputStream2 = new ObjectInputStream (inputStream);

        while (true){
            Object readObject = inputStream2.readObject();
            System.out.println(readObject);
        }

        }

    }

还有一个简单的客户端：

  import java.io.IOException;
    import java.io.ObjectOutputStream;
    import java.net.Socket;

    public class Client {

    public static void main(String[] args) throws IOException, InterruptedException {
        Socket socket = new Socket ("localhost", 3000);
        ObjectOutputStream oos = new ObjectOutputStream (
                socket.getOutputStream());
        oos.writeObject("First!");
        Thread.sleep(10000);
        oos.writeObject("First again!");
        Thread.sleep(10000);
        oos.writeObject("First again again!");

        }

    }

---

将

ThreadPoolExecutor

与

DiscardPolicy

一起使用，如下所示：

  int poolSize=1;
  int maxPoolSize=2;
  int queueSize=5;
  long aliveTive=1000;
  ArrayBlockingQueue<Runnable> queue= new ArrayBlockingQueue<Runnable>(queueSize);
  ThreadPoolExecutor executor= new ThreadPoolExecutor(poolSize,maxPoolSize,aliveTive,
                    TimeUnit.MILLISECONDS,queue,new ThreadPoolExecutor.DiscardPolicy());
}

intpoolsize=1；
int maxPoolSize=2；
int queueSize=5；
长有效期=1000；
ArrayBlockingQueue=新的ArrayBlockingQueue（queueSize）；
ThreadPoolExecutor executor=新的ThreadPoolExecutor（池大小、maxPoolSize、Aliveive、，
TimeUnit.ms，队列，新ThreadPoolExecutor.DiscardPolicy（））；
}

被拒绝的任务：

在方法execute（Runnable）中提交的新任务在执行器关闭时，以及在执行器对最大线程和工作队列容量使用有限边界且已饱和时，将被拒绝

在任何一种情况下，execute方法都会调用其

RejectedExecutionHandler的
RejectedExecutionHandler.rejectedExecution（Runnable，ThreadPoolExecutor）
方法

提供了四个预定义的处理程序策略：

在默认的
ThreadPoolExecutor.AbortPolicy
中，处理程序在拒绝时抛出运行时拒绝执行异常
在
ThreadPoolExecutor.CallerRunPolicy
中，调用自身执行的线程运行任务。这提供了一种简单的反馈控制机制，可以降低提交新任务的速度
在
ThreadPoolExecutor.DiscardPolicy
中，无法执行的任务被简单地丢弃
在
ThreadPoolExecutor.DiscardOldestPolicy
中，如果未关闭执行器，将丢弃工作队列头部的任务，然后重试执行（可能再次失败，导致重复执行）
有关更多详细信息，请查看此页面