用一个线程池执行多个任务

分手后的思念是犯贱 2022-07-18 00:16 337阅读 0赞

今天写了些代码，测试了一下用多个线程来执行多个任务的的情况，线程放在一个线程池里进行管理。

线程的数量控制在10个(当然可以指定线程池里的线程数量)；任务的数量不做限制。

下面贴出代码，以备用时之需。

4个java类：1 Test.java(用于测试);2 TracingObject.java(用于传递参数的对象); 3 TracingTask.java(任务) 4 TracingThreadPool.java （管理线程的线程池）。

Test:

public class Test \{

public static void main(String\[\] args) \{  
  try \{  
   int poolSize = 10;  
     
   //1 新增一些TracingObject  
   List<TracingObject> objects = new ArrayList<TracingObject>();  
     
   for(int i=1;i<=10;i++)\{  
    objects.add(new TracingObject(new Integer(i),"file\_name\_" + i, "content\_" + i,"description\_" + i, new Integer(1)));  
   \}

for(int i=1;i<=10;i++)\{  
    objects.add(new TracingObject(new Integer(i),"maintainlog\_name\_" + i, "content\_" + i,"description\_" + i, new Integer(2)));  
   \}

for(int i=1;i<=10;i++)\{  
    objects.add(new TracingObject(new Integer(i),"db\_name\_" + i, "content\_" + i,"description\_" + i, new Integer(3)));  
   \}  
     
   //2 创建线程池  
   TracingThreadPool tracingThreadPool = new TracingThreadPool(poolSize);  
     
   //3 新增一些任务到线程池中 给线程执行  
   for (TracingObject tracingObject : objects) \{  
    tracingThreadPool.addTask(new TracingTask(tracingObject));  
   \}  
     
   //4 等待工作线程完成所有的任务  
   tracingThreadPool.join();  
     
   //5 关闭线程池  
   tracingThreadPool.close();  
     
  \} catch (Exception e) \{  
   // TODO: handle exception  
   e.printStackTrace();  
  \}

TracingObject:

public class TracingObject \{

private Integer id;

private String name;

private String content;

private String description;

private Integer type;  
   
 public Integer getId() \{  
  return id;  
 \}

public void setId(Integer id) \{  
  this.id = id;  
 \}

public String getName() \{  
  return name;  
 \}

public void setName(String name) \{  
  this.name = name;  
 \}

public String getContent() \{  
  return content;  
 \}

public void setContent(String content) \{  
  this.content = content;  
 \}

public String getDescription() \{  
  return description;  
 \}

public void setDescription(String description) \{  
  this.description = description;  
 \}

public Integer getType() \{  
  return type;  
 \}

public void setType(Integer type) \{  
  this.type = type;  
 \}

@Override  
 public String toString() \{  
  // TODO Auto-generated method stub  
  return "id:" + id  
    \+ "\\t name:" + name  
    \+ "\\t content:" + content  
    \+ "\\t description:" + description  
    \+ "\\t type:" + type;  
 \}

public TracingObject(Integer id, String name, String content,  
   String description, Integer type) \{  
  super();  
  this.id = id;  
  this.name = name;  
  this.content = content;  
  this.description = description;  
  this.type = type;  
 \}

TracingTask:

public class TracingTask implements Runnable \{

private TracingObject tracingObject;  
   
 private TracingTask() \{\}

public TracingTask(TracingObject tracingObject) \{  
  this.tracingObject = tracingObject;  
 \}

public void run() \{  
  // TODO Auto-generated method stub  
  try \{  
   System.out.println(Thread.currentThread().getName() + "\\t" + this.tracingObject);  
   // 增加执行一个任务的时间,3秒  
   Thread.sleep(3000);  
  \} catch (InterruptedException ex) \{  
  \}  
 \}  
\}

TracingThreadPool:

public class TracingThreadPool extends ThreadGroup \{  
 // 线程池是否关闭  
 private boolean isClosed = false;  
 // 表示工作队列  
 private LinkedList<Runnable> workQueue;  
 // 表示线程池ID  
 private static int threadPoolID;  
 // 表示工作线程ID  
 private int threadID;

// poolSize指定线程池中的工作线程数目  
 public TracingThreadPool(int poolSize) \{  
  super("ThreadPool-" + (threadPoolID++));  
  setDaemon(true);  
  // 创建工作队列  
  workQueue = new LinkedList<Runnable>();  
  // 打印起始时间  
  System.out.println("start time:" + (new Date()));

for (int i = 0; i < poolSize; i++)  
   // 创建并启动工作线程  
   new WorkThread().start();  
 \}

public synchronized void addTask(Runnable task) \{  
  // 线程池被关则抛出IllegalStateException异常  
  if (isClosed) \{  
   throw new IllegalStateException();  
  \}  
  if (task != null) \{  
   workQueue.add(task);  
   // 唤醒正在getTask()方法中等待任务的工作线程  
   notify();  
  \}  
 \}

protected synchronized Runnable getTask() throws InterruptedException \{  
  while (workQueue.size() == 0) \{  
   if (isClosed)  
    return null;  
   // 如果工作队列中没有任务，就等待任务  
   wait();  
  \}  
  return workQueue.removeFirst();  
 \}

public synchronized void close() \{  
  if (!isClosed) \{  
   isClosed = true;  
   workQueue.clear(); // 清空工作队列  
   interrupt(); // 中断所有的工作线程，该方法继承自ThreadGroup类  
  \}  
 \}

public void join() \{  
  synchronized (this) \{  
   isClosed = true;  
   // 唤醒还在getTask()方法中等待任务的工作线程  
   notifyAll();  
  \}

Thread\[\] threads = new Thread\[activeCount()\];  
  //获得线程组中当前所有活着的工作线程  
  int count = enumerate(threads);  
  // 等待所有工作线程运行结束  
  for (int i = 0; i < count; i++) \{  
   try \{  
    // 等待工作线程运行结束  
    threads\[i\].join();  
   \} catch (InterruptedException ex) \{  
   \}  
  \}  
  //打印结束时间  
  System.out.println("end time:" + (new Date()));  
 \}

private class WorkThread extends Thread \{  
  public WorkThread() \{  
   // 加入到当前ThreadPool线程组中  
   super(TracingThreadPool.this, "WorkThread-" + (threadID++));  
  \}

public void run() \{  
   while (!isInterrupted()) \{ // isInterrupted()方法继承自Thread类，判断线程是否被中断  
    Runnable task = null;  
    try \{  
     // 得到任务  
     task = getTask();  
    \} catch (InterruptedException ex) \{  
    \}

// 如果getTask()返回null或者线程执行getTask()时被中断，则结束此线程  
    if (task == null)  
     return;

try \{  
     // 运行任务，捕获异常  
     task.run();  
    \} catch (Throwable t) \{  
     t.printStackTrace();  
    \}  
   \}  
  \}  
 \}  
\}