java如何实现单线程启动多个线程处理一个列表并在所有子线程处理完毕后父线程再处理其他操作

这篇文章将为大家详细讲解有关java如何实现单线程启动多个线程处理一个列表并在所有子线程处理完毕后父线程再处理其他操作，小编觉得挺实用的，因此分享给大家做个参考，希望大家阅读完这篇文章后可以有所收获。

主类：ParentChildMain

父线程类：ParentChildPoolTest

子线程类：ParentChildDoThread

线程池：ThreadPool

import java.util.ArrayList;

public class ParentChildMain {
private static ArrayList list = new ArrayList();
private static int controlNum = 0;
private static int listNum = 0;
public ParentChildMain() {
 for (int i = 0; i < 50; i++) {
  list.add(String.valueOf(i));
 }
 listNum = list.size();
 ParentChildPoolTest test = new ParentChildPoolTest();
 test.start();
}

public static synchronized  String getControlObj(){
 if(listNum == controlNum){
  return null;
 }
 String retValue = (String)list.get(controlNum);
 controlNum ++;
 return retValue;
}

public static void main(String[] args){
 ParentChildMain main = new ParentChildMain();
}
}

import java.util.ArrayList;

public class ParentChildPoolTest extends Thread{

int numThreads = 10;
int numTasks = 4;
public ParentChildPoolTest(){
 
}
public void run(){
  // 生成线程池
       ThreadPool threadPool = new ThreadPool(numThreads);

// 运行任务
       for (int i=0; i<numTasks; i++) {
threadPool.runTask(new ParentChildDoThread());
       }

// 关闭线程池并等待所有任务完成
       threadPool.join();
       threadPool.close();

System.out.println("1111111111111111111111");
}

public static  void main(String[] args){
 
}

}

public class ParentChildDoThread extends Thread {

public void run() {
 String value = ParentChildMain.getControlObj();
 while ( value != null) {
  System.out.println("this is test:"+value);
  try {
   this.sleep(Integer.parseInt(value)*1000);
  } catch (InterruptedException e) {
   e.printStackTrace();
  }
  value = ParentChildMain.getControlObj();
 }
}

}

import java.util.LinkedList;

public class ThreadPool extends ThreadGroup {

private boolean isAlive;
 private LinkedList taskQueue;
 private int threadID;
 private static int threadPoolID;

 public ThreadPool(int numThreads) {
   super("ThreadPool-" + (threadPoolID++));
   setDaemon(true);

isAlive = true;

taskQueue = new LinkedList();
   for (int i = 0; i < numThreads; i++) {
     new PooledThread().start();
   }
 }

 public synchronized void runTask(Runnable task) {
   if (!isAlive) {
     throw new IllegalStateException(); //线程被关则抛出IllegalStateException异常
   }
   if (task != null) {
     taskQueue.add(task);
     notify();
   }

}

protected synchronized Runnable getTask() throws InterruptedException {
   while (taskQueue.size() == 0) {
     if (!isAlive) {
       return null;
     }
     wait();
   }
   return (Runnable) taskQueue.removeFirst();
 }

 public synchronized void close() {
   if (isAlive) {
     isAlive = false;
     taskQueue.clear();
     interrupt();
   }
 }

 public void join() {
   //告诉等待线程线程池已关
   synchronized (this) {
     isAlive = false;
     notifyAll();
   }

// 等待所有线程完成
   Thread[] threads = new Thread[activeCount()];
   int count = enumerate(threads);
   for (int i = 0; i < count; i++) {
     try {
       threads[i].join();
     }
     catch (InterruptedException ex) {
       ex.printStackTrace();
     }
   }
 }

 
 private class PooledThread extends Thread {
   public PooledThread() {
     super(ThreadPool.this,"PooledThread-" + (threadID++));
   }

public void run() {
     while (!isInterrupted()) {
       // 得到任务
       Runnable task = null;
       try {
         task = getTask();
       }
       catch (InterruptedException ex) {
       }

// 若getTask()返回null或中断，则关闭此线程并返回
       if (task == null) {
         return;
       }

// 运行任务，吸收异常
       try {
         task.run();
       }
       catch (Throwable t) {
         uncaughtException(this, t);
       }
     }
   }
 }
}

关于“java如何实现单线程启动多个线程处理一个列表并在所有子线程处理完毕后父线程再处理其他操作”这篇文章就分享到这里了，希望以上内容可以对大家有一定的帮助，使各位可以学到更多知识，如果觉得文章不错，请把它分享出去让更多的人看到。