1.今天对三千万数据进行pv,uv处理,突然有意思的建立了uuid作为主键,应用六个线程去处理六个文件,测试结果发现
(1)有uuid批量插入,每一万个数据提交一次[数据量达到十万时发生内存溢出],
前六分钟跑的速度还行,插入了250w数据,后面的插入数据慢慢走。让我无法忍受,直接关了。
(2)对puv汇总的时候select url,sum(nums) from puv group by url,发现也是慢的可以用时2.2分钟。
下面是测试结果:
320w 31 2.2分钟
270w 12
254w 8
250w 6
-------------------
去掉uuid后,发现批量插入的数据很平衡,cpu一直处于平衡状态。
(1)对puv汇总的时候select url,sum(nums) from puv group by url,发现也是慢的可以用时92秒
下面是运行时候的统计:
32811948 38 92秒
3090w 36
2761w 32
2568w 29
2056w 24
1787w 21
1123w 13
1029w 12
913w 11
823w 10
708w 8
604w 7
470w 6
330w 4
130w 2
总结:发现当数据量达到两百万左右时,用uuid反而降低了批量插入和查询的性能。
-----------------------------------
当我用hadoop去处理这批数据时,我发现才花了3.6分钟。此时,我猜想spark处理时间应该是1.5分钟左右。
代码清单:
package com.sho9wbox.utils;
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.UUID;
import java.util.concurrent.ConcurrentHashMap;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import com.recommend.JDBIBase;
public class AppRank {
private static long totalTimes = 0l;
private static Date beginTime1 = null;
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
beginTime1 = new Date();
Thread t1 = new Thread(new Runnable() {
@Override
public void run() {
new AppRank().dealData("1");
}
});
t1.start();
System.out.println("t1 begin...........");
// TODO Auto-generated method stub
Thread t2 = new Thread(new Runnable() {
@Override
public void run() {
new AppRank().dealData("2");
}
});
t2.start();
System.out.println("t2 begin...........");
Thread t3 = new Thread(new Runnable() {
@Override
public void run() {
new AppRank().dealData("3");
}
});
t3.start();
System.out.println("t3 begin...........");
Thread t4 = new Thread(new Runnable() {
@Override
public void run() {
new AppRank().dealData("4");
}
});
t4.start();
System.out.println("t4 begin...........");
Thread t5 = new Thread(new Runnable() {
@Override
public void run() {
new AppRank().dealData("5");
}
});
t5.start();
System.out.println("t5 begin...........");
Thread t6 = new Thread(new Runnable() {
@Override
public void run() { new AppRank().dealData("6");
}
});
t6.start();
System.out.println("t6 begin...........");
}
private static String comile = "(.)\\w+(.)com(.)cn|(.)\\w+(\\.)com|(.)\\w+(.)cn";
//http://\\d+.\\d+.\\d+.\\d+:\\d+/
private static String compile1 = "(?<=http://)(\\w+[\\.|/])+\\w+:\\d+/";
private static Pattern pattern = Pattern.compile(comile);
private static Pattern pattern1 = Pattern.compile(compile1);
public void dealData(String s) {
long beginTime = System.currentTimeMillis();
List<Map<String,Object>> list = new ArrayList<>();
String path = "E://"+s+".txt";
FileReader file = null;
try {
file = new FileReader(path);
BufferedReader buffer = new BufferedReader(file);
String str = new String();
StringBuilder sb = new StringBuilder();
sb.append("insert into cs1(url,nums) values");
while ((str = buffer.readLine()) != null) {
System.out.println(s+"------"+new Date()+" "+beginTime1);
Map<String, Object> map = new AppRank().getData(str);
list.add(map);
if(list.size()%10000==0){
for(Map<String, Object> mapc:list){
for(Entry<String, Object> entry:mapc.entrySet()){
String key = entry.getKey().replace("\n", "").trim();
String val = entry.getValue().toString().replace("\n", "").trim();
int values = Integer.parseInt(val);
//sb.append("('"+UUID.randomUUID()+"','"+key+"',"+values+"),");
sb.append("('"+key+"',"+values+"),");
}
}
String s1 = sb.toString();
s1 = s1.substring(0, s1.lastIndexOf(","));
JDBIBase.execute(s1);
list.clear();
sb.delete(0, sb.length());
sb.append("insert into cs1(url,nums) values");
}
}
if(list.size()<=10000){
for(Map<String, Object> mapc:list){
for(Entry<String, Object> entry:mapc.entrySet()){
String key = entry.getKey().replace("\n", "").trim();
String val = entry.getValue().toString().replace("\n", "").trim();
int values = Integer.parseInt(val);
//sb.append("('"+UUID.randomUUID()+"','"+key+"',"+values+"),");
sb.append("('"+key+"',"+values+"),");
}
}
String s1 = sb.toString();
s1 = s1.substring(0, s1.lastIndexOf(","));
JDBIBase.execute(s1);
list.clear();
sb.delete(0, sb.length());
sb.append("insert into cs1(url,nums) values");
//Thread.sleep(2000);
}
long end = System.currentTimeMillis();
totalTimes+=end-beginTime;
System.out.println("文件耗时 "+totalTimes/1000+" 秒");
} catch (Exception e) {
e.printStackTrace();
System.out.println("发生异常......");
}
finally{
try {
file.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
/**
* @param s
* @return
* @throws Exception
*/
public Map<String, Object> getData(String s) throws Exception{
Map<String, Object> map = new ConcurrentHashMap<String,Object>();
String arr[] = s.split(" ");
Matcher m = pattern.matcher(arr[0]);
String rs = null;
if(m.find()) {
rs = m.group().replace("/", ".");
rs= "http://www"+rs;
}
else
{
Matcher m1 = pattern1.matcher(arr[0]);
while(m1.find()){
rs = m1.group();
}
if(null==rs)
rs = arr[0];
}
//System.out.println(rs +" "+entry.getValue().toString());
if(rs.indexOf("localhost")<=0||rs.indexOf("127.0.0.1")<=0) {
rs.replace("/", ".");
map.put(rs, arr[1]);
}
return map;
}
}
hadoop处理代码:
package com;
import java.io.IOException;
import java.net.URI;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import org.apache.hadoop.mapreduce.Counter;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.conf.Configured;
import org.apache.hadoop.fs.FileSystem;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.LongWritable;
import org.apache.hadoop.io.NullWritable;
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 org.apache.hadoop.util.Tool;
import org.apache.hadoop.util.ToolRunner;
public class RankAppSort extends Configured implements Tool{
static String INPUT_PATH = "hdfs://192.168.1.230:9000/input";
static String OUT_PATH = "hdfs://192.168.1.230:9000/output/";
@Override
public int run(String[] arg0) throws Exception {
/*INPUT_PATH = arg0[0];
OUT_PATH = arg0[1];
*/
long beginTime = System.currentTimeMillis();
System.out.println(System.currentTimeMillis());
Configuration conf = new Configuration();
final FileSystem fileSystem = FileSystem.get(new URI(INPUT_PATH), conf);
final Path outPath = new Path(OUT_PATH);
if(fileSystem.exists(outPath)){
fileSystem.delete(outPath, true);
}
final Job job = new Job(conf , RankAppSort.class.getSimpleName());
job.setJarByClass(RankAppSort.class);
FileInputFormat.setInputPaths(job, INPUT_PATH);
//1.2 指定自定义的map类
job.setMapperClass(MyMapper.class);
//map输出的<k,v>类型。如果<k3,v3>的类型与<k2,v2>类型一致,则可以省略
job.setMapOutputKeyClass(Text.class);
job.setMapOutputValueClass(LongWritable.class);
//1.3 分区
//job.setPartitionerClass(HashPartitioner.class);
job.setReducerClass(MyReducer.class);
job.setOutputKeyClass(Text.class);
job.setOutputValueClass(LongWritable.class);
//2.3 指定写出到哪里
FileOutputFormat.setOutputPath(job, outPath);
//指定输出文件的格式化类
//job.setOutputFormatClass(TextOutputFormat.class);
//把job提交给JobTracker运行
job.waitForCompletion(true);
long end = System.currentTimeMillis();
System.out.println((end-beginTime)/1000+"秒");
return 0;
//1429522143046
//
}
private static String comile = "(.)\\w+(.)com(.)cn|(.)\\w+(\\.)com|(.)\\w+(.)cn";
//http://\\d+.\\d+.\\d+.\\d+:\\d+/
private static String compile1 = "(?<=http://)(\\w+[\\.|/])+\\w+:\\d+/";
private static Pattern pattern = Pattern.compile(comile);
private static Pattern pattern1 = Pattern.compile(compile1);
public static void main(String[] args) throws Exception {
ToolRunner.run(new RankAppSort(), args);
}
static class MyMapper extends Mapper<LongWritable, Text, Text, LongWritable>{
protected void map(LongWritable k1, Text v1, Context context) throws java.io.IOException ,InterruptedException {
final String[] arr = v1.toString().split(" ");
Matcher m = null;
if(null!=arr[0]&&!"".equals(arr[0]))
m = pattern.matcher(arr[0]);
String rs = null;
if(m.find()) {
rs = m.group().replace("/", ".");
rs= "http://www"+rs;
}
else
{
Matcher m1 = pattern1.matcher(arr[0]);
while(m1.find()){
rs = m1.group();
}
if(null==rs)
rs = arr[0];
}
//System.out.println(rs +" "+entry.getValue().toString());
if(rs.indexOf("localhost")>-1||rs.indexOf("127.0.0.1")>-1){
//Log.info("排除localhost");
}else{
rs.replace("/", ".");
context.write(new Text(rs), new LongWritable(Long.parseLong(arr[1])));
}
}
}
static class MyReducer extends Reducer<Text, LongWritable, Text, LongWritable>{
protected void reduce(Text k2,Iterable<LongWritable> v2s, Context ctx) throws java.io.IOException ,InterruptedException {
int times = 0;
for (LongWritable count : v2s) {
times += count.get();
}
IntPair ip = new IntPair(k2.toString(), times);
ctx.write(new Text(ip.getKey()), new LongWritable(ip.getVal()));
}
@Override
protected void cleanup(
Context context)
throws IOException, InterruptedException {
// TODO Auto-generated method stub
//super.cleanup(context);
}
}
}
spark的代码清单后续有时间贴上。
分享到:
相关推荐
标题“uuid.rar_C获得UUID_UUID C_c生成uuid_c语言生成uuid_uuid”表明这是一个关于使用C语言实现UUID生成的资源包。这个压缩包可能包含了一个C语言编写的程序或库,可以用来在Windows平台上(通过VC6编译器)生成...
java 获取 UUID 与 UUID 校验详解 Java 获取 UUID 是一个非常常见的操作,UUID(Universally Unique Identifier,全球唯一标识符)是一种软件建筑中用于标识信息的标识符。UUID 的主要用途是为了在分布式系统中生成...
标题中的"PB生成UUID"指的是在编程中使用Protocol Buffers(简称PB)生成Universally Unique Identifier(UUID)。UUID是一个128位的数字,通常表示为32个十六进制数字,用于唯一标识网络中的对象。它在分布式系统、...
【ThinkPad System UUID1.82】是一款专为联想ThinkPad笔记本电脑设计的系统UUID添加工具,主要用于在制作U盘启动盘时解决特定问题。UUID(Universally Unique Identifier)是全球唯一的标识符,用于区分不同的计算机...
UUID,全称Universally Unique Identifier,是用于唯一标识信息的128位数字。在Java中,UUID提供了标准的方法来生成全局唯一的标识符。UUID主要由三部分组成:时间戳、随机数和节点ID,这确保了其在全球范围内的唯一...
UUID,全称Universally Unique Identifier,是全局唯一标识符的缩写,是一种软件构造标准,用于在分布式系统中唯一标识信息。UUID的主要目的是解决网络系统中的唯一性问题,确保在网络中的任何地方都不会出现重复的...
### JavaScript生成UUID的三种方法详解 #### 一、前言 在软件开发中,经常会遇到需要为特定的数据或对象分配唯一标识符的情况。UUID(通用唯一标识符)就是一种常用的解决方案,它能够确保生成的ID在空间和时间上...
《JavaScript中的UUID生成:深入理解Math.uuid.js》 在JavaScript编程中,UUID(Universally Unique Identifier)是一种广泛应用的全局唯一标识符,它主要用于创建对象的唯一ID,尤其是在分布式环境中。Math.uuid....
可能包含了如`uuid_generate()`用于生成新的UUID,`uuid_parse()`解析字符串形式的UUID,以及`uuid_compare()`比较两个UUID是否相同等函数。这些函数的实现通常基于RFC 4122,这是一个定义UUID生成和格式的标准。 ...
16bit UUID一览表 16位UUID是一种通用唯一标识符,用于标识蓝牙设备中的服务、特征和特征描述符。它是一个16位的二进制数字,通常用十六进制表示法表示。16位UUID是一种广泛使用的标识符,在蓝牙技术中扮演着重要...
UUID(Universally Unique Identifier)是用于唯一标识信息的一种标准格式,通常由32个十六进制数字组成,分为五组,用短横线分隔。在JavaScript中,生成UUID的需求时常出现,例如在生成临时ID、数据库记录的主键...
在IT领域,尤其是在Web开发中,唯一标识符(UUID)是一种极为重要的技术,它用于确保在分布式网络环境中数据对象的唯一性。JavaScript作为一种广泛应用于Web前端与后端开发的脚本语言,提供了多种方法来生成UUID,...
标题"通过NDK获得UUID"和描述涉及到利用Native Development Kit (NDK) 在Android系统底层获取UUID,以及通过Java层获取Android的唯一标识码。NDK允许开发者用C/C++编写部分应用,从而提高性能,特别是对于计算密集型...
UUID,全称Universally Unique Identifier,是用于唯一标识网络中的对象的一种标识符。在数据库系统中,UUID常常被用来创建全局唯一的序列号,避免不同系统间的冲突。在PostgreSQL数据库中,uuid-ossp扩展提供了生成...
UUID(Universally Unique Identifier)在蓝牙通信中扮演着关键角色,它是一种全球唯一的标识符,用于区分不同的蓝牙服务。本教程将深入探讨如何在Android设备之间利用UUID进行蓝牙通信。 首先,我们要了解Android...
在Java编程中,UUID(Universally Unique Identifier)是一种标准的128位的唯一标识符,通常用于生成不可预测的全局唯一ID。然而,标准的UUID由32个16进制数字组成,形式上类似于“123e4567-e89b-12d3-a456-...
UUID,全称Universally Unique Identifier,是一种为分布式系统生成全局唯一标识符的机制。在Java中,虽然标准库提供有`java.util.UUID`类来生成和处理UUID,但其性能并非最优,特别是在大规模生成和解析时。为了...
在这种背景下,使用UUID作为IMEI的替代方案变得越来越常见。本文将深入探讨如何在Android中生成UUID以及其作为唯一标识符的优势。 UUID(Universally Unique Identifier)是一种全球唯一的标识符,它是由128位数字...
在IT行业中,UUID(Universally Unique Identifier)是一种用于标识信息的标准,它确保了全局的唯一性,不依赖网络连接或中央注册机构。在PHP中,生成UUID常常用于创建唯一的记录标识,比如数据库中的主键或者分布式...
UUID,全称Universally Unique Identifier,是用于唯一标识信息的128位数字。在IT领域,UUID扮演着至关重要的角色,特别是在分布式系统和数据库设计中。UUID生成器是用来创建这些独特标识的工具,它确保生成的每个ID...