打印1到1亿的平方

public class CalcTest{

    private volatile int beforeValue = 0;//最后一个启动线程需要计算范围的的起始值
    private volatile boolean isStop = false;//是否完成了所有的输出
    private volatile boolean isChangeBeforeValue = true;//是否有线程启动成功，并改变了beforeValue
    private volatile int threadCount = 0;//所有线程总数
    private volatile Integer nowThreadCount = 0;//当前计算线程总数
    private final int minValue = 0;//范围最小值
    private final int maxValue = 100000000;//范围最大值
    private final int speed = 10000;//每一个线程需要计算数字的个数,改值设置的越小，每一个子线程进行计算所需时间就会相应减少，当前处于计算的总子线程数也就相应减小
    private LinkedBlockingQueue<String> result = new LinkedBlockingQueue<>();//计算结果存放队列

    @Test
    public void test_calc() {
        Timestamp startTime = new Timestamp(System.currentTimeMillis());//开始时间
        final ExecutorService calcThreadPool = Executors.newFixedThreadPool(1);//进行拆分计算的固定缓存池
        calcThreadPool.execute(new Runnable() {
            @Override
            public void run() {
                calc();
                calcThreadPool.shutdown();
            }
        });
        //从结果队列中时时取出结果
        String nextResult;
        while (!isStop || !result.isEmpty()) {
            nextResult = result.poll();
            if (nextResult == null) {
                continue;
            }
            System.out.println("now calc thread total count：" + nowThreadCount + " , now beforeValue:" + beforeValue + " ," + nextResult);
        }
        //计算完了统计一下
        System.out.println("------------------- ok ---------------------");
        System.out.println(result);
        Timestamp endTime = new Timestamp(System.currentTimeMillis());
        System.out.println(startTime + "-->" + endTime);
        System.out.println("共开起线程总数：" + threadCount);
        System.out.println((endTime.getTime() - startTime.getTime()) / 1000 + "秒");
    }

    public void calc() {
        beforeValue = minValue;
        while (true) {
            if (isChangeBeforeValue) {
                threadCount++;
                isChangeBeforeValue = false;
                try {
                    synchronized (nowThreadCount) {
                        nowThreadCount++;
                    }
                    final ExecutorService calcThreadPool = Executors.newCachedThreadPool();
                    calcThreadPool.execute(new Runnable() {
                        @Override
                        public void run() {
                            int firstValue = beforeValue + 1;
                            int lastValue = firstValue + speed;
                            final int endValue = (lastValue > maxValue ? maxValue : lastValue);
                            isStop = endValue == maxValue;
                            beforeValue = endValue;
                            isChangeBeforeValue = true;
                            StringBuilder sb = new StringBuilder();
                            for (int i = firstValue; i <= endValue; i++) {
                                String str = " " + i + "平方:" + Math.pow(i, 2);
                                sb.append(str);
                            }
                            try {
                                result.put(" calc thread " + Thread.currentThread().getId() + " => " + sb.toString());
                                sb.setLength(0);
                            } catch (InterruptedException e) {
                                e.printStackTrace();
                            }
                            synchronized (nowThreadCount) {
                                nowThreadCount--;
                            }
                            calcThreadPool.shutdown();
                        }
                    });
                } catch (Exception e) {
                    System.out.println(e.getMessage());
                    break;
                }
            }
            if (isStop && !result.isEmpty()) {
                break;
            }
        }
    }
}