多线程读取大数据文件

最新推荐文章于 2021-11-29 13:50:13 发布
最新推荐文章于 2021-11-29 13:50:13 发布
阅读量2.7k 收藏
点赞数
分类专栏： 设计模式 java 文章标签： 大数据 多线程 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lrq1988/article/details/17927911
版权

代码改错，已更新为：http://blog.csdn.net/lrq1988/article/details/17954715

工作之故，要读取一个几十万条的文本，就写了这个程序，倒腾了俩天，改来改去，并不一定是最终版，姑且先记录下来。

1、本地读取以后改为网络读取

2、timer是为了作定时刷新

3、容器启动时，首先加载MobileUtil.init()方法

4、多核服务器，加载会更快，根据服务器内核切割获取的内容来组装map

5、基于线程安全考虑，HashMap可能改为ConcurrentHashMap

6、之所以没用NIO，是因为文本行数的计算在JDK6不支持，另外实现的代价又高。貌似JDK7已提供相应API。

import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.HttpURLConnection;
import java.net.URL;
import java.net.URLConnection;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.zip.CRC32;

import org.apache.commons.codec.digest.DigestUtils;

//import org.apache.commons.codec.digest.DigestUtils;

public class MobileUtil {
	private static final ScheduledExecutorService timer = Executors
			.newScheduledThreadPool(Runtime.getRuntime().availableProcessors());
	private static final String fileName = "/Users/leefelix/Downloads/all.csv";
	private static long crc32;// 字符串进行crc32数据校验
	private static String content = null;// 获取的内容字符串
	public static HashMap<String, Location> locationMap = new HashMap<String, Location>();
	public static volatile boolean started = false;

	private MobileUtil() {
	}

	private void initial() {
		timer.scheduleWithFixedDelay(new Runnable() {
			public void run() {
				long start = System.nanoTime();
				try {
					//crc32校验
					System.out.println("md4....");
					if(crc32 == crc32(fileName)){
						System.out.println("md5....");
						return;
					}
					crc32 = crc32(fileName);
					
					FileInputStream fi = new FileInputStream(fileName);
					InputStreamReader inreader = new InputStreamReader(fi,
							"UTF-8");
					BufferedReader reader = new BufferedReader(inreader);
					String line = null;
					long start1 = System.nanoTime();
					StringBuilder sb = new StringBuilder();
					System.out.println(start1);
					int strCount = 0;
					while ((line = reader.readLine()) != null) {
						strCount++;
						sb.append(line + "\r\n");
					}
					System.out.println("end...");
					String tmp=sb.toString();
					System.out.println("tmp length:"+tmp.length());
//					System.out.println("content length:"+content.length());
					content = sb.toString();
					System.out.println("time1:" + (System.nanoTime() - start1));
					String contentCopy = content;
					int total = contentCopy.length();
					System.out.println(total);
					// 使用的线程数量
					int threadCounts = Runtime.getRuntime()
							.availableProcessors();
					ExecutorService exec = Executors
							.newFixedThreadPool(threadCounts);
					List<Callable<HashMap<String, Location>>> callList = new ArrayList<Callable<HashMap<String, Location>>>();
					int len = strCount / threadCounts;// 平均分割strCount
					// strCount小于线程数
					if (len == 0) {
						threadCounts = strCount;// 采用一个线程处理List中的一个元素
						len = strCount / threadCounts;// 重新平均分割List
					}
					for (int i = 0; i < threadCounts; i++) {
						// 根据线程数量切割字符串为线程数量个子字符串
						final String subContent;
						if (0 == threadCounts - 1) {
							subContent = contentCopy;
						} else {
							int startPos = i * total / threadCounts;
							int endPos = (i + 1) * total / threadCounts;
							if (i != 0)
								while (!contentCopy.substring(startPos - 2,
										startPos).endsWith("\r\n")) {
									startPos++;
								}
							if (i != threadCounts - 1)
								while (!contentCopy.substring(endPos - 2,
										endPos).endsWith("\r\n")) {
									endPos++;
								}
							subContent = contentCopy
									.substring(startPos, endPos);
						}
						callList.add(new Callable<HashMap<String, Location>>() {
							public HashMap<String, Location> call()
									throws Exception {
								String contentCopy = subContent;
								HashMap<String, Location> map = new HashMap<String, Location>();
								while (true) {
									String splitStr = null;
									int j = contentCopy.indexOf("\r\n");
									if (j < 0) {
										break;
									}
									splitStr = contentCopy.substring(0, j);
									Location lc = new Location();
									String[] arr = new String[4];
									arr[0] = splitStr.substring(0,
											splitStr.indexOf("\t")).trim();
									splitStr = splitStr.substring(splitStr
											.indexOf("\t") + 1);
									arr[1] = splitStr.substring(0,
											splitStr.indexOf("\t")).trim();
									splitStr = splitStr.substring(splitStr
											.indexOf("\t") + 1);
									arr[2] = splitStr.substring(0,
											splitStr.indexOf("\t")).trim();
									splitStr = splitStr.substring(splitStr
											.indexOf("\t") + 1);
									arr[3] = splitStr.trim();
									lc.setNum(arr[0]);
									lc.setProvince(arr[1]);
									lc.setCity(arr[2]);
									lc.setOperator(arr[3]);
									map.put(arr[0], lc);
									System.out.println(arr[1]);
									contentCopy = contentCopy.substring(j + 1);
								}
								return map;
							}
						});

						List<Future<HashMap<String, Location>>> futureList = exec
								.invokeAll(callList);
						HashMap<String, Location> result = new HashMap<String, Location>();
						for (Future<HashMap<String, Location>> future : futureList) {
							result.putAll(future.get());
						}
						locationMap = result;
						System.out.println("locationMap:"+result.size());
						started = true;
						System.out.println(true);
						System.out.println(System.nanoTime() - start);
						exec.shutdown();
					}
				} catch (FileNotFoundException e) {
					e.printStackTrace();
					System.out.println("找不到文件" + fileName + "...");
				} catch (IOException e) {
					e.printStackTrace();
					System.out.println("与文件" + fileName + "通信异常...");

				} catch (InterruptedException e) {
					e.printStackTrace();
				} catch (ExecutionException e) {
					e.printStackTrace();
				}
			}
		}, 0, 1, TimeUnit.MINUTES);
	}

	public static void init() {
		final MobileUtil mobileUtil = new MobileUtil();
		mobileUtil.initial();
	}
	public static MobileUtil create(){
		final MobileUtil mobileUtil = new MobileUtil();
		while(!started){
			if(started)break;
		}
		return mobileUtil;
	}

	// static {
	// long start = System.nanoTime();
	// // FileInputStream fis;
	// // FileChannel fc;
	// // ByteBuffer bf;
	// try {
	// if (content != null && md5Data.equals(DigestUtils.md5Hex(content))) {
	//
	// } else {
	// // fis = new FileInputStream(fileName);
	// // // 创建UTF-8/GBK符集
	// // Charset charset = Charset.forName("GBK");
	// // // 得到文件通道
	// // fc = fis.getChannel();
	// // // 分配与文件尺寸等大的缓冲区
	// // bf = ByteBuffer.allocate((int) fc.size());
	// // // 整个文件内容全读入缓冲区，即是内存映射文件
	// // fc.read(bf);
	// // // 把缓冲中当前位置回复为零
	// // bf.rewind();
	// // // 输出缓冲区中的内容
	// // content = charset.decode(bf).toString();
	// // fc.close();
	// // int strCount = 0;
	// // while (true) {
	// // int j = contentCopy.indexOf("\r\n");
	// // if (j < 0) {
	// // break;
	// // }
	// // strCount++;
	// // contentCopy = contentCopy.substring(j + 1);
	// // }
	// //之所以使用BufferedReader而不使用NIO，是为了方便计算行数
	// int strCount = 0;
	// FileInputStream fi = new FileInputStream(fileName);
	// InputStreamReader inreader = new InputStreamReader(fi, "GBK");
	// BufferedReader reader = new BufferedReader(inreader);
	// String line = null;
	// long start1 = System.nanoTime();
	// StringBuilder sb = new StringBuilder();
	// while ((line = reader.readLine()) != null) {
	// strCount++;
	// sb.append(line+"\r\n");
	// }
	// content=sb.toString();
	// System.out.println("time1:"+(System.nanoTime()-start1));
	// // long start2 = System.nanoTime();
	// // String ss=null;
	// // while ((line = reader.readLine()) != null) {
	// // strCount++;
	// // ss+=line+"\r\n";
	// // }
	// // content=ss;
	// // System.out.println("time2:"+(System.nanoTime()-start2));
	// md5Data = DigestUtils.md5Hex(content);
	// String contentCopy = content;
	// int total = contentCopy.length();
	// // 使用的线程数量
	// int threadCounts = Runtime.getRuntime().availableProcessors();
	// ExecutorService exec = Executors
	// .newFixedThreadPool(threadCounts);
	// List<Callable<HashMap<String, Location>>> callList = new
	// ArrayList<Callable<HashMap<String, Location>>>();
	// int len = strCount / threadCounts;// 平均分割strCount
	// // strCount小于线程数
	// if (len == 0) {
	// threadCounts = strCount;// 采用一个线程处理List中的一个元素
	// len = strCount / threadCounts;// 重新平均分割List
	// }
	// for (int i = 0; i < threadCounts; i++) {
	// //根据线程数量切割字符串为线程数量个子字符串
	// final String subContent;
	// if(0 == threadCounts -1){
	// subContent = contentCopy;
	// }else{
	// int startPos = i*total/threadCounts;
	// int endPos = (i+1)*total/threadCounts;
	// if(i!=0)
	// while(!contentCopy.substring(startPos-2,startPos).endsWith("\r\n")){
	// startPos++;
	// }
	// if(i!=threadCounts -1)
	// while(!contentCopy.substring(endPos-2,endPos).endsWith("\r\n")){
	// endPos++;
	// }
	// subContent = contentCopy.substring(startPos,endPos);
	// }
	// callList.add(new Callable<HashMap<String, Location>>() {
	// public HashMap<String, Location> call()
	// throws Exception {
	// String contentCopy = subContent;
	// HashMap<String, Location> map = new HashMap<String, Location>();
	// while (true) {
	// String splitStr = null;
	// int j = contentCopy.indexOf("\r\n");
	// if (j < 0) {
	// break;
	// }
	// splitStr = contentCopy.substring(0, j);
	// Location lc = new Location();
	// String[] arr = new String[4];
	// arr[0] = splitStr.substring(0,
	// splitStr.indexOf("\t")).trim();
	// splitStr = splitStr.substring(splitStr
	// .indexOf("\t") + 1);
	// arr[1] = splitStr.substring(0,
	// splitStr.indexOf("\t")).trim();
	// splitStr = splitStr.substring(splitStr
	// .indexOf("\t") + 1);
	// arr[2] = splitStr.substring(0,
	// splitStr.indexOf("\t")).trim();
	// splitStr = splitStr.substring(splitStr
	// .indexOf("\t") + 1);
	// arr[3] = splitStr.trim();
	// lc.setNum(arr[0]);
	// lc.setProvince(arr[1]);
	// lc.setCity(arr[2]);
	// lc.setOperator(arr[3]);
	// map.put(arr[0], lc);
	// contentCopy = contentCopy.substring(j + 1);
	// }
	// return map;
	// }
	// });
	// }
	//
	// List<Future<HashMap<String, Location>>> futureList = exec
	// .invokeAll(callList);
	// HashMap<String, Location> result = new HashMap<String, Location>();
	// for (Future<HashMap<String, Location>> future : futureList) {
	// result.putAll(future.get());
	// }
	// md5Data = DigestUtils.md5Hex(content);
	// locationMap=result;
	// System.out.println(System.nanoTime() - start);
	// exec.shutdown();
	// }
	// } catch (FileNotFoundException e) {
	// e.printStackTrace();
	// System.out.println("找不到文件" + fileName + "...");
	// } catch (IOException e) {
	// e.printStackTrace();
	// System.out.println("与文件" + fileName + "通信异常...");
	//
	// } catch (InterruptedException e) {
	// e.printStackTrace();
	// } catch (ExecutionException e) {
	// e.printStackTrace();
	// }
	// }
	public static void main(String args[]) throws IOException {
		System.out.println(getCity("13811014978"));
		System.out.println(getOperator("13811014978"));
	}

	static class Location {

		private String num;
		private String province;
		private String city;
		private String operator;

		public Location() {
		}

		public String getNum() {
			return num;
		}

		public void setNum(String num) {
			this.num = num;
		}

		public String getProvince() {
			return province;
		}

		public void setProvince(String province) {
			this.province = province;
		}

		public String getCity() {
			return city;
		}

		public void setCity(String city) {
			this.city = city;
		}

		public String getOperator() {
			return operator;
		}

		public void setOperator(String operator) {
			this.operator = operator;
		}
	}

	public static Location getLocation(String mobile) {
		mobile = getNum7(mobile);
		while(!started){
			if(started)break;
		}
		return locationMap.get(mobile);
	}

	public static String getCity(String mobile) {
		while(!started){
			if(started)break;
		}
		mobile = getNum7(mobile);
		System.out.println("mobile:"+mobile);
		if (locationMap.get(mobile) == null)
			return null;
		return locationMap.get(mobile).getCity();
	}

	public static String getProvince(String mobile) {
		mobile = getNum7(mobile);
		while(!started){
			if(started)break;
		}
		if (locationMap.get(mobile) == null)
			return null;
		return locationMap.get(mobile).getProvince();
	}

	public static String getOperator(String mobile) {
		mobile = getNum7(mobile);
		while(!started){
			if(started)break;
		}
		if (locationMap.get(mobile) == null)
			return null;
		return locationMap.get(mobile).getOperator();
	}

	private static String getNum7(String mobile) {
		mobile = mobile.trim();
		if (mobile.length() != 11 || !mobile.startsWith("1")
				|| !mobile.matches("\\d+"))
			throw new IllegalArgumentException("传入的手机号码" + mobile
					+ "不正确，请使用正确的11位数字号码");
		return mobile.substring(0, 7);
	}

	private static String getContentByUri(String uri) {
		URL url;
		URLConnection urlconn;
		try {
			url = new URL(uri);
			urlconn = url.openConnection();
			HttpURLConnection httpConnection = (HttpURLConnection) urlconn;
			httpConnection.setConnectTimeout(1000000);
			httpConnection.setReadTimeout(1000000);
			httpConnection.setRequestProperty("User-Agent", "new");
			httpConnection.setRequestMethod("POST");
			InputStream in = httpConnection.getInputStream();
			BufferedReader br = new BufferedReader(new InputStreamReader(in,
					"UTF-8"));

			String line = "";
			while ((line = br.readLine()) != null) {
				System.out.println(line);
			}
			br.close();
			in.close();
			return line;
		} catch (IOException e) {
			e.printStackTrace();
			return null;
		}
	}

	private static int getNumber(String des, String reg) {
		Pattern p = Pattern.compile(reg);
		Matcher m = p.matcher(des);
		int count = 0;// 记录个数
		while (m.find()) {
			count++;
		}
		return count;
	}

	public static String getUrlContent(String url) {
		// CloseableHttpClient httpclient = HttpClients.createDefault();
		// HttpGet httpget = new HttpGet(url);
		// CloseableHttpResponse response = null;
		String value = null;
		// try {
		// response = httpclient.execute(httpget);
		// HttpEntity entity = response.getEntity();
		// if (entity != null) {
		// value=EntityUtils.toString(entity);
		// }
		// } catch (Exception e) {
		// e.printStackTrace();
		// } finally {
		// try {
		// response.close();
		// httpclient.close();
		// } catch (IOException e) {
		// e.printStackTrace();
		// }
		// }
		return value;
	}
	
	private static long crc32(String str){
		CRC32 crc32 = new CRC32();
		byte[] data = str.getBytes();
		for(byte i=0;i<data.length;i++) {
		    data[i] = i;
		}
		crc32.update(data);
		return crc32.getValue();
	}
}


lrq1988
关注
专栏目录
多线程读取大文件
04-26
NULL 博文链接：https://wpf-0604.iteye.com/blog/2348093
JAVA多线程读写文件范例
weixin_34380781的博客
07-28 422
   在写之前先声明，本文是基于之前在博客园网站上检索到的一份JAVA多线程读写文件的示例，我在写自己的程序时是在那位作者写的基础上做了改良，但已不记得原文的地址。如果有知情者，烦请帖出地址，我在此文上加入引用或转载。     本程序是基于这么一种考虑，某系统后台有个将近2G大小的日志文件，你用任何编辑器去打开它，都将会很困难。针对这样的大文件解析处理，解决方案是使用多个线程，分割读取指定的大文件...
java多线程有序读取同一个文件
08-25
Java多线程有序读取同一个文件的实现 Java多线程有序读取同一个文件是指在多个线程中读取同一个文件的内容，并且保证读取的顺序。这种技术在实际应用中非常有用，例如在大数据处理、分布式系统、云计算等领域都有...
poi多线程大数据导出excel文件.zip
08-14
本项目“poi多线程大数据导出excel文件”提供了一个解决方案，利用多线程来提高Excel的大数据导出效率。 Apache POI 3.1版本是较早的版本，而项目中使用了更新的4.1版本，这意味着它可能利用了更多优化和新特性。在...
java对大数据量文件内容的多线程读取和排序.zip_大数据 java_文件读取
最新发布
09-24
本文将详细介绍如何在Java中实现对大数据量文件内容的多线程读取和排序。 首先，理解多线程的概念是至关重要的。线程是程序执行的最小单元，每个线程都有自己的程序计数器、虚拟机栈、本地方法栈和一部分堆内存。...
易语言多线程读取大文本文件源码
06-03
综上所述，易语言的多线程读取大文本文件源码是一个实用的示例，它展示了如何利用多线程并行处理大数据，以提高程序的运行效率。通过学习和理解这个源码，开发者可以更好地掌握易语言中的多线程编程技术，并将其应用...
Java多线程实现快速切分文件的程序
09-02
本文将深入探讨如何使用Java多线程来快速切分大文件，以解决大数据导入时遇到的性能问题。 首先，我们来看标题中的核心概念——"Java多线程实现快速切分文件的程序"。这表明我们将使用Java的多线程特性来并行处理...
Java多线程读取大文件
12-22
前言 　　是五一假期第，按理应该是快乐玩耍的日子，但是作为一个北漂到京师的开发人员，实在难想出去那玩耍。好玩的地方比较远，近处又感觉没意思。于是乎，闲着写篇文章，总结下昨天写的程序吧。 　　昨天下午朋友跟我聊起，他说有个需求，需要把上G的txt文件读取写入到数据库。用普通的io结果自然是OOM了，所以果断用NIO技术。为了提高速度，自然还得用上多线程技术。 　　接下来介绍一下实现思路以及相关的知识点。 　　内容 　　一、对文件分区 　　为了充分利用多线程读取，需要把文件划分成多个区域，供每个线程读取。那么需要有一个算法来计算出每个线程读取的开始位置和结束位置。那么首先根据配置的线程
java使用多线程读取超大文件
08-25
主要为大家详细介绍了java使用多线程读取超大文件，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
基于java线程池读取单个SQL数据库表
08-25
主要为大家详细介绍了基于java线程池读取单个SQL数据库表，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
大数据数据提取（文件读写，不读内存）
11-09
用于大数据数据提取，将文件中的数据提取至另一文件，中间不读取至内存，以满足大数据处理需要，本代码用于负荷曲线大数据提取。
读取大数据量的excel文件
04-26
本案例采用的poi读取大数据的excel文件 usermodel模式对excel操作前需要将文件全部转入内存，对较大文件来说内存开销很大。但是其使用简单。 eventusermodel模式采用事件模型，对文件边读取边处理，内存消耗较低，效率高，因为不用等待文件全部装入内存。但使用较复杂。 对12万条数据，7M大小的文件也能正常运行。无需设置vm的内存空间
java多线程读取大文件（日后还会复盘）
justleavel的博客
11-29 2932
首先讲解一下Java RandomAccessFile用法： 动态读取文件内容：所谓动态读取是指从文件的任意位置开始访问文件，而不是必须从文件开始位置读取到文件末尾。动态读取需要用到 Java 中的 RandomAccessFile 类。 RandomAccessFile 是 Java 输入/输出流体系中功能最丰富的文件内容访问类，它提供了众多的方法来访问文件内容，它既可以读取文件内容，也可以向文件输出数据。由于 RandomAccessFile 可以从任意位置访问文件，所以在只需要访问文件部分内容的情
多线程 + java nio 实现按行读取并处理超大文件
热门推荐
qq_25473933的博客
03-18 1万+
之前通过 java nio 实现了按行读写文件的方法，但由于是单线程读写，所以当读取数据量比较大的文件时性能肯定会是个大问题，所以为了解决读取处理大文件时性能上的问题，就在原来按行读取文件的基础上增加了多线程的实现，并使用线程来进行线程调度，思路和其它相关博客都一样，只是在代码实现的方式上有所区别，整体思路就是根据初始化线程数量来将文件进行分段读取，一个线程读取一个片段的内容，然后将读取到的行数据...
Java多线程读取与排序大数据文件策略
"java对大数据量文件内容的多线程读取和排序" 在处理大数据量文件时，Java 提供了多种方法来实现高效的数据读取和排序。在本例中，我们面临的问题是读取一个包含至少1亿行且每行超过100个字符的文本文件，并对其...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值