前言：
眼前兄弟们对“java处理视频”大概比较珍视，你们都想要学习一些“java处理视频”的相关内容。那么小编在网络上搜集了一些关于“java处理视频””的相关文章，希望看官们能喜欢，咱们快快来学习一下吧！一、场景说明
现有一个10G文件的数据，里面包含了18-70之间的整数，分别表示18-70岁的人群数量统计，假设年龄范围分布均匀，分别表示系统中所有用户的年龄数，找出重复次数最多的那个数，现有一台内存为4G、2核CPU的电脑，请写一个算法实现。
23,31,42,19,60,30,36,........
二、模拟数据
Java中一个整数占4个字节，模拟10G为30亿左右个数据， 采用追加模式写入10G数据到硬盘里。
每100万个记录写一行，大概4M一行，10G大概2500行数据。
package bigdata;import java.io.*;import java.util.Random;/** * @Desc: * @Author: bingbing * @Date: 2022/5/4 0004 19:05 */public class GenerateData { private static Random random = new Random(); public static int generateRandomData(int start, int end) { return random.nextInt(end - start + 1) + start; } /** * 产生10G的 1-1000的数据在D盘 */ public void generateData() throws IOException { File file = new File("D:\\ User.dat"); if (!file.exists()) { try { file.createNewFile(); } catch (IOException e) { e.printStackTrace(); } } int start = 18; int end = 70; long startTime = System.currentTimeMillis(); BufferedWriter bos = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(file, true))); for (long i = 1; i < Integer.MAX_VALUE * 1.7; i++) { String data = generateRandomData(start, end) + ","; bos.write(data); // 每100万条记录成一行，100万条数据大概4M if (i % 1000000 == 0) { bos.write("\n"); } } System.out.println("写入完成! 共花费时间:" + (System.currentTimeMillis() - startTime) / 1000 + " s"); bos.close(); } public static void main(String[] args) { GenerateData generateData = new GenerateData(); try { generateData.generateData(); } catch (IOException e) { e.printStackTrace(); } }}上述代码调整参数执行2次, 凑10个G的数据在D盘的User.dat文件里：
准备好10G数据后，接着写如何处理这些数据
三、场景分析
10G的数据比当前拥有的运行内存大的多，不能全量加载到内存中读取，如果采用全量加载，那么内存会直接爆掉，只能按行读取，Java中的bufferedReader的readLine()按行读取文件里的内容。
四、读取数据
首先我们写一个方法单线程读完这30E数据需要多少时间，每读100行打印一次:
private static void readData() throws IOException { BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream(FILE_NAME), "utf-8")); String line; long start = System.currentTimeMillis(); int count = 1; while ((line = br.readLine()) != null) { // 按行读取// SplitData.splitLine(line); if (count % 100 == 0) { System.out.println("读取100行,总耗时间: " + (System.currentTimeMillis() - start) / 1000 + " s"); System.gc(); } count++; } running = false; br.close(); }按行读完10G的数据大概20秒，基本每100行，1E多数据花1S，速度还挺快:
五、处理数据
思路一
通过单线程处理，初始化一个countMap, key为年龄，value为出现的次数, 将每行读取到的数据按照"," 进行分割，然后获取到的每一项进行保存到countMap里，如果存在，那么值key的value+1。
for (int i = start; i <= end; i++) { try { File subFile = new File(dir + "\\" + i + ".dat"); if (!file.exists()) { subFile.createNewFile(); } countMap.computeIfAbsent(i + "", integer -> new AtomicInteger(0)); } catch (FileNotFoundException e) { e.printStackTrace(); } catch (IOException e) { e.printStackTrace(); } }单线程读取并统计countMap:
public static void splitLine(String lineData) { String[] arr = lineData.split(","); for (String str : arr) { if (StringUtils.isEmpty(str)) { continue; } countMap.computeIfAbsent(str, s -> new AtomicInteger(0)).getAndIncrement(); } }通过比较找出年龄数最多的年龄并打印出来:
private static void findMostAge() { Integer targetValue = 0; String targetKey = null; Iterator<Map.Entry<String, AtomicInteger>> entrySetIterator = countMap.entrySet().iterator(); while (entrySetIterator.hasNext()) { Map.Entry<String, AtomicInteger> entry = entrySetIterator.next(); Integer value = entry.getValue().get(); String key = entry.getKey(); if (value > targetValue) { targetValue = value; targetKey = key; } } System.out.println("数量最多的年龄为:" + targetKey + "数量为：" + targetValue); }完整代码
package bigdata;import org.apache.commons.lang3.StringUtils;import java.io.*;import java.util.*;import java.util.concurrent.ConcurrentHashMap;import java.util.concurrent.atomic.AtomicInteger;/** * @Desc: * @Author: bingbing * @Date: 2022/5/4 0004 19:19 * 单线程处理 */public class HandleMaxRepeatProblem_v0 { public static final int start = 18; public static final int end = 70; public static final String dir = "D:\\dataDir"; public static final String FILE_NAME = "D:\\ User.dat"; /** * 统计数量 */ private static Map<String, AtomicInteger> countMap = new ConcurrentHashMap<>(); /** * 开启消费的标志 */ private static volatile boolean startConsumer = false; /** * 消费者运行保证 */ private static volatile boolean consumerRunning = true; /** * 按照 "," 分割数据，并写入到countMap里 */ static class SplitData { public static void splitLine(String lineData) { String[] arr = lineData.split(","); for (String str : arr) { if (StringUtils.isEmpty(str)) { continue; } countMap.computeIfAbsent(str, s -> new AtomicInteger(0)).getAndIncrement(); } } } /** * init map */ static { File file = new File(dir); if (!file.exists()) { file.mkdir(); } for (int i = start; i <= end; i++) { try { File subFile = new File(dir + "\\" + i + ".dat"); if (!file.exists()) { subFile.createNewFile(); } countMap.computeIfAbsent(i + "", integer -> new AtomicInteger(0)); } catch (FileNotFoundException e) { e.printStackTrace(); } catch (IOException e) { e.printStackTrace(); } } } public static void main(String[] args) { new Thread(() -> { try { readData(); } catch (IOException e) { e.printStackTrace(); } }).start(); } private static void readData() throws IOException { BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream(FILE_NAME), "utf-8")); String line; long start = System.currentTimeMillis(); int count = 1; while ((line = br.readLine()) != null) { // 按行读取，并向map里写入数据 SplitData.splitLine(line); if (count % 100 == 0) { System.out.println("读取100行,总耗时间: " + (System.currentTimeMillis() - start) / 1000 + " s"); try { Thread.sleep(1000L); } catch (InterruptedException e) { e.printStackTrace(); } } count++; } findMostAge(); br.close(); } private static void findMostAge() { Integer targetValue = 0; String targetKey = null; Iterator<Map.Entry<String, AtomicInteger>> entrySetIterator = countMap.entrySet().iterator(); while (entrySetIterator.hasNext()) { Map.Entry<String, AtomicInteger> entry = entrySetIterator.next(); Integer value = entry.getValue().get(); String key = entry.getKey(); if (value > targetValue) { targetValue = value; targetKey = key; } } System.out.println("数量最多的年龄为:" + targetKey + "数量为：" + targetValue); } private static void clearTask() { // 清理，同时找出出现字符最大的数 findMostAge(); System.exit(-1); }}测试结果
总共花了3分钟读取完并统计完所有数据:
内存消耗为2G-2.5G, CPU利用率太低，只向上浮动了20%-25%之间:
要想提高CPU的利用率，那么可以使用多线程去处理。
下面我们使用多线程去解决这个CPU利用率低的问题
思路二分治法
使用多线程去消费读取到的数据。 采用生产者、消费者模式去消费数据，因为在读取的时候是比较快的，单线程的数据处理能力比较差，因此思路一的性能阻塞在取数据方，又是同步的，所以导致整个链路的性能会变的很差。
所谓分治法就是分而治之，也就是说将海量数据分割处理。 根据CPU的能力初始化n个线程，每一个线程去消费一个队列，这样线程在消费的时候不会出现抢占队列的问题，同时为了保证线程安全和生产者消费者模式的完整，采用阻塞队列，Java中提供了LinkedBlockingQueue就是一个阻塞队列。
初始化阻塞队列
使用linkedList创建一个阻塞队列列表:
private static List<LinkedBlockingQueue<String>> blockQueueLists = new LinkedList<>();
在static块里初始化阻塞队列的数量和单个阻塞队列的容量为256, 上面讲到了30E数据大概2500行，按行塞到队列里，20个队列，那么每个队列125个，因此可以容量可以设计为256即可:
//每个队列容量为256 for (int i = 0; i < threadNums; i++) { blockQueueLists.add(new LinkedBlockingQueue<>(256)); }生产者
为了实现负载的功能, 首先定义一个count计数器，用来记录行数:
private static AtomicLong count = new AtomicLong(0);
按照行数来计算队列的下标: long index=count.get()%threadNums。 下面算法就实现了对队列列表中的队列进行轮询的投放:
static class SplitData { public static void splitLine(String lineData) {// System.out.println(lineData.length()); String[] arr = lineData.split("\n"); for (String str : arr) { if (StringUtils.isEmpty(str)) { continue; } long index = count.get() % threadNums; try { // 如果满了就阻塞 blockQueueLists.get((int) index).put(str); } catch (InterruptedException e) { e.printStackTrace(); } count.getAndIncrement(); } }消费者
队列线程私有化
消费方在启动线程的时候根据index去获取到指定的队列，这样就实现了队列的线程私有化。
private static void startConsumer() throws FileNotFoundException, UnsupportedEncodingException { //如果共用一个队列，那么线程不宜过多，容易出现抢占现象 System.out.println("开始消费..."); for (int i = 0; i < threadNums; i++) { final int index = i; // 每一个线程负责一个queue，这样不会出现线程抢占队列的情况。 new Thread(() -> { while (consumerRunning) { startConsumer = true; try { String str = blockQueueLists.get(index).take(); countNum(str); } catch (InterruptedException e) { e.printStackTrace(); } } }).start(); } }多子线程分割字符串
由于从队列中多到的字符串非常的庞大，如果又是用单线程调用split(",")去分割，那么性能同样会阻塞在这个地方。
// 按照arr的大小，运用多线程分割字符串 private static void countNum(String str) { int[] arr = new int[2]; arr[1] = str.length() / 3;// System.out.println("分割的字符串为start位置为:" + arr[0] + ",end位置为:" + arr[1]); for (int i = 0; i < 3; i++) { final String innerStr = SplitData.splitStr(str, arr);// System.out.println("分割的字符串为start位置为:" + arr[0] + ",end位置为:" + arr[1]); new Thread(() -> { String[] strArray = innerStr.split(","); for (String s : strArray) { countMap.computeIfAbsent(s, s1 -> new AtomicInteger(0)).getAndIncrement(); } }).start(); } }分割字符串算法
分割时从0开始，按照等分的原则，将字符串n等份，每一个线程分到一份。
用一个arr数组的arr[0] 记录每次的分割开始位置, arr[1] 记录每次分割的结束位置，如果遇到的开始的字符不为",", 那么就startIndex-1, 如果结束的位置不为",", 那么将endIndex向后移一位。
如果endIndex超过了字符串的最大长度，那么就把最后一个字符赋值给arr[1]。
/** * 按照 x坐标 来分割 字符串，如果切到的字符不为“，”， 那么把坐标向前或者向后移动一位。 * * @param line * @param arr 存放x1,x2坐标 * @return */ public static String splitStr(String line, int[] arr) { int startIndex = arr[0]; int endIndex = arr[1]; char start = line.charAt(startIndex); char end = line.charAt(endIndex); if ((startIndex == 0 || start == ',') && end == ',') { arr[0] = endIndex + 1; arr[1] = arr[0] + line.length() / 3; if (arr[1] >= line.length()) { arr[1] = line.length() - 1; } return line.substring(startIndex, endIndex); } if (startIndex != 0 && start != ',') { startIndex = startIndex - 1; } if (end != ',') { endIndex = endIndex + 1; } arr[0] = startIndex; arr[1] = endIndex; if (arr[1] >= line.length()) { arr[1] = line.length() - 1; } return splitStr(line, arr); }完整代码
package bigdata;import cn.hutool.core.collection.CollectionUtil;import org.apache.commons.lang3.StringUtils;import java.io.*;import java.util.*;import java.util.concurrent.ConcurrentHashMap;import java.util.concurrent.LinkedBlockingQueue;import java.util.concurrent.atomic.AtomicInteger;import java.util.concurrent.atomic.AtomicLong;import java.util.concurrent.locks.ReentrantLock;/** * @Desc: * @Author: bingbing * @Date: 2022/5/4 0004 19:19 * 多线程处理 */public class HandleMaxRepeatProblem { public static final int start = 18; public static final int end = 70; public static final String dir = "D:\\dataDir"; public static final String FILE_NAME = "D:\\ User.dat"; private static final int threadNums = 20; /** * key 为年龄， value为所有的行列表，使用队列 */ private static Map<Integer, Vector<String>> valueMap = new ConcurrentHashMap<>(); /** * 存放数据的队列 */ private static List<LinkedBlockingQueue<String>> blockQueueLists = new LinkedList<>(); /** * 统计数量 */ private static Map<String, AtomicInteger> countMap = new ConcurrentHashMap<>(); private static Map<Integer, ReentrantLock> lockMap = new ConcurrentHashMap<>(); // 队列负载均衡 private static AtomicLong count = new AtomicLong(0); /** * 开启消费的标志 */ private static volatile boolean startConsumer = false; /** * 消费者运行保证 */ private static volatile boolean consumerRunning = true; /** * 按照 "," 分割数据，并写入到文件里 */ static class SplitData { public static void splitLine(String lineData) {// System.out.println(lineData.length()); String[] arr = lineData.split("\n"); for (String str : arr) { if (StringUtils.isEmpty(str)) { continue; } long index = count.get() % threadNums; try { // 如果满了就阻塞 blockQueueLists.get((int) index).put(str); } catch (InterruptedException e) { e.printStackTrace(); } count.getAndIncrement(); } } /** * 按照 x坐标 来分割 字符串，如果切到的字符不为“，”， 那么把坐标向前或者向后移动一位。 * * @param line * @param arr 存放x1,x2坐标 * @return */ public static String splitStr(String line, int[] arr) { int startIndex = arr[0]; int endIndex = arr[1]; char start = line.charAt(startIndex); char end = line.charAt(endIndex); if ((startIndex == 0 || start == ',') && end == ',') { arr[0] = endIndex + 1; arr[1] = arr[0] + line.length() / 3; if (arr[1] >= line.length()) { arr[1] = line.length() - 1; } return line.substring(startIndex, endIndex); } if (startIndex != 0 && start != ',') { startIndex = startIndex - 1; } if (end != ',') { endIndex = endIndex + 1; } arr[0] = startIndex; arr[1] = endIndex; if (arr[1] >= line.length()) { arr[1] = line.length() - 1; } return splitStr(line, arr); } public static void splitLine0(String lineData) { String[] arr = lineData.split(","); for (String str : arr) { if (StringUtils.isEmpty(str)) { continue; } int keyIndex = Integer.parseInt(str); ReentrantLock lock = lockMap.computeIfAbsent(keyIndex, lockMap -> new ReentrantLock()); lock.lock(); try { valueMap.get(keyIndex).add(str); } finally { lock.unlock(); }// boolean wait = true;// for (; ; ) {// if (!lockMap.get(Integer.parseInt(str)).isLocked()) {// wait = false;// valueMap.computeIfAbsent(Integer.parseInt(str), integer -> new Vector<>()).add(str);// }// // 当前阻塞，直到释放锁// if (!wait) {// break;// }// } } } } /** * init map */ static { File file = new File(dir); if (!file.exists()) { file.mkdir(); } //每个队列容量为256 for (int i = 0; i < threadNums; i++) { blockQueueLists.add(new LinkedBlockingQueue<>(256)); } for (int i = start; i <= end; i++) { try { File subFile = new File(dir + "\\" + i + ".dat"); if (!file.exists()) { subFile.createNewFile(); } countMap.computeIfAbsent(i + "", integer -> new AtomicInteger(0));// lockMap.computeIfAbsent(i, lock -> new ReentrantLock()); } catch (FileNotFoundException e) { e.printStackTrace(); } catch (IOException e) { e.printStackTrace(); } } } public static void main(String[] args) { new Thread(() -> { try { // 读取数据 readData(); } catch (IOException e) { e.printStackTrace(); } }).start(); new Thread(() -> { try { // 开始消费 startConsumer(); } catch (FileNotFoundException e) { e.printStackTrace(); } catch (UnsupportedEncodingException e) { e.printStackTrace(); } }).start(); new Thread(() -> { // 监控 monitor(); }).start(); } /** * 每隔60s去检查栈是否为空 */ private static void monitor() { AtomicInteger emptyNum = new AtomicInteger(0); while (consumerRunning) { try { Thread.sleep(10 * 1000); } catch (InterruptedException e) { e.printStackTrace(); } if (startConsumer) { // 如果所有栈的大小都为0，那么终止进程 AtomicInteger emptyCount = new AtomicInteger(0); for (int i = 0; i < threadNums; i++) { if (blockQueueLists.get(i).size() == 0) { emptyCount.getAndIncrement(); } } if (emptyCount.get() == threadNums) { emptyNum.getAndIncrement(); // 如果连续检查指定次数都为空，那么就停止消费 if (emptyNum.get() > 12) { consumerRunning = false; System.out.println("消费结束..."); try { clearTask(); } catch (Exception e) { System.out.println(e.getCause()); } finally { System.exit(-1); } } } } } } private static void readData() throws IOException { BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream(FILE_NAME), "utf-8")); String line; long start = System.currentTimeMillis(); int count = 1; while ((line = br.readLine()) != null) { // 按行读取，并向队列写入数据 SplitData.splitLine(line); if (count % 100 == 0) { System.out.println("读取100行,总耗时间: " + (System.currentTimeMillis() - start) / 1000 + " s"); try { Thread.sleep(1000L); System.gc(); } catch (InterruptedException e) { e.printStackTrace(); } } count++; } br.close(); } private static void clearTask() { // 清理，同时找出出现字符最大的数 Integer targetValue = 0; String targetKey = null; Iterator<Map.Entry<String, AtomicInteger>> entrySetIterator = countMap.entrySet().iterator(); while (entrySetIterator.hasNext()) { Map.Entry<String, AtomicInteger> entry = entrySetIterator.next(); Integer value = entry.getValue().get(); String key = entry.getKey(); if (value > targetValue) { targetValue = value; targetKey = key; } } System.out.println("数量最多的年龄为:" + targetKey + "数量为：" + targetValue); System.exit(-1); } /** * 使用linkedBlockQueue * * @throws FileNotFoundException * @throws UnsupportedEncodingException */ private static void startConsumer() throws FileNotFoundException, UnsupportedEncodingException { //如果共用一个队列，那么线程不宜过多，容易出现抢占现象 System.out.println("开始消费..."); for (int i = 0; i < threadNums; i++) { final int index = i; // 每一个线程负责一个queue，这样不会出现线程抢占队列的情况。 new Thread(() -> { while (consumerRunning) { startConsumer = true; try { String str = blockQueueLists.get(index).take(); countNum(str); } catch (InterruptedException e) { e.printStackTrace(); } } }).start(); } } // 按照arr的大小，运用多线程分割字符串 private static void countNum(String str) { int[] arr = new int[2]; arr[1] = str.length() / 3;// System.out.println("分割的字符串为start位置为:" + arr[0] + ",end位置为:" + arr[1]); for (int i = 0; i < 3; i++) { final String innerStr = SplitData.splitStr(str, arr);// System.out.println("分割的字符串为start位置为:" + arr[0] + ",end位置为:" + arr[1]); new Thread(() -> { String[] strArray = innerStr.split(","); for (String s : strArray) { countMap.computeIfAbsent(s, s1 -> new AtomicInteger(0)).getAndIncrement(); } }).start(); } } /** * 后台线程去消费map里数据写入到各个文件里, 如果不消费，那么会将内存程爆 */ private static void startConsumer0() throws FileNotFoundException, UnsupportedEncodingException { for (int i = start; i <= end; i++) { final int index = i; BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(dir + "\\" + i + ".dat", false), "utf-8")); new Thread(() -> { int miss = 0; int countIndex = 0; while (true) { // 每隔100万打印一次 int count = countMap.get(index).get(); if (count > 1000000 * countIndex) { System.out.println(index + "岁年龄的个数为:" + countMap.get(index).get()); countIndex += 1; } if (miss > 1000) { // 终止线程 try { Thread.currentThread().interrupt(); bw.close(); } catch (IOException e) { } } if (Thread.currentThread().isInterrupted()) { break; } Vector<String> lines = valueMap.computeIfAbsent(index, vector -> new Vector<>()); // 写入到文件里 try { if (CollectionUtil.isEmpty(lines)) { miss++; Thread.sleep(1000); } else { // 100个一批 if (lines.size() < 1000) { Thread.sleep(1000); continue; } // 1000个的时候开始处理 ReentrantLock lock = lockMap.computeIfAbsent(index, lockIndex -> new ReentrantLock()); lock.lock(); try { Iterator<String> iterator = lines.iterator(); StringBuilder sb = new StringBuilder(); while (iterator.hasNext()) { sb.append(iterator.next()); countMap.get(index).addAndGet(1); } try { bw.write(sb.toString()); bw.flush(); } catch (IOException e) { e.printStackTrace(); } // 清除掉vector valueMap.put(index, new Vector<>()); } finally { lock.unlock(); } } } catch (InterruptedException e) { } } }).start(); } }}测试结果
内存和CPU初始占用大小:
启动后，运行时稳定在11.7，CPU稳定利用在90%以上。
总耗时由180S缩减到103S，效率提升75%,得到的结果也与单线程处理的一致!
遇到的问题
如果在运行了的时候，发现GC突然罢工了，开始不工作了，有可能是JVM的堆中存在的垃圾太多，没回收导致内存的突增。
解决方法: 在读取一定数量后，可以让主线程暂停几秒，手动调用GC。
提示: 本demo的线程创建都是手动创建的，实际开发中使用的是线程池 !~
版权声明：
本站文章均来自互联网搜集，如有侵犯您的权益，请联系我们删除，谢谢。
标签： #java处理视频
