無差別に技術をついばむ鳥

import java.util.*;

//直列処理でFizzBuzzを行う。
public class Main {
    public static void main(String[] args) {
        int count = 2000000;
        String[] numbers = new String[ count ];
        List target = Arrays.asList( numbers );
        long start = System.nanoTime();
        for( int i = 0; i < count; i++ ) {
            int flag = 1;
            int flag1 = 1;
            int number = i + 1;
            if ( ( flag  = number % 3 ) == 0 )
                target.set( i, "Fizz" );
            if ( ( flag1 = number % 5 ) == 0 )
                target.set( i, flag == 0 ? "Fizz Buzz" : "Buzz" );
            if ( flag != 0 && flag1 != 0 )
               target.set( i, ( ( Integer ) number ).toString() );
        }
        long stop = System.nanoTime();
        System.out.println("実行にかかった時間は " + 
            (stop - start) + " ナノ秒です。");
    }
}

import java.util.*;
import java.util.logging.Level;
import java.util.logging.Logger;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class Main {
    public static void main(String[] args) {
        String[] numbers = new String[ 2000000 ];
        long start = System.nanoTime();
        ParalleManager manager = new ParalleManager();
        try {
            manager.start(Arrays.asList(numbers));
        } catch (ArithmeticException ex) {
           System.out.print( ex.toString() );
        } catch (InterruptedException ex) {
            System.out.print( ex.toString() );
        }
        long end = System.nanoTime();
        System.out.println("実行にかかった時間は " +
                (end - start) + "ナノ秒です。");
    }
}


//並列的にFizzBuzz用の出力文字を用意するオブジェクト
public class ParalleManager {
    //フィールド
    static int coefficient = 20;
    int threadCount;

    //コンストラクタ
    public ParalleManager() {
        //作成するスレッド数を算出
        Runtime env = Runtime.getRuntime();
        int cpuCount = env.availableProcessors();
        this.threadCount = cpuCount * coefficient;
    }

    //複数のスレッドを使用して並列的にFizzBuzz用の文字を用意する
    
    public void start( List target )
            throws ArithmeticException, InterruptedException
    {
        //エラーチェック
        if (target.size() < this.threadCount )
            throw new ArithmeticException(
                "対象の要素数が少ないので並列的に実行出来ません。");
        //各種変数を準備
        int number = target.size() / this.threadCount;
        int startIndex = 0;
        int endIndex = 0;
        ExecutorService ex =
               Executors.newFixedThreadPool(this.threadCount + 1 );
        //同じ数の仕事をスレッドに割り振る
        for ( int i = 0; i < this.threadCount; i++ ) {
            endIndex = startIndex + number;
            ex.execute( 
                new FizzBuzzThread( startIndex, endIndex, target ) );
            startIndex = endIndex;
        }
        //剰余な範囲に対応
        if ( endIndex != target.size()  ) {
            ex.execute( new FizzBuzzThread(
                    endIndex, target.size(), target ) );
        }
        //スレッドが完了するのを待つ
        ex.shutdown();
    }
}


//FizzBuzz専用のスレッドオブジェクト
public class FizzBuzzThread extends Thread {
    //フィールド
    private int startIndex;
    private int endIndex;
    private List target;

    //コンストラクタ
    public FizzBuzzThread( int start, int end, List strs ) {
        this.startIndex = start;
        this.endIndex = end;
        this.target = strs;
    }

    //FizzBuzzのルールに従って数値を文字列に変換する
    public void run() {
        StringBuilder str = new StringBuilder();
        for( int i = startIndex; i < endIndex; i++ ) {
            int flag = 1;
            int flag1 = 1;
            int number = i + 1;
            if ( ( flag  = number % 3 ) == 0 )
                this.target.set( i, "Fizz" );
            if ( ( flag1 = number % 5 ) == 0 )
                this.target.set( i,
                        flag == 0 ? "Fizz Buzz" : "Buzz" );
            if ( flag != 0 && flag1 != 0 )
               this.target.set( i,
                       ( ( Integer ) number ).toString() );
        }
    }
}