使用locks.ReentrantLock实现Java basic线程池

我是Java新手。我只是在尝试线程，我想创建一个类似于线程池的东西（如果这是我正在做的…）

基本上，我有一个while循环，它激发线程直到还有任务要执行&而最大并发线程数不大于n。每个线程都使用java.util.concurrent.locks.ReentrantLock在每个线程中减少的任务计数变量和线程计数变量周围提供一个锁，线程计数变量在线程开始时增加，在线程结束前减少（代码气味？）：

我确信我使用线程或锁的方式一定是完全错误的。。但是作为一名java新手，我可能会错过很多东西（甚至可能是最基本的东西），如果能给我一些帮助，让我重回正轨，我将不胜感激。。。！ 多谢各位

我将此用作线程的参考：

然后，这个stackoverflow的答案是了解如何使用ReentrantLock：

这适用于无法修改外部变量的闭包解决方案（使用数组值）： 您不能使用该功能吗

如果不是，问题是

运行线程

在每个线程启动并获得锁之前不会增加。实际上，主线程可能会运行相当长的一段时间，同时无限制地旋转新线程

一种解决方案可能是在启动新线程之前增加主线程上的

runningThreads

变量，但在每个工作线程中保留减少变量

我不想说代码的其他方面都是“好的”（创建一个健壮的线程池实现可能是一项非常困难和复杂的任务），但是一个可以避免问题的最小更改可能是

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class Test { 
   public static void main(String[] args) {

      //overcome limitation of closure not being able to modify outer variable with arr.
      final int[] runningThreads = {0};
      final int[] taskcount = {10};

      final Lock _mutex = new ReentrantLock(true);

      int maxThreadQty = 3;


      while ((taskcount[0] > 0) && (runningThreads[0] < maxThreadQty))  {
         System.out.println("New Thread Started");
         _mutex.lock();
         runningThreads[0]++;
         System.out.println("Running Threads: " + runningThreads[0]);
         System.out.println("Times to go: " + taskcount[0]);
         _mutex.unlock();
         new Thread("T") {
             public void run() {
                  // actually do something;
                  _mutex.lock();
                  taskcount[0]--;
                  runningThreads[0]--;
                  _mutex.unlock();
             }

          }.start();
      }
   }
}

import java.util.concurrent.locks.Lock；
导入java.util.concurrent.locks.ReentrantLock；
公共类测试{
公共静态void main（字符串[]args）{
//克服闭包不能用arr修改外部变量的限制。
final int[]runningThreads={0}；
最终int[]任务计数={10}；
最终锁_mutex=新的可重入锁（true）；
int MAXTREADQTY=3；
而（（taskcount[0]>0）和&（runningThreads[0]

您正在主线程中创建“子线程”。没有人知道处理器将允许哪个线程执行。这意味着从技术上讲，在这些子线程中的任何一个子线程有机会减少计数器之前，您的主线程可能会创建随机数目的新线程。谢谢，如果您愿意这样做的话，您想连续一两行解释一下正确的实现是如何工作的吗？谢谢谢谢这样代码就可以执行所需数量的任务！但线程数始终为1:

新线程开始运行线程：1次：5个新线程开始运行线程：1次：4个新线程开始运行线程：1次：3个新线程开始运行线程：1次：2个新线程开始运行线程：1次：1个新线程开始运行线程：1次to go:0

你认为是什么让它这么做的？@jj_uu你真的在“实际行动”部分放了什么东西吗？如果没有，很可能在下一个线程开始之前线程就结束了。这可能是因为每个线程的持续时间都很短，因此它们从不重叠。。。可能的我添加了Thread.sleep（10000），然后看起来它们的总数达到了允许的最大线程数！我猜是你干的！谢谢是的，我们同时写的；）这段代码的一个大陷阱是，只要使用“while”循环达到中线程的最大计数，“while”将不再计算为true，因此它将停止循环。。。所以剩余任务的其他线程将永远不会执行：）

Running Threads: 565
Times to go: 8
Running Threads: 566
Times to go: 8
Running Threads: 567
Times to go: 8
Running Threads: 568
Times to go: 8
Running Threads: 569
Times to go: 8
Running Threads: 570
Times to go: 8
Running Threads: 571
Times to go: 8
Running Threads: 572
Times to go: 8
Running Threads: 573
Times to go: 8
Running Threads: 574
Times to go: 8
Running Threads: 575
Times to go: 8

CTRL-C

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class Test { 
   public static void main(String[] args) {

      //overcome limitation of closure not being able to modify outer variable with arr.
      final int[] runningThreads = {0};
      final int[] taskcount = {10};

      final Lock _mutex = new ReentrantLock(true);

      int maxThreadQty = 3;


      while ((taskcount[0] > 0) && (runningThreads[0] < maxThreadQty))  {
         System.out.println("New Thread Started");
         _mutex.lock();
         runningThreads[0]++;
         System.out.println("Running Threads: " + runningThreads[0]);
         System.out.println("Times to go: " + taskcount[0]);
         _mutex.unlock();
         new Thread("T") {
             public void run() {
                  // actually do something;
                  _mutex.lock();
                  taskcount[0]--;
                  runningThreads[0]--;
                  _mutex.unlock();
             }

          }.start();
      }
   }
}