Hadoop下MapReduce实现Pi值的计算

Hadoop自带的例子中，有一个计算Pi值的例子。

这个程序的原理是这样的。假如有一个边长为1的正方形。以正方形的一个端点为圆心，以1为半径，画一个圆弧，于是在正方形内就有了一个直角扇形。在正方形里随机生成若干的点，则有些点是在扇形内，有些点是在扇形外。正方形的面积是1，扇形的面积是0.25*Pi。设点的数量一共是n，扇形内的点数量是nc，在点足够多足够密集的情况下，会近似有nc/n的比值约等于扇形面积与正方形面积的比值，也就是nc/n= 0.25*Pi/1，即Pi = 4*nc/n。

在正方形内生成的样本点越多，计算Pi值越精确，这样，这个问题就很适合用Hadoop来处理啦。假设要在正方形内生成1000万个点，可以设置10个Map任务，每个Map任务处理100万个点，也可以设置100个Map任务，每个Map任务处理10万个点。

package mapreduce1;
/*
 *  @create by 刘大哥
 *  2019年9月3日
   *       利用MapReduce计算pi值
 * */
import java.io.IOException;
import java.util.StringTokenizer;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.IntWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Job;
import org.apache.hadoop.mapreduce.Mapper;
import org.apache.hadoop.mapreduce.Reducer;
import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;
import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;
import PI.Pi;  

    public class WordCount {
        public static void main(String[] args) throws IOException, ClassNotFoundException, InterruptedException {
            Job job = Job.getInstance();
            job.setJobName("WordCount");
            job.setJarByClass(WordCount.class);
            job.setMapperClass(doMapper.class);
            job.setReducerClass(doReducer.class);
            job.setOutputKeyClass(Text.class);
            job.setOutputValueClass(IntWritable.class);
            Path in = new Path("hdfs://192.168.100.129:9000/user/hadoop/p1i.txt");   //输入路径
            Path out = new Path("hdfs://192.168.100.129:9000/user/hadoop/out_pi1");  //输出路径
            FileInputFormat.addInputPath(job, in);
            FileOutputFormat.setOutputPath(job, out);
            System.exit(job.waitForCompletion(true) ?  : );
        }
        public static class doMapper extends Mapper<Object, Text, Text, IntWritable>{
            private static final IntWritable one = new IntWritable();
            @Override
            protected void map(Object key, Text value, Context context) throws IOException, InterruptedException {
                String line =  value.toString();
                String word = line.toString();         //读取每个map的数值
                //System.out.println(word);
                int num = Integer.parseInt(word);      //转化为int类型
                //System.out.println(num);
                int[] base = {,};
                Pi test = new Pi(base);
                int a= ;         // 是否在扇形区域内的标志符  1：在扇形区域内 2：不在扇形区域内
                int count = ;  // 统计在扇形区域内点的个数
                for(int x = ; x < num; x++){
                    double[] t = test.getNext();
                    if(t[]*t[]+t[]*t[]<) {  //在扇形区域内
                        a=;
                        count++;                 //在扇形区域内的个数加+
                    }
                    else {                       //不在扇形区域内
                        a=;
                    }

                }
                double result= count*4.00000000/num;    //每个map计算出pi的值
                String strresule = String.valueOf(result);
                Text textresult = new Text();              /*转换类型为Text */
                textresult.set(strresule);
                context.write(textresult, one);         //写入
            }
        }
        public static class doReducer extends Reducer<Text, IntWritable, Text, IntWritable>{   //reduce 整合输出
            private IntWritable result = new IntWritable();
            @Override
            protected void reduce(Text key, Iterable<IntWritable> values, Context context)
            throws IOException, InterruptedException {
            int sum = ;
            for (IntWritable value : values) {
                sum += value.get();
            }
                result.set(sum);
                context.write(key, result);
            }
        }
    }