ITPub博客
首页 博客 专栏 学院 社区 IT新媒体评选
发博

首页 > 应用开发 > Java > 外部排序

外部排序

原创 Java 作者：壹頁書 时间：2014-05-23 00:15:29 0 删除 编辑
外部排序
如果需要排序的文件超过了内存的大小，就需要分块排序，按块写入文件，最后再归并已经有序的分块文件。

第一阶段 切分排序
1.将原始未排序的大文件，分为有序的小文件
    1.1确定大文件切分的位置
    1.2主线程按块读取原始文件,然后交给排序线程
    1.3排序线程,对块进行排序
    1.4写入线程将有序的数据，写入文件


第二阶段 归并
    将临时文件归并到目标的结果文件

作为JAVA程序，需要注意的是，第一阶段是IO密集型,尽量分配更多的内存给Old区
而第二阶段是CPU密集型,需要注意Young区,避免过多的GC占用CPU资源。

需要提前了解的技术细节。
1.JAVA切分大文件
http://blog.itpub.net/29254281/viewspace-1161173/

2.JAVA内存映射文件
http://blog.itpub.net/29254281/viewspace-1162157/

3.JAVA栅栏
http://blog.itpub.net/29254281/viewspace-1164727/

4.观察者模式、生产者/消费者模式    

5.JVM监控和GC

实验环境:
双核CPU,使用1G的JAVA堆内存,对2亿long型随机数排序,一般情况下,2亿long型随机数文件4G左右大小。




总体设计的思路
Main主线程负责切分原始文件,blocking函数根据文件分片的设置，返回原始文件的分块。
这样主要为了分块包含整行，而不会切断数据。
读取出来的原始未排序数据封装为Sorter对象,提交给排序线程池。
排序之后的数据,封装为Writer对象,再交给写入线程池,将排序好的分块写入临时文件。
在每个分块写入之后，线程在CyclicBarrier栅栏处等待,待所有的分块写入完毕,启用归并。
需要特别注意的是,在栅栏等待之前,一定要释放所有的资源,以便JVM GC回收内存。
就是Writer对象write方法的下列代码

归并非常消耗CPU资源。
在归并的过程中，因为每个分块本身都是有序的,所以只需要一个线程计算各个分块中最小的数字，将其写入BlockingQueue。
而另一个线程,不断的将队列的数据顺序写入目标文件。
这就是Merge对象的作用。这个过程使用了观察者模式和生产者消费者模式。

实现如下:
  1. import java.io.BufferedInputStream;
  2. import java.io.BufferedOutputStream;
  3. import java.io.File;
  4. import java.io.FileInputStream;
  5. import java.io.FileOutputStream;
  6. import java.io.IOException;
  7. import java.io.RandomAccessFile;
  8. import java.nio.MappedByteBuffer;
  9. import java.nio.channels.FileChannel;
  10. import java.nio.channels.FileChannel.MapMode;
  11. import java.util.ArrayList;
  12. import java.util.Arrays;
  13. import java.util.Collections;
  14. import java.util.List;
  15. import java.util.Queue;
  16. import java.util.concurrent.BlockingQueue;
  17. import java.util.concurrent.BrokenBarrierException;
  18. import java.util.concurrent.ConcurrentLinkedQueue;
  19. import java.util.concurrent.CyclicBarrier;
  20. import java.util.concurrent.ExecutorService;
  21. import java.util.concurrent.Executors;
  22. import java.util.concurrent.LinkedBlockingQueue;

  24. public class Controller {
  25.     public static void main(String[] args) throws IOException {
  26.         Controller c = new Controller(new File("/home/lihuilin/桌面/t.txt"), 15, "/home/lihuilin/桌面/");
  27.     }

  29.     // 排序线程池
  30.     private final ExecutorService sortThread;
  31.     // 写入线程池，将排序之后的分片写入文件
  32.     private final ExecutorService writerThread;
  33.     // 栅栏,等待所有分片写入文件之后，启动合并
  34.     private final CyclicBarrier barrier;
  35.     // 原始没有顺序的大文件
  36.     private final File file;
  37.     // 分片大小
  38.     private final int pieces;
  39.     // 输出目录
  40.     private final String outDir;
  41.     // 记录分片写入临时文件的位置
  42.     private final List<File> outFileList = new ArrayList<File>();

  44.     public Controller(File file, int pieces, final String outDir) throws IOException {
  45.         final long start = System.currentTimeMillis();
  46.         sortThread = Executors.newFixedThreadPool(1);
  47.         // 写入线程池的线程数一定不能小于分片的大小。否则CyclicBarrier
  48.         // await之后，后续的分片将没有线程可用。await不会释放线程资源。
  49.         writerThread = Executors.newFixedThreadPool(pieces + 1);
  50.         this.file = file;
  51.         this.pieces = pieces;
  52.         this.outDir = outDir;
  53.         this.barrier = new CyclicBarrier(pieces, new Runnable() {

  55.             @Override
  56.             public void run() {
  57.                 long end = System.currentTimeMillis();
  58.                 System.out.println("合并之前总用时:" + (end - start) / 1000 + "s");
  59.                 // 合并有序的分片临时文件
  60.                 Merger merger = new Merger(outFileList, outDir);
  61.                 writerThread.submit(merger);
  62.                 try {
  63.                     merger.merge();
  64.                 } catch (IOException e) {
  65.                     // TODO Auto-generated catch block
  66.                     e.printStackTrace();
  67.                 } catch (InterruptedException e) {
  68.                     // TODO Auto-generated catch block
  69.                     e.printStackTrace();
  70.                 }

  72.                 writerThread.shutdown();
  73.                 sortThread.shutdown();
  74.                 end = System.currentTimeMillis();
  75.                 System.out.println("外部排序总用时:" + (end - start) / 1000 + "s");
  76.             }
  77.         });
  78.         action();
  79.     }

  81.     private void action() throws IOException {
  82.         List<Point> list = blocking(file, pieces);
  83.         for (Point p : list) {
  84.             Spilter spilter = new MappedByteBufferSpilter(file, p);
  85.             long[] data = null;
  86.             data = spilter.spilt();
  87.             Sorter s = new Sorter(data, p, writerThread, barrier, outFileList);
  88.             sortThread.submit(s);
  89.         }

  91.     }

  93.     private List<Point> blocking(File file, int piece) throws IOException {
  94.         List<Point> result = new ArrayList<Point>();
  95.         List<Long> list = new ArrayList<Long>();
  96.         list.add(-1L);
  97.         long length = file.length();
  98.         long step = length / piece;
  99.         long index = 0;
  100.         for (int i = 0; i < piece; i++) {
  101.             BufferedInputStream in = new BufferedInputStream(new FileInputStream(file));
  102.             if (index + step < length) {
  103.                 index = index + step;
  104.                 in.skip(index);

  106.                 while (in.read() != 10) {
  107.                     index = index + 1;
  108.                 }
  109.                 list.add(index);
  110.                 index++;
  111.             }
  112.             in.close();
  113.         }
  114.         list.add(length - 1);
  115.         for (int i = 0; i < list.size() - 1; i++) {
  116.             long skipSize = list.get(i) + 1;
  117.             long l = list.get(i + 1) - list.get(i);
  118.             result.add(new Point(skipSize, l, outDir));

  120.         }
  121.         return result;
  122.     }

  124. }

  126. class Merger implements Runnable {
  127.     private final List<Worker> workerList = new ArrayList<Worker>();
  128.     private String outDir = null;
  129.     private BlockingQueue<Long> queue = new LinkedBlockingQueue<Long>(1000);
  130.     private volatile boolean finished = false;

  132.     public Merger(List<File> outFileList, String outDir) {
  133.         for (File file : outFileList) {
  134.             Worker worker = new Worker(file, workerList);
  135.             workerList.add(worker);
  136.         }
  137.         this.outDir = outDir;
  138.     }

  140.     @Override
  141.     public void run() {
  142.         try {
  143.             System.out.println("读取队列,写入目标文件");
  144.             BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(outDir + "result.txt"), 50 * 1024 * 1024);
  145.             while (finished != true || !queue.isEmpty()) {
  146.                 Long l = queue.take();
  147.                 bos.write((l + "\n").getBytes());
  148.             }
  149.             bos.flush();
  150.             bos.close();
  151.         } catch (Exception ex) {
  152.             ex.printStackTrace();
  153.         }
  154.     }

  156.     public void merge() throws IOException, InterruptedException {
  157.         while (workerList.size() != 0) {
  158.             Collections.sort(workerList);
  159.             Worker worker = workerList.get(0);
  160.             Long data = worker.poll();
  161.             if (data == null) {
  162.                 workerList.remove(worker);
  163.             } else {
  164.                 queue.put(data);
  165.             }
  166.         }
  167.         finished = true;
  168.     }

  170.     private class Worker implements Comparable<Worker> {
  171.         private long data;
  172.         private MappedByteBuffer buffer = null;
  173.         private List<Worker> workerList = null;
  174.         private boolean eof = false;

  176.         Worker(File file, List<Worker> workerList) {
  177.             try {
  178.                 RandomAccessFile rFile = new RandomAccessFile(file, "r");
  179.                 FileChannel channel = rFile.getChannel();
  180.                 buffer = channel.map(MapMode.READ_ONLY, 0, channel.size());
  181.                 channel.close();
  182.                 rFile.close();
  183.                 this.workerList = workerList;
  184.                 data = buffer.getLong();
  185.             } catch (IOException e) {
  186.                 // TODO Auto-generated catch block
  187.                 e.printStackTrace();
  188.             }
  189.         }

  191.         public long peek() {
  192.             return data;
  193.         }

  195.         public Long poll() {
  196.             long result = data;
  197.             if (buffer.position() != buffer.limit()) {
  198.                 data = buffer.getLong();
  199.             } else {
  200.                 if (eof == false) {
  201.                     eof = true;
  202.                 } else {
  203.                     return null;
  204.                 }
  205.             }

  207.             return result;
  208.         }

  210.         @Override
  211.         public int compareTo(Worker o) {
  212.             if (this.peek() > o.peek()) {
  213.                 return 1;
  214.             } else if (this.peek() < o.peek()) {
  215.                 return -1;
  216.             } else {
  217.                 return 0;
  218.             }
  219.         }
  220.     }

  222. }

  224. interface Spilter {
  225.     public long[] spilt();
  226. }

  228. class Sorter implements Runnable {
  229.     long[] data;
  230.     Point p;
  231.     ExecutorService writerThread;
  232.     List<File> outFileList;
  233.     CyclicBarrier barrier;

  235.     public Sorter(long[] data, Point p, ExecutorService writerThread, CyclicBarrier barrier, List<File> outFileList) {
  236.         this.data = data;
  237.         this.p = p;
  238.         this.outFileList = outFileList;
  239.         this.barrier = barrier;
  240.         this.writerThread = writerThread;
  241.     }

  243.     public long[] sort() {
  244.         System.out.println("\t开始排序:" + p);
  245.         long start = System.currentTimeMillis();
  246.         Arrays.sort(this.data);
  247.         long end = System.currentTimeMillis();
  248.         System.out.println("\t结束排序:" + p + ",用时:" + (end - start) / 1000);
  249.         return this.data;
  250.     }

  252.     @Override
  253.     public void run() {
  254.         Writer writer = new MappedByteBufferWriter(sort(), p, barrier, outFileList);
  255.         writerThread.submit(writer);
  256.     }
  257. }

  259. interface Writer extends Runnable {
  260.     public void write();
  261. }

  263. class MappedByteBufferWriter implements Writer {
  264.     private static int FLAG = 1;
  265.     private CyclicBarrier barrier = null;
  266.     private File outfile = null;
  267.     private Point point = null;

  269.     private long[] data = null;
  270.     private List<File> outFileList = null;

  272.     public MappedByteBufferWriter(long[] data, Point point, CyclicBarrier barrier, List<File> outFileList) {
  273.         this.data = data;
  274.         this.point = point;
  275.         this.outfile = new File(point.getOutDir() + FLAG + ".txt");
  276.         this.barrier = barrier;
  277.         this.outFileList = outFileList;
  278.         FLAG++;
  279.     }

  281.     @Override
  282.     public void write() {
  283.         try {
  284.             System.out.println("\t\t开始写入:" + point);
  285.             long start = System.currentTimeMillis();
  286.             FileChannel channel = new RandomAccessFile(this.outfile, "rw").getChannel();
  287.             MappedByteBuffer buffer = channel.map(MapMode.READ_WRITE, 0, this.data.length * 8);
  288.             for (int i = 0; i < data.length; i++) {
  289.                 buffer.putLong(data[i]);
  290.             }
  291.             buffer.force();
  292.             long end = System.currentTimeMillis();
  293.             System.out.println("\t\t结束写入:" + point + ",用时:" + (end - start) / 1000);
  294.             synchronized (outFileList) {
  295.                 outFileList.add(outfile);
  296.             }
  297.             this.data = null;
  298.             channel.close();
  299.             buffer = null;
  300.             barrier.await();
  301.         } catch (IOException ex) {
  302.             ex.printStackTrace();
  303.         } catch (InterruptedException e) {
  304.             // TODO Auto-generated catch block
  305.             e.printStackTrace();
  306.         } catch (BrokenBarrierException e) {
  307.             // TODO Auto-generated catch block
  308.             e.printStackTrace();
  309.         }
  310.     }

  312.     @Override
  313.     public void run() {
  314.         this.write();
  315.     }

  317. }

  319. class MappedByteBufferSpilter implements Spilter {
  320.     private File file;
  321.     private Point point;

  323.     public MappedByteBufferSpilter(File file, Point p) {
  324.         this.file = file;
  325.         this.point = p;
  326.     }

  328.     @Override
  329.     public long[] spilt() {
  330.         System.out.println("开始读入:" + point);
  331.         long start = System.currentTimeMillis();
  332.         long[] result = null;
  333.         try {

  335.             FileChannel in = new RandomAccessFile(file, "r").getChannel();
  336.             MappedByteBuffer inBuffer = in.map(MapMode.READ_ONLY, point.getSkipSize(), point.getLength());

  338.             byte[] data = new byte[inBuffer.limit()];
  339.             inBuffer.get(data);
  340.             result = new long[getObjectSize(data)];
  341.             int resultIndex = 0;
  342.             int index = 0;
  343.             int first = 0;
  344.             while (index < data.length) {
  345.                 if (data[index] == 10) {
  346.                     byte[] tmpData = Arrays.copyOfRange(data, first, index);
  347.                     String str = new String(tmpData);
  348.                     result[resultIndex] = Long.valueOf(str);
  349.                     resultIndex++;
  350.                     first = index + 1;
  351.                 }

  353.                 index++;
  354.             }
  355.             in.close();

  357.         } catch (IOException ex) {
  358.             ex.printStackTrace();
  359.         }
  360.         long end = System.currentTimeMillis();
  361.         System.out.println("结束读入:" + point + ",用时:" + (end - start) / 1000);
  362.         return result;
  363.     }

  365.     private int getObjectSize(byte[] data) {
  366.         int size = 0;
  367.         for (byte b : data) {
  368.             if (b == 10) {
  369.                 size++;
  370.             }
  371.         }
  372.         return size;
  373.     }

  375. }

  377. class Point {
  378.     public Point(long skipSize, long length, String outDir) {
  379.         if (length > Integer.MAX_VALUE) {
  380.             throw new RuntimeException("长度溢出");
  381.         }
  382.         this.skipSize = skipSize;
  383.         this.length = (int) length;
  384.         this.outDir = outDir;
  385.     }

  387.     @Override
  388.     public String toString() {
  389.         return "Point [skipSize=" + skipSize + ", length=" + length + "]";
  390.     }

  392.     private long skipSize;
  393.     private int length;
  394.     private String outDir;

  396.     public String getOutDir() {
  397.         return outDir;
  398.     }

  400.     public long getSkipSize() {
  401.         return skipSize;
  402.     }

  404.     public int getLength() {
  405.         return length;
  406.     }
  407. }
运行:
  1. [lihuilin@lihuilin 桌面]$ java Controller
  2. 开始读入:Point [skipSize=0, length=271726519]
  3. 结束读入:Point [skipSize=0, length=271726519],用时:8
  4. 开始读入:Point [skipSize=271726519, length=271726515]
  5. 开始排序:Point [skipSize=0, length=271726519]
  6. 结束排序:Point [skipSize=0, length=271726519],用时:3
  7. 开始写入:Point [skipSize=0, length=271726519]
  8. 结束写入:Point [skipSize=0, length=271726519],用时:2
  9. 结束读入:Point [skipSize=271726519, length=271726515],用时:9
  10. 开始排序:Point [skipSize=271726519, length=271726515]
  11. 开始读入:Point [skipSize=543453034, length=271726511]
  12. 结束排序:Point [skipSize=271726519, length=271726515],用时:4
  13. 开始写入:Point [skipSize=271726519, length=271726515]
  14. 结束写入:Point [skipSize=271726519, length=271726515],用时:3
  15. 结束读入:Point [skipSize=543453034, length=271726511],用时:9
  16. 开始读入:Point [skipSize=815179545, length=271726515]
  17. 开始排序:Point [skipSize=543453034, length=271726511]
  18. 结束排序:Point [skipSize=543453034, length=271726511],用时:3
  19. 开始写入:Point [skipSize=543453034, length=271726511]
  20. 结束写入:Point [skipSize=543453034, length=271726511],用时:5
  21. 结束读入:Point [skipSize=815179545, length=271726515],用时:13
  22. 开始读入:Point [skipSize=1086906060, length=271726524]
  23. 开始排序:Point [skipSize=815179545, length=271726515]
  24. 结束排序:Point [skipSize=815179545, length=271726515],用时:3
  25. 开始写入:Point [skipSize=815179545, length=271726515]
  26. 结束写入:Point [skipSize=815179545, length=271726515],用时:5
  27. 结束读入:Point [skipSize=1086906060, length=271726524],用时:13
  28. 开始读入:Point [skipSize=1358632584, length=271726507]
  29. 开始排序:Point [skipSize=1086906060, length=271726524]
  30. 结束排序:Point [skipSize=1086906060, length=271726524],用时:3
  31. 开始写入:Point [skipSize=1086906060, length=271726524]
  32. 结束写入:Point [skipSize=1086906060, length=271726524],用时:5
  33. 结束读入:Point [skipSize=1358632584, length=271726507],用时:12
  34. 开始读入:Point [skipSize=1630359091, length=271726523]
  35. 开始排序:Point [skipSize=1358632584, length=271726507]
  36. 结束排序:Point [skipSize=1358632584, length=271726507],用时:3
  37. 开始写入:Point [skipSize=1358632584, length=271726507]
  38. 结束写入:Point [skipSize=1358632584, length=271726507],用时:5
  39. 结束读入:Point [skipSize=1630359091, length=271726523],用时:13
  40. 开始读入:Point [skipSize=1902085614, length=271726514]
  41. 开始排序:Point [skipSize=1630359091, length=271726523]
  42. 结束排序:Point [skipSize=1630359091, length=271726523],用时:3
  43. 开始写入:Point [skipSize=1630359091, length=271726523]
  44. 结束写入:Point [skipSize=1630359091, length=271726523],用时:5
  45. 结束读入:Point [skipSize=1902085614, length=271726514],用时:13
  46. 开始读入:Point [skipSize=2173812128, length=271726519]
  47. 开始排序:Point [skipSize=1902085614, length=271726514]
  48. 结束排序:Point [skipSize=1902085614, length=271726514],用时:3
  49. 开始写入:Point [skipSize=1902085614, length=271726514]
  50. 结束写入:Point [skipSize=1902085614, length=271726514],用时:5
  51. 结束读入:Point [skipSize=2173812128, length=271726519],用时:13
  52. 开始读入:Point [skipSize=2445538647, length=271726516]
  53. 开始排序:Point [skipSize=2173812128, length=271726519]
  54. 结束排序:Point [skipSize=2173812128, length=271726519],用时:3
  55. 开始写入:Point [skipSize=2173812128, length=271726519]
  56. 结束写入:Point [skipSize=2173812128, length=271726519],用时:5
  57. 结束读入:Point [skipSize=2445538647, length=271726516],用时:12
  58. 开始读入:Point [skipSize=2717265163, length=271726517]
  59. 开始排序:Point [skipSize=2445538647, length=271726516]
  60. 结束排序:Point [skipSize=2445538647, length=271726516],用时:3
  61. 开始写入:Point [skipSize=2445538647, length=271726516]
  62. 结束写入:Point [skipSize=2445538647, length=271726516],用时:5
  63. 结束读入:Point [skipSize=2717265163, length=271726517],用时:13
  64. 开始读入:Point [skipSize=2988991680, length=271726517]
  65. 开始排序:Point [skipSize=2717265163, length=271726517]
  66. 结束排序:Point [skipSize=2717265163, length=271726517],用时:3
  67. 开始写入:Point [skipSize=2717265163, length=271726517]
  68. 结束写入:Point [skipSize=2717265163, length=271726517],用时:5
  69. 结束读入:Point [skipSize=2988991680, length=271726517],用时:12
  70. 开始读入:Point [skipSize=3260718197, length=271726516]
  71. 开始排序:Point [skipSize=2988991680, length=271726517]
  72. 结束排序:Point [skipSize=2988991680, length=271726517],用时:3
  73. 开始写入:Point [skipSize=2988991680, length=271726517]
  74. 结束写入:Point [skipSize=2988991680, length=271726517],用时:5
  75. 结束读入:Point [skipSize=3260718197, length=271726516],用时:12
  76. 开始读入:Point [skipSize=3532444713, length=271726515]
  77. 开始排序:Point [skipSize=3260718197, length=271726516]
  78. 结束排序:Point [skipSize=3260718197, length=271726516],用时:3
  79. 开始写入:Point [skipSize=3260718197, length=271726516]
  80. 结束写入:Point [skipSize=3260718197, length=271726516],用时:5
  81. 结束读入:Point [skipSize=3532444713, length=271726515],用时:12
  82. 开始读入:Point [skipSize=3804171228, length=271726376]
  83. 开始排序:Point [skipSize=3532444713, length=271726515]
  84. 结束排序:Point [skipSize=3532444713, length=271726515],用时:3
  85. 开始写入:Point [skipSize=3532444713, length=271726515]
  86. 结束写入:Point [skipSize=3532444713, length=271726515],用时:4
  87. 结束读入:Point [skipSize=3804171228, length=271726376],用时:12
  88. 开始排序:Point [skipSize=3804171228, length=271726376]
  89. 结束排序:Point [skipSize=3804171228, length=271726376],用时:2
  90. 开始写入:Point [skipSize=3804171228, length=271726376]
  91. 结束写入:Point [skipSize=3804171228, length=271726376],用时:3
  92. 合并之前总用时:190s
  93. 读取队列,写入目标文件
  94. 外部排序总用时:398s
JVM监控:


从监控可以看到第一阶段是IO密集型,对于内存需要很大;
而第二阶段,排序各个分块对于CPU压力很大,一定要注意不要让GC线程占用过多CPU资源,就是Young区不能过小。

上图中FGC 55之后的就是第二阶段的过程,Young GC明显增多。

验证:
开始使用1-100的实验数据，可以正确排序。
大文件排序之后，可以使用Linux Sort命令验证。


关于性能优化
外部排序的本质就是排序写入小文件，再将小文件归并为有序的目标文件。
所以时间大致应该是拷贝这个文件的时间乘以2.

但是...
想起在15所的时候，吴老师使用大致与我性能相当的配置，居然只用了230S左右..
优化需要注意的两点
1.内存映射文件
    文件复制,分块文件写入然后读出这种场景使用内存映射文件，避免了内核空间和用户空间的内存复制。并且可以使用堆外操作系统内存作为缓存.
2.避免GC占用CPU
    读取文件和写入文件的时候,Byte和Long做转换的时候，均采用了String类型作为中转,
    

    
    后续可以考虑直接将byte和long型互转,避免引入String类型,这样就可以避免额外的GC

第一点都很容易想到,而第二点吴老师做了,我没有实现,这可能是导致性能较慢的原因。
以后有时间再补上这个细节吧。
因为使用了内存映射文件,比了避免误差,每次实验之前最好清除缓存。

来自 “ ITPUB博客 ” ，链接：https://blog.itpub.net/29254281/viewspace-1167988/ ，如需转载，请注明出处，否则将追究法律责任。

0
0
上一篇： MySQL的Group By分组
下一篇： 外部排序优化
请登录后发表评论 登录
全部评论
壹頁書

注册时间：2013-10-19

  • 博文量
    620
  • 访问量
    6339971

最新文章

支持我们 作者招募 用户协议 FAQ Contact Us

北京盛拓优讯信息技术有限公司. 版权所有  京ICP备16024965号-8 北京市公安局海淀分局网监中心备案编号：11010802021510 niuxiaotong@pcpop.com 17352615567 未成年人举报专区

广播电视节目制作经营许可证(京) 字第1234号 中国互联网协会会员

违法和不良信息举报电话:18101376593