Java 在两个类之间共享线程池

我有一个固定大小的线程池12。现在我有两个实现Runnable的类，每个类有20个对象。我可以提交所有任务，线程池将定期完成其工作

我想做的是做一个分隔符。因此，如果我提交这40个任务，线程池将不会同时处理每个类中超过6个的任务。因此线程池的行为类似于2个较小的线程池，大小为6。java或guava的API有可能实现吗？

不用质疑“为什么”——可以使用信号量来实现，每个信号量都是以6的计数创建的，每个信号量同时将每种类型的任务数限定为6

以下是一个基本的工作示例：

public class TaskDelimitingTest {

  private enum Tasks {TASK1, TASK2};

  private static ConcurrentHashMap<Tasks, AtomicInteger> taskObserver = new ConcurrentHashMap<>();

  public static class Task implements Runnable {

    private static final Random random = new Random(System.currentTimeMillis());

    private final Semaphore sem = new Semaphore(6, true);
    private final Tasks task;

    public Task(Tasks task) {
      this.task = task;
    }

    @Override
    public void run() {
      try {
        taskObserver.get(task).incrementAndGet();
        Thread.sleep(random.nextInt(1000));
        taskObserver.get(task).decrementAndGet();
        sem.release();
      } catch (InterruptedException e) {
        e.printStackTrace();
      }
    }

    public void postToExecution(ExecutorService executor) {
      try {
        sem.acquire();
        executor.execute(this);
      } catch (InterruptedException e) {
        e.printStackTrace();
      }
    }
  }

  public static class Task1 extends Task {

    public Task1() {
      super(Tasks.TASK1);
    }

  }

  public static class Task2 extends Task {

    public Task2() {
      super(Tasks.TASK2);
    }

  }

  public static void main(String[] args) {
    ExecutorService executor = Executors.newFixedThreadPool(12);

    Thread t1 = new Thread(() -> {
      taskObserver.put(Tasks.TASK1, new AtomicInteger());
      IntStream.rangeClosed(1, 100).forEach(i -> {
        new Task1().postToExecution(executor);
        System.out.println(taskObserver);
      });
    });
    Thread t2 = new Thread(() -> {
      taskObserver.put(Tasks.TASK2, new AtomicInteger());
      IntStream.rangeClosed(1, 100).forEach(i -> {
        new Task2().postToExecution(executor);
        System.out.println(taskObserver);
      });
    });
    t1.start();
    t2.start();
  }

}

在某个时候，游泳池会饱和，然后只会这样：

    {TASK2=6, TASK1=6}
    ...

因此，每种类型最多只能同时执行6个线程。

不必质疑“为什么”——可以使用信号量来实现，每个信号量都是以6的计数创建的，每个信号量同时将每种类型的任务数限定为6

以下是一个基本的工作示例：

public class TaskDelimitingTest {

  private enum Tasks {TASK1, TASK2};

  private static ConcurrentHashMap<Tasks, AtomicInteger> taskObserver = new ConcurrentHashMap<>();

  public static class Task implements Runnable {

    private static final Random random = new Random(System.currentTimeMillis());

    private final Semaphore sem = new Semaphore(6, true);
    private final Tasks task;

    public Task(Tasks task) {
      this.task = task;
    }

    @Override
    public void run() {
      try {
        taskObserver.get(task).incrementAndGet();
        Thread.sleep(random.nextInt(1000));
        taskObserver.get(task).decrementAndGet();
        sem.release();
      } catch (InterruptedException e) {
        e.printStackTrace();
      }
    }

    public void postToExecution(ExecutorService executor) {
      try {
        sem.acquire();
        executor.execute(this);
      } catch (InterruptedException e) {
        e.printStackTrace();
      }
    }
  }

  public static class Task1 extends Task {

    public Task1() {
      super(Tasks.TASK1);
    }

  }

  public static class Task2 extends Task {

    public Task2() {
      super(Tasks.TASK2);
    }

  }

  public static void main(String[] args) {
    ExecutorService executor = Executors.newFixedThreadPool(12);

    Thread t1 = new Thread(() -> {
      taskObserver.put(Tasks.TASK1, new AtomicInteger());
      IntStream.rangeClosed(1, 100).forEach(i -> {
        new Task1().postToExecution(executor);
        System.out.println(taskObserver);
      });
    });
    Thread t2 = new Thread(() -> {
      taskObserver.put(Tasks.TASK2, new AtomicInteger());
      IntStream.rangeClosed(1, 100).forEach(i -> {
        new Task2().postToExecution(executor);
        System.out.println(taskObserver);
      });
    });
    t1.start();
    t2.start();
  }

}

在某个时候，游泳池会饱和，然后只会这样：

    {TASK2=6, TASK1=6}
    ...

---

因此，每种类型最多只能同时执行6个线程。

是否可以选择创建两个大小为6的池？如果我正确理解您的问题，我想您是在试图找出一个线程池中有多少活动线程，然后对它们进行划分，试一试@px06如果您知道问题中所述需求的活动计数，那么您赢得了什么？因此您希望拥有两个线程池的功能，但只使用一个线程池？为什么？您是如何提出这个看似非常随意的要求的？我所问的一切都是因为项目的要求。我知道我可以使用2个池或其他技术。但是这些要求是我刚才问的，而不是其他要求。创建两个大小为6的池是一种选择吗？如果我正确理解了你的问题，我想你是想找出一个线程池中有多少活动线程，然后对它们进行划分，试一试@px06如果您知道问题中所述需求的活动计数，那么您赢得了什么？因此您希望拥有两个线程池的功能，但只使用一个线程池？为什么？您是如何提出这个看似非常随意的要求的？我所问的一切都是因为项目的要求。我知道我可以使用2个池或其他技术。但是这些要求是我刚才问的，而不是其他的。