线程池ExecutorService 和ThreadPoolExecotor，优先级队列

我使用这个Executors执行器类

Executor executor=Executors.newFixedThreadPool(2);        
        for (int i = 0; i < 10; i++) {
            MyRun run=new MyRun();
            executor.execute(run);
        }

java线程池ThreadPoolExecutor类使用详解 - bigfan - 博客园

public class ThreadPool {
    private static ExecutorService pool;
    public static void main( String[] args )
    {
        //拒绝策略为AbortPolic策略，直接提交队列：
//        pool = new ThreadPoolExecutor(1, 2, 1000, TimeUnit.MILLISECONDS, new SynchronousQueue<Runnable>                                      (),Executors.defaultThreadFactory(),new ThreadPoolExecutor.AbortPolicy());
//        有界的任务队列，      策略函数 //DiscardOldestPolicy 和DiscardPolicy 都差不多；都会丢弃；
                             //        CallerRunsPolicy会使用main方法
//        pool=new ThreadPoolExecutor(1, 2, 1000, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>                                                              (4),Executors.defaultThreadFactory(),new ThreadPoolExecutor.AbortPolicy());
//        无界的任务队列：，没有异常
//        pool = new ThreadPoolExecutor(1, 2, 1000, TimeUnit.MILLISECONDS, new LinkedBlockingQueue<Runnable>                                                            (),Executors.defaultThreadFactory(),new ThreadPoolExecutor.AbortPolicy());
        for(int i=0;i<3;i++) {
            try {
                pool.execute(new ThreadTask());
            } catch (Exception e) {
                e.printStackTrace();
                System.out.println("请您排队");
            }
        } 

    }
    
}

class ThreadTask implements Runnable{
    public void run() {
        System.out.println(Thread.currentThread().getName());
    }
}

优先级队列，线程池的一个线程执行任务队列，没有异常

public class ThreadPool {
    private static ExecutorService pool;
    public static void main( String[] args )
    {
        //优先任务队列
        pool = new ThreadPoolExecutor(1, 2, 1000, TimeUnit.MILLISECONDS, new PriorityBlockingQueue<Runnable>(),Executors.defaultThreadFactory(),new ThreadPoolExecutor.AbortPolicy());
          
        for(int i=0;i<20;i++) {
            pool.execute(new ThreadTask(i));
        }    
    }
}

class ThreadTask implements Runnable,Comparable<ThreadTask>{
    
    private int priority;
    public ThreadTask(int priority) {
        this.priority = priority;
    }

   //队列进行
    public int compareTo(ThreadTask o) {
         return  this.priority>o.priority?1:-1;
    }
    
    public void run() {
        try {
            //让线程阻塞，使后续任务进入缓存队列
            Thread.sleep(10);
            System.out.println("priority:"+this.priority+",ThreadName:"+Thread.currentThread().getName());
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    
    }
}
priority:1,ThreadName:pool-1-thread-1
priority:2,ThreadName:pool-1-thread-1
priority:3,ThreadName:pool-1-thread-1
priority:4,ThreadName:pool-1-thread-1