java架构《并发线程高级篇一》

  本章主要记录讲解并发线程的线程池。java.util.concurrent工具包里面的工具类。

一:Executor框架:

    Executors创建线程池的方法:

      

newFixedThreadPool()方法: 该方法返回一个固定数量的线程池,该方法的线程数始终不变,当有一个任务提交时,若线程池中空闲,则立即执行,若没有,则会被暂缓在一个任务队列中等待有空闲的线程去执行。

newSingleThreadExecutor()方法:创建一个线程的线程池,若空闲则执行。若没有,则暂缓在任务队列中。

newCachedThreadPool()方法:返回一个可根据实际情况调整线程个数的线程池,不限制最大线程数量,若用空闲的线程则执行任务,若无任务则不创建线程,并且每一个空闲线程会在60秒后自动回收。

newScheduledThreadPool()方法:该方法返回一个SchededExecutorService对象,但该线程池可以指定线程的数量。

newFixedThreadPool使用心得:因为该方法创建的是一个固定的线程池,底层运用的队列是linkBlockingQueue队列,该队列是阻塞无序队列,所以切记,当首次任务列队完成调度后,后面的顺序就会被打乱,排序则需要根据指定的规则排序。

newCachedThreadExecutor使用心得:创建一个可缓存线程池,如果线程池长度超过处理需要,可灵活回收空闲线程,若无可回收,则新建线程。

newSingleThreadExecutor使用心得:创建一个单线程化的线程池,它只会用唯一的工作线程来执行任务,保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。

newScheduledThreadPool使用心得:创建一个定长线程池,支持定时及周期性任务执行。

     

    代码解析:

       

 1  //Task内部类:  
2
3         class Task extends Thread{
4
5         private int TaskId;
6
7         public Task(Integer TaskId){
8         this.TaskId=TaskId;
9         }
10           @Override
11           public void run() {
12             long start = System.currentTimeMillis();
13             try {
14               System.out.println("Run-----" +"TaskId:"+TaskId);
15               //模仿处理数据需要5s
16               Thread.sleep(5000);
17               long end = System.currentTimeMillis() - start;
18               System.out.println(" 执行时间:" + end);
19               } catch (InterruptedException e) {
20                 // TODO Auto-generated catch block
21                 e.printStackTrace();
22               }
23
24               }
25           }
26
27

      

 1 // newFixedThreadPool方法测试:
2
3             
4
5           /**
6           * newFixedThreadPool线程池测试 创建一个定长线程池,可控制线程最大并发数,超出的线程会在队列中等待。队列无序
7           * @throws InterruptedException
8           */
9           private static void FixedThredPoolTest() throws InterruptedException {
10             System.out.println("newFixedThreadPool线程池测试-------------------");
11             //创建固定的10个线程的线程池 队列阻塞无序
12             ExecutorService pool=Executors.newFixedThreadPool(10);
13             /**
14             * 这里产生15个任务 看是否一次性处理10个任务,
15             * 然后5个任务阻塞放在LinkBlockingQueue队列里面,
16             * 然后等10个任务处理完在执行
17             */
18               for (int i = 1; i <= 15; i++) {
19                 // 执行给定的命令 执行任务
20                 pool.execute(new Task(i));
21                 }
22
23                 //关闭启动线程
24                 pool.shutdown();
25                 // 等待子线程结束,再继续执行下面的代码
26                 pool.awaitTermination(Long.MAX_VALUE, TimeUnit.DAYS);
27                 System.out.println("all thread complete");
28               }
29
30         

      

 1  // newCachedThreadPool方法测试:
2
3             
4
5            /**
6            * newCachedThreadPool线程池测试 创建一个可缓存线程池,如果线程池长度超过处理需要,可灵活回收空闲线程,若无可回收,则新建线程。
7            * @throws InterruptedException
8            */
9            private static void CachedThreadPoolTest() throws InterruptedException {
10               System.out.println("newCachedThreadPool线程池测试-------------------");
11               ExecutorService pool=Executors.newCachedThreadPool();
12
13                 for (int i =1; i <= 10; i++) {
14                   // 执行给定的命令
15                   pool.execute(new Task(i));
16                 }
17                 //关闭启动线程
18                 pool.shutdown();
19                 // 等待子线程结束,再继续执行下面的代码
20                 pool.awaitTermination(Long.MAX_VALUE, TimeUnit.DAYS);
21                 System.out.println("all thread complete");
22               }
23
24

       

 1 // newSingleThreadExecutor方法测试:
2
3         
4
5             /**
6
7             * newSingleThreadExecutor测试:创建一个单线程化的线程池,它只会用唯一的工作线程来执行任务,保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。
8             * @throws InterruptedException
9             */
10             private static void SingleThreadPoolTest() throws InterruptedException {
11               System.out.println("newSingleThreadExecutor线程池测试-------------------");
12               ExecutorService pool=Executors.newSingleThreadExecutor();
13                 for (int i = 1; i <= 5; i++) {
14                   // 执行给定的命令
15                   pool.execute(new Task(i));
16                   }
17                 //关闭启动线程
18                 pool.shutdown();
19                 // 等待子线程结束,再继续执行下面的代码
20                 pool.awaitTermination(Long.MAX_VALUE, TimeUnit.DAYS);
21                 System.out.println("all thread complete");
22               }
23
24

      

 1  // newScheduledThreadPool方法测试:
2
3           
4
5           /**
6           * newScheduledThreadPool测试 创建一个定长线程池,支持定时及周期性任务执行。
7           */
8           private static void ScheduledThreadPoolTest() {
9             System.out.println("newScheduledThreadPool线程池测试-------------------");
10             ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(1);
11             /* 参数:
12             command - 要执行的任务
13             initialdelay - 首次执行的延迟时间
14             delay - 一次执行终止和下一次执行开始之间的延迟
15             unit - initialdelay 和 delay 参数的时间单位*/
16             ScheduledFuture<?> scheduleTask = scheduler.scheduleWithFixedDelay(new Task(1), 5, 1, TimeUnit.SECONDS);
17           }
18
19   

 

    

上一篇:Java多线程与并发库高级应用-java5线程并发库


下一篇:java--加强之 Java5的线程并发库