Hadoop合并小文件

       在运行hadoop程序时，从hdfs上读取数据,可能会由于小文件过多而影响内存资源大量被占用，从而导致hadoop集群崩溃，或者程序执行耗时过长。(在Hadoop的世界中，小文件是指文件大小远远小于HDFS块大小的文件，Hadoop2.0中，HDFS默认的块大小是128MB，所以，比如2MB,7MB或9MB的文件就认为是小文件。)

      Hadoop的应用中，Hadoop可以很好的处理大文件，不过当文件很多，并且文件很小时，Hadoop会把每一个小文件传递给map()函数，而Hadoop在调用map()函数时会创建一个映射器，这样就会创建了大量的映射器，应用的运行效率并不高。例如，如果有2000个文件，每一个文件的大小约为2-3MB，在处理这一批文件时，就需要2000个映射器，将每一个文件发送到一个映射器，效率会非常低的。所以，在Hadoop的环境环境中，要解决这个问题，就需要把多个文件合并为一个文件，然后在进行处理。Hadoop主要设计批处理大量数据的大文件，不是很多小文件。解决小文件问题的主要目的就是通过合并小文件为更大的文件来加快Hadoop的程序的执行，解决小文件问题可以减少map()函数的执行次数，相应地提高hadoop作业的整体性能。

解决方法：

       将小文件提交到MapReduce/Hadoop之前，需要先把这些小文件合并到大文件中，再把合并的大文件提交给MapReduce驱动器程序。

       定义一个SmallFilesConsolidator类接受一组小文件，然后将这些小文件合并在一起，生成更大的Hadoop文件，这些文件的大小接近于HDFS块大小(dfs.block.size)，最优的解决方案便是尽可能创建少的文件。

       定义一个BucketThread类，这个类把小文件合并为一个大小于或接近于HDFS块大小的大文件。BucketThread是一个实现了Runable接口的独立线程，通过提供copyMerge()方法，把小文件合并为一个大文件。由于BucketThread是一个线程，所有的BucketThread对象可以并发的合并小文件。copyMerge()是BucketThread类的核心方法，它会把一个桶中的所有小文件合并为为一个临时的HDFS文件。例如，如果一个同种包含小文件｛file1,file2,file3,file4，file5｝，那么合并得到的文件如下图所示：

                                                       

SmallFilesConsolidator类的实现 

1. /**
2.  * 接受一组小Hadoop文件,然后将这些小文件合并在一起,构成更大的hadoop文件
3.  * @author hujie.hu
4.  *
5.  */
6. public class SmallFilesConsolidator {
7.     
8.     /**
9.      * 创建空桶数组
10.      * @param totals 小文件总文件数
11.      * @param available map允许数量 
12.      * @param pers 每一个Bucket的最大文件数
13.      * @return
14.      */
15.     public static BucketThread[] createBuckets(int totals, int available, int pers) {
16.         // 计算需要桶数量
17.         int nums = getNumberOfBuckets(totals, available, pers);
18.         BucketThread[] buckets = new BucketThread[nums];
19.         return buckets;
20.     }
21.     /**
22.      * 获取桶的数量
23.      * @param totals 小文件总文件数
24.      * @param available map允许数量 
25.      * @param pers 每一个Bucket的最大文件数
26.      * @return
27.      */
28.     private static int getNumberOfBuckets(int totals,int available, int pers) {
29.         // 如果文件数量小于pers * available
30.         if (totals <= (pers * available)) {
31.             return available;
32.         } else {
33.             int nums = totals / pers;
34.             int remainder = totals % pers;
35.             if (remainder == 0) {
36.                 return nums;
37.             } else {
38.                 return nums + 1;
39.             }
40.         }
41.     }
42.     
43.     /**
44.      * 填充bucket(将所有的小文件分区并填充到bucket中)
45.      * @param buckets 所有Bucket列表
46.      * @param smallFiles 小文件路径集合
47.      * @param dir 拷贝文件输出目录文件夹
48.      * @param pers  每一个Bucket的最大文件数
49.      * @throws Exception
50.      */
51.     public static void fillBuckets(BucketThread[] buckets,Configuration conf, List<Path> smallFiles, int pers,String dir)throws Exception {
52.         // 获得桶的数量
53.         int bucketSize = buckets.length;
54.         // 总文件数
55.         int totals = smallFiles.size();
56.         // 获得每个桶需要文件数量
57.         int num = totals / bucketSize;
58.         // 如果每个桶的文件数量小于每一个Bucket的最大文件数,且还有多余文件没有装到桶内,则向每个桶内再添加一个文件
59.         if (num < pers) {
60.             int remainder = totals % bucketSize;
61.             if (remainder != 0) {
62.                 num++;
63.             }
64.         }
65.  
66.         // 使用Bucket的序号定义Bucket的i(范围是从0到numberOfBuckets-1)
67.         int i = 0;
68.         int index = 0;
69.         // 标识小文件是否全部填充到桶内
70.         boolean done = false;
71.         while ((!done) & (i < bucketSize)) {
72.             // 创建一个Bucket对象
73.             buckets[i] = new BucketThread(dir,conf, i);
74.             // 使用小文件填充Bucket
75.             for (int b = 0; b < num; b++) {
76.                 buckets[i].add(smallFiles.get(index));
77.                 index++;
78.                 if (index == totals) {
79.                     done = true;
80.                     break;
81.                 }
82.             }
83.             i++;
84.         }
85.     }
86.     /**
87.      * 逐个桶合并文件
88.      * @param buckets 桶对象数组
89.      * @return
90.      * @throws Exception
91.      */
92.     public static List<Path> mergeEachBucket(BucketThread[] buckets) throws Exception {
93.         // 用于记录合并之后的文件路径
94.         List<Path> list = new ArrayList<>();
95.         // 桶对象数组为空或数组长度为0时,直接返回
96.         if (buckets == null || buckets.length < 1) {
97.             return list;
98.         }
99.         // 遍历线程数组,逐个桶合并每个桶内文件
100.         for (int i = 0; i < buckets.length; i++) {
101.             if (buckets[i] != null) {
102.                 buckets[i].start();
103.             }
104.         }
105.         // 等待所有线程完成
106.         for (int i = 0; i < buckets.length; i++) {
107.             if (buckets[i] != null) {
108.                 buckets[i].join();
109.             }
110.         }
111.         // 将每个桶内合并后的文件路径保存在集合中
112.         for (int i = 0; i < buckets.length; i++) {
113.             if (buckets[i] != null) {
114.                 Path biosetPath = buckets[i].getTargetDir();
115.                 list.add(biosetPath);
116.             }
117.         }
118.         return list;
119.     } 
120. }

 BucketThread类的实现

1. /**
2.  * 把小文件连接为一个小于hdfs块大小的大文件
3.  * @author hujie.hu
4.  *
5.  */
6. public class BucketThread implements Runnable {
7.     private static Logger logger = Logger.getLogger(BucketThread.class);
8.     
9.     private static final Path NULL_PATH = new Path("/tmp/angle/null");
10.      
11.     private Thread runner = null;
12.     private List<Path> bucket = null;
13.     private Configuration conf = null;
14.     private FileSystem fs = null;
15.     private String targetDir = null;
16.     private String targetFile = null;
17.     
18.     /**
19.      * 创建一个新的Bucket线程对象
20.      * @param parentDir 父目录
21.      * @param id 每一个Bucket都有一个唯一的ID
22.      */
23.     public BucketThread(String parentDir,Configuration conf, int id) {
24.         try {
25.             // 桶的存储路径
26.             this.targetDir = parentDir + File.separator + id;
27.             // 合并之后生成的大文件路径
28.             this.targetFile = targetDir + File.separator + id + ".lzo";
29.             this.conf = conf;
30.             // 当前线程执行对象
31.             this.runner = new Thread(this);
32.             this.fs = FileSystem.get(URI.create("hdfs://ns1"),conf);
33.             this.bucket = new ArrayList<>();
34.         } catch (Exception e) {
35.             logger.error("创建bucket对象错误,父目录/bucketID:"+parentDir+"/"+id, e);
36.         }
37.     }
38.     /**
39.      * 线程执行
40.      */
41.     @Override
42.     public void run() {
43.         try {
44.             copyMerge();
45.         } catch (Exception e) {
46.             logger.error("run(): copyMerge() failed.", e);
47.         }
48.     }
49.     /**
50.      * 逐个桶和并文件
51.      * @throws IOException
52.      */
53.     private void copyMerge() throws IOException {
54.         // 如果bucket中只有一个路径/dir，则不需要合并它
55.         if (bucket.size() < 2) {
56.             return;
57.         }
58.         Path hdfsTargetFile = new Path(targetFile);
59.         LzopCodec lzo=new LzopCodec();
60.         lzo.setConf(conf);
61.         // 创建输出流,合并为大文件
62.         OutputStream out = lzo.createOutputStream(fs.create(hdfsTargetFile));
63.         for (int i = 0; i < bucket.size(); i++) {
64.             FileStatus[] contents = fs.listStatus(bucket.get(i));
65.             for (int k = 0; k < contents.length; k++) {
66.                 if (!contents[k].isDirectory()) {
67.                     InputStream in = lzo.createInputStream(fs.open(contents[k].getPath()));
68.                     IOUtils.copyBytes(in, out, this.conf, false);
69.                     in.close();
70.                 }
71.             }
72.  
73.         }
74.         out.close();
75.     }
76.     
77.     /**
78.      * 添加一个文件到Bucket中
79.      * @param path
80.      * @throws Exception 
81.      */
82.     public void add(Path path) throws Exception {
83.         if (path == null) {
84.             return;
85.         }
86.         if (fs.exists(path)) {
87.             bucket.add(path);
88.         }
89.     }
90.     /**
91.      * 启动线程
92.      */
93.     public void start() {
94.         runner.start();
95.     }
96.     /**
97.      * 连接并等待其他线程
98.      */
99.     public void join() {
100.         try {
101.             runner.join();
102.         } catch (InterruptedException e) {
103.             logger.error("线程连接发生错误", e);
104.         }
105.     }
106.     /**
107.      * 获得合并后桶的路径
108.      * @return
109.      */
110.     public Path getTargetDir() {
111.         if (bucket.isEmpty()) {
112.             // 没有文件的空目录
113.             return NULL_PATH;
114.         } else if (bucket.size() == 1) {
115.             return bucket.get(0);
116.         } else {
117.             // bucket有两个或更多的文件，并且已经被合并
118.             return new Path(targetDir);
119.         }
120.     }
121. }
      

 调用方法

1. // 小文件合并成大文件
2. int available = 15;
3. int pers = 10;
4. List<Path> validlist = new ArrayList<>();
5. validlist = LoadHdfs.readFile2List(ReadConf.jobsvalidPath,month,validlist);
6. BucketThread[] buckets = SmallFilesConsolidator.createBuckets(validlist.size(), available, pers);
7. SmallFilesConsolidator.fillBuckets(buckets, conf, validlist, pers, ReadConf.mixValidPath);
8. List<Path> validBucket = SmallFilesConsolidator.mergeEachBucket(buckets);