使用ThreadPoolExecutor和DiscardPolicy

Question

我需要使用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!");

        }

    }

Answer 1

将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());
}

拒绝任务：

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

在这两种情况下，execute方法都会调用其RejectedExecutionHandler.rejectedExecution(Runnable, ThreadPoolExecutor)方法的RejectedExecutionHandler。

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

1. 在默认的ThreadPoolExecutor.AbortPolicy中，处理程序在拒绝时抛出一个运行时RejectedExecutionException。
2. 在ThreadPoolExecutor.CallerRunsPolicy中，调用执行本身的线程运行任务。这提供了一个简单的反馈控制机制，它将减慢新任务提交的速度。
3. 在ThreadPoolExecutor.DiscardPolicy中，不能执行的任务被简单地删除。
4. 在ThreadPoolExecutor.DiscardOldestPolicy中，如果未关闭执行器，则删除工作队列顶部的任务，然后重试执行(这可能再次失败，导致重复执行)。

有关更多细节，请查看此文档页面