通过使用CyclicBarrier来计算Matrix中最大的值

import java.util.Random;

import java.util.concurrent.CyclicBarrier;

import java.util.concurrent.Executor;

import java.util.concurrent.ExecutorService;

import java.util.concurrent.Executors;



/**

 * Created by ltao on 2015/1/14.

 * 通过使用CyclicBarrier来计算Matrix中最大的值

 */



class FindMax {

    public static void findMax(int rowStart, int rowEnd, int[] maxs, int[][] matrix, int length) {

        for (int i = rowStart; i < rowEnd; i++) {

            int[] tmp = matrix[rowStart];

            int max = -1;

            for (int j = 0; j < length; j++) {

                if (max < tmp[j]) {

                    max = tmp[j];

                }

            }

            maxs[i] = max;

        }

    }

}



class SubMatrix implements Runnable {

    private int rowStart;

    private int rowEnd;

    int[] maxs;

    int[][] matrix;

    int length;



    private CyclicBarrier cyclicBarrier;



    public SubMatrix(int rowStart, int rowEnd, int[] maxs, int[][] matrix, int length, CyclicBarrier cyclicBarrier) {

        this.rowStart = rowStart;

        this.rowEnd = rowEnd;

        this.maxs = maxs;

        this.matrix = matrix;

        this.length = length;

        this.cyclicBarrier = cyclicBarrier;

    }



    public int getRowStart() {

        return rowStart;

    }



    public void setRowStart(int rowStart) {

        this.rowStart = rowStart;

    }



    public int getRowEnd() {

        return rowEnd;

    }



    public void setRowEnd(int rowEnd) {

        this.rowEnd = rowEnd;

    }



    public int[] getMaxs() {

        return maxs;

    }



    public void setMaxs(int[] maxs) {

        this.maxs = maxs;

    }



    public int[][] getMatrix() {

        return matrix;

    }



    public void setMatrix(int[][] matrix) {

        this.matrix = matrix;

    }



    public int getLength() {

        return length;

    }



    public void setLength(int length) {

        this.length = length;

    }



    @Override

    public void run() {

        try {

            FindMax.findMax(rowStart, rowEnd, maxs, matrix, length);

            this.cyclicBarrier.await();

        } catch (Exception e) {

            e.printStackTrace();

        }



    }



}



public class MatrixCounter {



    public static void main(String[] args) {



        final int row = 100000;

        int length = 2000;

        final int[][] matrix = new int[row][length];

        Random random = new Random();

        for (int i = 0; i < row; i++) {

            for (int j = 0; j < length; j++) {

                matrix[i][j] = random.nextInt(3000);

            }

        }







        final int[] maxs = new int[row];

        int coreSize = Runtime.getRuntime().availableProcessors();

        int threadNum = coreSize;



        if (row < coreSize) {

            threadNum = row;

        }





        CyclicBarrier cyclicBarrier = new CyclicBarrier(threadNum, new Runnable() {

            @Override

            public void run() {

                int max = -1;

                for (int i = 0; i < row; i++) {

                    if (maxs[i] > max) {

                        max = maxs[i];

                    }

                }

                System.out.println("max:" + max);

            }

        });

        System.out.println("线程数目:"+threadNum);

        ExecutorService executor = Executors.newFixedThreadPool(threadNum);

        for (int i = 0; i < threadNum; i++) {

            int rowSart = i * (row / threadNum);

            int rowEnd = 0;

            if (i != threadNum - 1) {

                rowEnd = (i + 1) * (row / threadNum) - 1;

            } else {

                rowEnd = row - 1;

            }

            executor.execute(new SubMatrix(rowSart, rowEnd, maxs, matrix, length, cyclicBarrier));

        }





    }





}