001线程池

最新推荐文章于 2025-05-23 23:18:31 发布

sijidou112

最新推荐文章于 2025-05-23 23:18:31 发布

阅读量314

点赞数

CC 4.0 BY-SA版权

分类专栏：线程专题

本文链接：https://blog.youkuaiyun.com/sijidou112/article/details/8122997

线程专题专栏收录该内容

7 篇文章

订阅专栏

本文详细介绍了Java中使用ExecutorService实现固定线程池、创建Runnable和Callable任务、使用FutureTask跟踪任务执行状态以及取消任务的方法。通过实例演示了如何在多线程环境下高效执行并管理任务。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

package testThreadPool;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Executors;
import java.util.concurrent.FutureTask;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

import java.util.concurrent.ExecutorService;

public class test1 {

   public static void main(String[] args) {

       // 创建一个可重用固定线程数的线程池

       ExecutorService pool = Executors.newFixedThreadPool(2);

       // 创建实现了Runnable接口对象，Thread对象当然也实现了Runnable接口

//       Thread t1 = new MyThread();
//
//       Thread t2 = new MyThread();
//
//       Thread t3 = new MyThread();
//
//       Thread t4 = new MyThread();
//
//       Thread t5 = new MyThread();
//
//       // 将线程放入池中进行执行
//
//       pool.execute(t1);
//
//       pool.execute(t2);
//
//       pool.execute(t3);
//
//       pool.execute(t4);
//
//       pool.execute(t5);
       CallableTask<String> ct = new CallableTask<String>("result");

       task<String> t1 = new task<String>(ct);

       pool.submit(t1);
       System.out.print("start");

       t1.cancel(true);

       try {
           System.out.print(t1.get()); //很有必要在一个全新的线程中跟踪任务的执行
       } catch (Exception e1) {
           System.out.print("asdf");
           // TODO Auto-generated catch block
           //e1.printStackTrace();
       }

       // 关闭线程池
       try{
           Thread.sleep(1000);
       }catch (Exception e) {
           // TODO: handle exception
       }

       System.out.println("Start");
       try{
           Thread.sleep(5000);
       }catch (Exception e) {
           // TODO: handle exception
       }
       System.out.println(Thread.currentThread().getName()+"end");
       pool.shutdown();

   }

}

class task<V> extends FutureTask<V>{

   public task(Callable<V> callable){
       super(callable);
   }

   @Override
   public boolean isCancelled() {
       // TODO Auto-generated method stub
       return super.isCancelled();
   }

   @Override
   public boolean isDone() {
       // TODO Auto-generated method stub
       return super.isDone();
   }

   @Override
   public boolean cancel(boolean mayInterruptIfRunning) {
       // TODO Auto-generated method stub
       return super.cancel(mayInterruptIfRunning);
   }

   @Override
   public V get() throws InterruptedException, ExecutionException {
       // TODO Auto-generated method stub
       return super.get();
   }

   @Override
   public V get(long timeout, TimeUnit unit) throws InterruptedException,
           ExecutionException, TimeoutException {
       // TODO Auto-generated method stub
       return super.get(timeout, unit);
   }

   @Override
   protected void done() {
       // TODO Auto-generated method stub
       super.done();
   }

   @Override
   protected void set(V v) {
       // TODO Auto-generated method stub
       super.set(v);
   }

   @Override
   protected void setException(Throwable t) {
       // TODO Auto-generated method stub
       super.setException(t);
   }

   @Override
   public void run() {
       // TODO Auto-generated method stub
       super.run();
   }

   @Override
   protected boolean runAndReset() {
       // TODO Auto-generated method stub
       return super.runAndReset();
   }

}

class CallableTask<V> implements Callable<V>{


   public CallableTask(V v){
       this.result = v;
   }

   private V result;

   @Override
   public V call() throws Exception {
       try{
           Thread.sleep(2000); //睡眠的是线程池中的线程
       }catch (Exception e) {
           return result;
       }
       System.out.println(Thread.currentThread().getName() + "正在执行。。。");
       return result;
   }

}

class MyThread extends Thread {

   @Override
   public void run() {
       try{
           Thread.sleep(2000); //睡眠的是线程池中的线程
       }catch (Exception e) {
           return;
       }
       System.out.println(Thread.currentThread().getName() + "正在执行。。。");

   }

}