java.util.concurrent学习—Executor框架

java.util.concurrent 包分成了三个部分,分别是:
                           java.util.concurrent
 
                           java.util.concurrent.atomic
                           java.util.concurrent.lock
     
内容涵盖了并发集合类、线程池机制、同步互斥机制、线程安全的变量更新工具类、锁等等常用工具。  

 

并发编程的一种编程方式是把任务拆分为一些列的小任务,即Runnable,然后在提交给一个Executor执行,Executor.execute(Runnalbe)Executor在执行时使用内部的线程池完成操作。

     
例子:
              
有一个很大的整数数组,需要求这个数组中所有整数的和,来计算结果。  
             
JDK 7 中的 Fork/Join模式可以解决该问题,http://www.ibm.com/developerworks/cn/java/j-lo-forkjoin/)

     
分析:
             
采用多线程(任务),并且还要分割List,每一小块的数组采用一个线程(任务)进行计算其和,那么我们必须要等待所有的线程(任务)完成之后才能得到正确的结果.

步骤:

  • 分割数组,根据采用的线程(任务)数平均分配,即array.length/threadCounts。
  • 定义一个记录“很大数组”中所有整数和的变量sum,采用一个线程(任务)处理一个分割后的子数组,计算子数组中所有整数和(subSum),然后把和(subSum)累加到sum上。
  • 等待所有线程(任务)完成后输出总和(sum)的值。

 

/**
 * 并行计算数组的和, 测试类
 * 
 * 
@author lsb
 *
 
*/

public   class  MainTest  {
    
public static void main(String[] args) {
        
int[] numbers = new int[] 123456781011 };
        CalcArrayTotal calc 
= new CalcArrayTotal();
        Long sum 
= calc.sum(numbers);
        System.out.println(sum);
        calc.close();
    }

}


主要实现类:

import  java.util.concurrent.CompletionService;
import  java.util.concurrent.ExecutionException;
import  java.util.concurrent.ExecutorCompletionService;
import  java.util.concurrent.ExecutorService;
import  java.util.concurrent.Executors;

import  com.li.senbiao.Thread.concurrent.test1.SumCalculator;

public   class  CalcArrayTotal  {

    
private ExecutorService exec;

    
private CompletionService<Long> completionService;

    
private int cpuCoreNumber;

    
public CalcArrayTotal() {
        cpuCoreNumber 
= Runtime.getRuntime().availableProcessors();
        exec 
= Executors.newFixedThreadPool(cpuCoreNumber);
        completionService 
= new ExecutorCompletionService<Long>(exec);
    }


    
public Long sum(final int[] numbers) {
        
// 根据CPU核心个数拆分任务,创建FutureTask并提交到Executor
        for (int i = 0; i < cpuCoreNumber; i++{
            
int increment = numbers.length / cpuCoreNumber + 1;
            
int start = increment * i;
            
int end = increment * i + increment;
            
if (end > numbers.length) {
                end 
= numbers.length;
            }

            SumCalculator subCalc 
= new SumCalculator(numbers, start, end);
            
if (!exec.isShutdown()) {
                
/**
                 * 生产者 submit() 执行的 任务。使用者 take() 已完成的任务, 
                 * 并按照完成这些任务的顺序处理它们的结果  。
                 * 也就是调用CompletionService 的 take 方法是,
                 * 会返回按完成顺序放回任务的结果, CompletionService 内部维护了一个 阻塞队列 BlockingQueue ,
                 * 如果没有任务完成, take() 方法也会阻塞。
                 
*/

                completionService.submit(subCalc);
            }

        }

        
return getResult();
    }


    
/**
     * 迭代每个只任务,获得部分和,相加返回
     
*/

    
public Long getResult() {
        Long result 
= 0L;
        
for (int i = 0; i < cpuCoreNumber; i++{
            
try {
                Long subSum 
= completionService.take().get();
                result 
+= subSum;
            }
 catch (InterruptedException e) {
                e.printStackTrace();
            }
 catch (ExecutionException e) {
                e.printStackTrace();
            }

        }

        
return result;
    }


    
public void close() {
        exec.shutdown();
    }


}


一组的计算和:

import  java.util.concurrent.Callable;

/**
 * 一组计算和值 
 * 
 * 
@author lsb
 *
 
*/

public   class  SumCalculator  implements  Callable < Long >   {

    
private int[] numbers;

    
private int start;

    
private int end;

    
public SumCalculator(final int[] numbers, int start, int end) {
        
this.numbers = numbers;
        
this.start = start;
        
this.end = end;
    }


    @Override
    
public Long call() throws Exception {
        Long sum 
= 0L;
        
for (int i = start; i < end; i++{
            sum 
+= numbers[i];
        }

        
return sum;
    }

}






 


     一、Executors创建线程池

        Executors类,提供了一系列工厂方法用于创先线程池,返回的线程池都实现了ExecutorService接口。

         // 创建固定数目线程的线程池
        public static ExecutorService newFixedThreadPool(int nThreads)

       
        // 创建一个可缓存的线程池,调用execute 将重用以前构造的线程(如果线程可用)。如果现有线程没有可用的,则创建一个新线程并添加到池中。终止并从缓存中移除那些已有 60 秒钟未被使用的线程。

        public static ExecutorService newCachedThreadPool() 
    
        // 创建一个单线程化的Executor

        public static ExecutorService newSingleThreadExecutor()

       
       //  创建一个支持定时及周期性的任务执行的线程池,多数情况下可用来替代Timer类

        public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) 



   二、ExecutorService 与生命周期

      ExecutorService 扩展了Executor 并添加了一些生命周期管理的方法。一个Executor 的生命周期有三种状态,运行 ,关闭 ,终止 。Executor 创建时处于运行状态。当调用ExecutorService.shutdown() 后,处于关闭状态,isShutdown() 方法返 回true 。这时,不应该再想Executor 中添加任务,所有已添加的任务执行完毕后,Executor 处于终止状态,isTerminated() 返 回true 。

   如果Executor 处于关闭状态,往Executor 提交任务会抛出unchecked exception RejectedExecutionException 。

 

 

    三、使用Callable ,Future 返回结果

     Future 代表一个异步执行的操作,通过get() 方法可以获得操作的结果,如果异步操作还没有完成,则,get() 会使当前 线程阻塞。FutureTask 实现了Future 和Runable 。Callable 代表一个 有返回值得操作。

ExecutoreService 提供了submit() 方法,传递一个Callable ,或Runnable ,返回Future 。如果Executor 后台线程池还没有完成Callable 的计算,这调用返回Future 对象的get() 方法,会阻塞直到计算完成。


你可能感兴趣的:(Java,技术)