Java 同时创建动态线程数

每次我都要创建不同数量的线程。 我通过创建一个线程数组并创建多个线程来实现这一点

但是，我不明白如何启动这n个线程，它们的行为就像多线程概念一样。 我希望它们并行运行

请指导如何使用此senario。

基本密码：

create x threads, store them in an array or list;
for each thread in the list/array
   call start() on the thread object;

但是，我不明白如何启动这n个线程，它们的行为就像多线程概念一样。我希望它们并行运行

您当然可以使用循环创建线程数组：

 Thread[] threads = new Thread[NUM_JOBS_TO_CREATE];
 for (int i = 0; i < threads.length; i++) {
     threads[i] = new Thread(new Runnable() {
         public void run() {
             // some code to run in parallel
             // this could also be another class that implements Runnable
         }
     });
     threads[i].start();
 }

但是我建议使用内置线程，而不是自己管理线程。他们为你做这一切都是因为你更容易管理。此方法的一个好处是它将任务与运行任务的线程分离。例如，您可以启动10个线程来并行运行1000和1000个任务

下面是一些示例

ExecutorService

code：

 // create a pool of threads, 10 max jobs will execute in parallel
 ExecutorService threadPool = Executors.newFixedThreadPool(10);
 // submit jobs to be executing by the pool
 for (int i = 0; i < NUM_JOBS_TO_CREATE; i++) {
    threadPool.submit(new Runnable() {
         public void run() {
             // some code to run in parallel
             // this could also be another class that implements Runnable
         }
     });
 }
 // once you've submitted your last job to the service it should be shut down
 threadPool.shutdown();
 // wait for the threads to finish if necessary
 threadPool.awaitTermination(Long.MAX_VALUE, TimeUnit.MILLISECONDS);

//创建一个线程池，最多并行执行10个作业
ExecutorService线程池=Executors.newFixedThreadPool（10）；
//提交要由池执行的作业
对于（int i=0；i

---

有关更多信息，请参阅。

尽量不要创建线程数组并尝试管理它们-它很快就会变成一团乱麻。如果需要线程池来运行任务，则需要生产者-消费者队列。创建一个线程，并在创建线程时将其（或将其作为成员包含的threadpool对象实例）传递到线程中。线程循环，获取任务并执行它们

实现这一点的简单方法是使用@Gray（+1）详述的ExecutorService

为了强调这一点，我再次强调，不要试图对数组、列表或向量中的线程进行微管理，启动它们，在“boss/management”循环中检查它们的状态，终止/中止它们，销毁它们等等。这就像保时捷911——在花费大量金钱/时间获得一个线程之后，你会有一些似乎工作正常的东西，然后它会突然断裂，把你旋转成一棵树

---

对于长时间阻塞的作业，使用专用线程；对于可以集中快速完成的作业，使用线程池。

在需要多线程的类中，我将其设置在类的顶部：

private static final executor service executor=Executors.newCachedThreadPool（）

&在Java 8+中，需要在新线程中运行某些内容时，请使用lamda表达式：

executor.submit(() -> {
        myOtherClass.myFunction(doSomething);
});

使用
newCachedThreadPool
Java将根据系统上的cpu内核数管理线程总数，并在一段不活动时间后自动停止线程（默认情况下，
60
秒）。
Scanner reader=new Scanner（system.in）；
System.out.println（“输入正数：”）；
int n=reader.nextInt（）；
如果（n>0）{
线程[]ob=新线程[n]；
for（int i=0；i
如果这样做，则线程不会并行运行。但是，它们作为正常函数按顺序运行call@sowmya我想你需要仔细阅读一些线索。对一组线程按顺序调用start（）并不意味着它们按顺序运行，它只意味着它们按顺序启动。但是，它们按我启动它们的顺序执行函数。据我所知，至少输出应该改变。但事实并非如此。如果我错了，请纠正我。它们各自执行自己版本的函数。如果我有1000个作业，它将创建1000个对象，这将导致性能问题1000个对象非常便宜@Manojraman。从对象带宽的角度来看，1000个字符串更昂贵。如果您创建了一百万个对象，您可能会注意到一些GC问题，因此我们通常会在队列上设置边界，以防
可运行的
生产者比消费者快得多。谢谢@Gray提供的信息。您能分享一些更多信息吗？我目前正在使用此实现。如何测试它欢迎使用堆栈溢出。虽然这很可能是解决OP问题的代码，但请添加一些解释，说明该代码的作用以及为什么会回答这个问题。
executor.submit(() -> {
        myOtherClass.myFunction(doSomething);
});

Scanner reader = new Scanner(System.in);
    System.out.println("Enter a positive number: ");
    int n = reader.nextInt();
    if(n>0){
        Thread[] ob = new Thread[n];
        for (int i = 0; i < ob.length; i++) {
            int num = i+1;
            ob[i] = new Thread(new Runnable() {
         public void run() {
             System.out.println("Hello, I am Thread #"+num);
         }
            });
            ob[i].start();
        }
    }else{
        System.out.println("Please Enter A Positive Integer");
    }