被我遗忘的时光

package fyting.javaeye.com;
public class MatrixSolver
{
    private final int[][] matrix;
    private final int maxThreads;
    private final Map<Integer, Integer> results = Collections.synchronizedMap(new TreeMap<Integer, Integer>());
    public void start(){
        //...
    }
}

public static void main(String[] args)
{
    final int row = 5000, column = 2000;
    final int[][] data = new int[row][column];
    for(int i = 0 ; i < row; i++) {
        for(int j = 0; j < column; j++) {
            data[i][j] = j;
        }
    }
    final int maxThreads = 3;
    MatrixSolver solver = new MatrixSolver(maxThreads, data);
    solver.start();
}

public void start()
{
    ExecutorService executor = Executors.newFixedThreadPool(maxThreads);
    final long st = System.nanoTime();
    if(this.matrix.length == 0) {
        System.err.println("no matrix data!");
        return;
    }
    final int columnCount = this.matrix[0].length;
    //创建一个计数的latch，用来等待运算结果
    final CountDownLatch latch = new CountDownLatch(columnCount);
    for(int i = 0 ; i < columnCount; i++) {
        final int column = i;
        executor.execute(newTask(column,latch));
    }
    try {
        latch.await();//等待运算完毕，否则会一直wait在这里
        executor.shutdown();
        long et = System.nanoTime();
        long time = (et - st) / (1000*1000);
        System.out.println("success, time: " + time + "ms");
        executor.awaitTermination(1, TimeUnit.SECONDS);
    }
    catch(InterruptedException e) {
        e.printStackTrace();
    }
    System.out.println("maxtrix: " + (matrix.length + "*" + matrix[0].length));
    System.out.println("column0==>" + ArrayUtils.toString(matrix[0]));
    System.out.println("results==>" + results);
} 

protected Runnable newTask(int column, CountDownLatch latch)
{
    return new ColumnSolver(column,latch);
} 

private class ColumnSolver extends Thread
{
    private final int columnIndex;
    private final CountDownLatch latch; 

    ColumnSolver(int columnIndex, CountDownLatch latch)
    {
        this.columnIndex = columnIndex;
        this.latch = latch;
    } 

    @Override
    public void run()
    {
        int count = 0;
        for(int j = 0, rowCount = matrix.length; j < rowCount; j++) {
            count += matrix[j][columnIndex];
        }
        results.put(columnIndex, count);
        latch.countDown();//计数器减1
    }
}

public class CalculatorService {   
    private AddService addService;   
    @Reference  
    public void setAddService(AddService addService) {   
        this.addService = addService;   
    }   
    public double add(double n1, double n2) {   
        return addService.add(n1, n2);   
    }   
}