「java大数据处理方案」java大数据处理技术

本篇文章给大家谈谈java大数据处理方案，以及java大数据处理技术对应的知识点，希望对各位有所帮助，不要忘了收藏本站喔。

本文目录一览：

• 1、JAVA开源大数据查询分析引擎有哪些方案
• 2、有哪些 java 解决大数据量同步的优选方案
• 3、java 数据库插入超大数据怎么处理
• 4、java中大量数据如何提高性能？
• 5、Java如何处理大数据的

JAVA开源大数据查询分析引擎有哪些方案

在大数据处理分析过程中常用的六大工具：HadoopHadoop是一个能够对大量数据进行分布式处理的软件框架。但是Hadoop是以一种可靠、高效、可伸缩的方式进行处理的。Hadoop是可靠的，因为它假设计算元素和存储会失败，因此它维护多个工作数据副本，确保能够针对失败的节点重新分布处理。Hadoop是高效的，因为它以并行的方式工作，通过并行处理加快处理速度。Hadoop还是可伸缩的，能够处理PB级数据。此外，Hadoop依赖于社区服务器，因此它的成本比较低，任何人都可以使用。HPCCHPCC，HighPerformanceComputingandCommunications(高性能计算与通信)的缩写。1993年，由美国科学、工程、技术联邦协调理事会向国会提交了逗重大挑战项目：高性能计算与通信地的报告，也就是被称为HPCC计划的报告，即美国总统科学战略项目，其目的是通过加强研究与开发解决一批重要的科学与技术挑战问题。HPCC是美国实施信息高速公路而上实施的计划，该计划的实施将耗资百亿美元，其主要目标要达到：开发可扩展的计算系统及相关软件，以支持太位级网络传输性能，开发千兆比特网络技术，扩展研究和教育机构及网络连接能力。StormStorm是自由的开源软件，一个分布式的、容错的实时计算系统。Storm可以非常可靠的处理庞大的数据流，用于处理Hadoop的批量数据。Storm很简单，支持许多种编程语言，使用起来非常有趣。ApacheDrill为了帮助企业用户寻找更为有效、加快Hadoop数据查询的方法，Apache软件会近日发起了一项名为逗Drill地的开源项目。ApacheDrill实现了Google'sDremel.据Hadoop厂商MapRTechnologies公司产品经理TomerShiran介绍，逗Drill地已经作为Apache孵化器项目来运作，将面向全球软件工程师持续推广。RapidMinerRapidMiner是世界领先的数据挖掘解决方案，在一个非常大的程度上有着先进技术。它数据挖掘任务涉及范围广泛，包括各种数据艺术，能简化数据挖掘过程的设计和评价。

有哪些 java 解决大数据量同步的优选方案

建议采用缓存处理，按照你说的这种数据量，基于redis的缓存完全可以满足，存取速度可以10W+的，另外，拟采用的hashMap 是ConcurrentHashMap还是其他，页面展示是增量查询还是直接所有的再查询一次，socket数据接收你是用的netty还是mina，这都需要经过仔细的斟酌考虑设计的。有这么大的并发的需求，完全可以考虑做分布式集群的，估计这只是领导想要的目标吧

java 数据库插入超大数据怎么处理

1、加大Java可使的内存量、单次提交的条数再扩大些、扩大java连接数据库最大连接数都可以从量上来解决这个问题，但是想质的解决这样做是不好的。

2、用存储过程，来解决大量数据的CRUD是最明智的选择。写个存储过程，把数据一千条或几条的传给存储过程，由存储过程去解析，然后CRUD就能从本质上解决这个问题了。

这也是为何电信运营商的数据库应中，都是大量的存储过程即pl/sql的原因了。

java中大量数据如何提高性能？

通过使用一些辅助性工具来找到程式中的瓶颈，然后就能对瓶颈部分的代码进行优化。一般有两种方案：即优化代码或更改设计方法。我们一般会选择后者，因为不去调用以下代码要比调用一些优化的代码更能提高程式的性能。而一个设计良好的程式能够精简代码，从而提高性能。

????下面将提供一些在JAVA程式的设计和编码中，为了能够提高JAVA程式的性能，而经常采用的一些方法和技巧。

????1．对象的生成和大小的调整。

????JAVA程式设计中一个普遍的问题就是没有好好的利用JAVA语言本身提供的函数，从而常常会生成大量的对象（或实例）。由于系统不仅要花时间生成对象，以后可能还需花时间对这些对象进行垃圾回收和处理。因此，生成过多的对象将会给程式的性能带来非常大的影响。

????例1：关于String ,StringBuffer，+和append

????JAVA语言提供了对于String类型变量的操作。但如果使用不当，会给程式的性能带来影响。如下面的语句：

????String name=new String("HuangWeiFeng");

????System.out.println(name+"is my name");

????看似已非常精简了，其实并非如此。为了生成二进制的代码，要进行如下的步骤和操作：

????(1) 生成新的字符串 new String（STR_1);

????(2) 复制该字符串;

????(3) 加载字符串常量"HuangWeiFeng"（STR_2);

????(4) 调用字符串的构架器（Constructor）;

????(5) 保存该字符串到数组中（从位置0开始）;

????(6) 从java.io.PrintStream类中得到静态的out变量;

????(7) 生成新的字符串缓冲变量new StringBuffer(STR_BUF_1);

????(8) 复制该字符串缓冲变量;

????(9) 调用字符串缓冲的构架器（Constructor）;

????(10) 保存该字符串缓冲到数组中（从位置1开始）;

????(11) 以STR_1为参数，调用字符串缓冲(StringBuffer)类中的append方法;

????(12) 加载字符串常量"is my name"(STR_3);

????(13) 以STR_3为参数，调用字符串缓冲(StringBuffer)类中的append方法;

????(14) 对于STR_BUF_1执行toString命令;

????(15) 调用out变量中的println方法，输出结果。

????由此能看出，这两行简单的代码，就生成了STR_1,STR_2,STR_3,STR_4和STR_BUF_1五个对象变量。这些生成的类的实例一般都存放在堆中。堆要对所有类的超类，类的实例进行初始化，同时还要调用类极其每个超类的构架器。而这些操作都是非常消耗系统资源的。因此，对对象的生成进行限制，是完全有必要的。

????经修改，上面的代码能用如下的代码来替换。

????StringBuffer name=new StringBuffer("HuangWeiFeng");

????System.out.println(name.append("is my name.").toString());

????系统将进行如下的操作：

????(1) 生成新的字符串缓冲变量new StringBuffer(STR_BUF_1);

????(2) 复制该字符串缓冲变量;

????(3) 加载字符串常量"HuangWeiFeng"(STR_1);

????(4) 调用字符串缓冲的构架器（Constructor）;

????(5) 保存该字符串缓冲到数组中（从位置1开始）;

????(6) 从java.io.PrintStream类中得到静态的out变量;

????(7) 加载STR_BUF_1;

????(8) 加载字符串常量"is my name"(STR_2);

????(9) 以STR_2为参数，调用字符串缓冲(StringBuffer)实例中的append方法;

????(10) 对于STR_BUF_1执行toString命令(STR_3);

????(11)调用out变量中的println方法，输出结果。

????由此能看出，经过改进后的代码只生成了四个对象变量：STR_1,STR_2,STR_3和STR_BUF_1.你可能觉得少生成一个对象不会对程式的性能有非常大的提高。但下面的代码段2的执行速度将是代码段1的2倍。因为代码段1生成了八个对象，而代码段2只生成了四个对象。

????代码段1：

????String name= new StringBuffer("HuangWeiFeng");

????name+="is my";

????name+="name";

????代码段2：

????StringBuffer name=new StringBuffer("HuangWeiFeng");

????name.append("is my");

????name.append("name.").toString();

????因此，充分的利用JAVA提供的库函数来优化程式，对提高JAVA程式的性能时非常重要的.其注意点主要有如下几方面；

????(1) 尽可能的使用静态变量（Static Class Variables）

????如果类中的变量不会随他的实例而变化，就能定义为静态变量，从而使他所有的实例都共享这个变量。

????例：

????public class foo

????{

??????SomeObject so=new SomeObject();

????}

????就能定义为：

????public class foo

????{

??????static SomeObject so=new SomeObject();

????}

????(2) 不要对已生成的对象作过多的改动。

????对于一些类(如：String类)来讲，宁愿在重新生成一个新的对象实例，而不应该修改已生成的对象实例。

????例：

????String name="Huang";

????name="Wei";

????name="Feng";

????上述代码生成了三个String类型的对象实例。而前两个马上就需要系统进行垃圾回收处理。如果要对字符串进行连接的操作，性能将得更差，因为系统将不得为此生成更多得临时变量，如上例1所示。

????(3) 生成对象时，要分配给他合理的空间和大小JAVA中的非常多类都有他的默认的空间分配大小。对于StringBuffer类来讲，默认的分配空间大小是16个字符。如果在程式中使用StringBuffer的空间大小不是16个字符，那么就必须进行正确的初始化。

????(4) 避免生成不太使用或生命周期短的对象或变量。对于这种情况，因该定义一个对象缓冲池。以为管理一个对象缓冲池的开销要比频繁的生成和回收对象的开销小的多。

????(5) 只在对象作用范围内进行初始化。JAVA允许在代码的所有地方定义和初始化对象。这样，就能只在对象作用的范围内进行初始化。从而节约系统的开销。

????例：

????SomeObject so=new SomeObject();

????If(x==1) then

????{

??????Foo=so.getXX();

????}

????能修改为：

????if(x==1) then

????{

??????SomeObject so=new SomeObject();

??????Foo=so.getXX();

????}

????2．异常(Exceptions)

????JAVA语言中提供了try/catch来发方便用户捕捉异常，进行异常的处理。不过如果使用不当，也会给JAVA程式的性能带来影响。因此，要注意以下两点：

????(1) 避免对应用程式的逻辑使用try/catch

????如果能用if,while等逻辑语句来处理，那么就尽可能的不用try/catch语句。

????(2) 重用异常

????在必须要进行异常的处理时，要尽可能的重用已存在的异常对象。以为在异常的处理中，生成一个异常对象要消耗掉大部分的时间。

????3. 线程(Threading)

????一个高性能的应用程式中一般都会用到线程。因为线程能充分利用系统的资源。在其他线程因为等待硬盘或网络读写而 时，程式能继续处理和运行。不过对线程运用不当，也会影响程式的性能。

????例2：正确使用Vector类

????Vector主要用来保存各种类型的对象（包括相同类型和不同类型的对象）。不过在一些情况下使用会给程式带来性能上的影响。这主要是由Vector类的两个特点所决定的。第一，Vector提供了线程的安全保护功能。即使Vector类中的许多方法同步。不过如果你已确认你的应用程式是单线程，这些方法的同步就完全不必要了。第二，在Vector查找存储的各种对象时，常常要花非常多的时间进行类型的匹配。而当这些对象都是同一类型时，这些匹配就完全不必要了。因此，有必要设计一个单线程的，保存特定类型对象的类或集合来替代Vector类.用来替换的程式如下（StringVector.java）：

????public class StringVector

????{

??????private String [] data;

??????private int count;

??????public StringVector()

??????{

????????this(10); // default size is 10

??????}

??????public StringVector(int initialSize)

??????{

????????data = new String[initialSize];

??????}

??????public void add(String str)

??????{

??????// ignore null strings

??????if(str == null) { return; }

??????ensureCapacity(count + 1);

??????data[count++] = str;

??????}

??????private void ensureCapacity(int minCapacity)

??????{

????????int oldCapacity = data.length;

????????if (minCapacity oldCapacity)

????????{

??????????String oldData[] = data;

??????????int newCapacity = oldCapacity * 2;

??????????data = new String[newCapacity];

??????????System.arraycopy(oldData, 0, data, 0, count);

????????}

??????}

??????public void remove(String str)

??????{

??????if(str == null) { return; // ignore null str }

??????for(int i = 0; i count; i++)

??????{

????????// check for a match

????????if(data[i].equals(str))

????????{

??????????System.arraycopy(data,i+1,data,i,count-1); // copy data

??????????// allow previously valid array element be gc�0�7d

??????????data[--count] = null;

??????????return;

????????}

??????}

??????}

??????public final String getStringAt(int index)

??????{

??????if(index 0) { return null; }

??????else if(index count) { return null; // index is # strings }

??????else { return data[index]; // index is good }

??????}

????}

????因此，代码：

????Vector Strings=new Vector();

????Strings.add("One");

????Strings.add("Two");

????String Second=(String)Strings.elementAt(1);

????能用如下的代码替换：

????StringVector Strings=new StringVector();

????Strings.add("One");

????Strings.add("Two");

????String Second=Strings.getStringAt(1);

????这样就能通过优化线程来提高JAVA程式的性能。用于测试的程式如下（TestCollection.java）:

????import java.util.Vector;

????public class TestCollection

????{

??????public static void main(String args [])

??????{

????????TestCollection collect = new TestCollection();

????????if(args.length == 0)

????????{

??????????System.out.println("Usage: java TestCollection [ vector | stringvector ]");

??????????System.exit(1);

????????}

????????if(args[0].equals("vector"))

????????{

??????????Vector store = new Vector();

??????????long start = System.currentTimeMillis();

??????????for(int i = 0; i 1000000; i++)

??????????{

????????????store.addElement("string");

??????????}

??????????long finish = System.currentTimeMillis();

??????????System.out.println((finish-start));

??????????start = System.currentTimeMillis();

??????????for(int i = 0; i 1000000; i++)

??????????{

????????????String result = (String)store.elementAt(i);

??????????}

??????????finish = System.currentTimeMillis();

??????????System.out.println((finish-start));

????????}

????????else if(args[0].equals("stringvector"))

????????{

??????????StringVector store = new StringVector();

??????????long start = System.currentTimeMillis();

??????????for(int i = 0; i 1000000; i++) { store.add("string"); }

??????????long finish = System.currentTimeMillis();

??????????System.out.println((finish-start));

??????????start = System.currentTimeMillis();

??????????for(int i = 0; i 1000000; i++) {

????????????String result = store.getStringAt(i);

??????????}

??????????finish = System.currentTimeMillis();

??????????System.out.println((finish-start));

????????}

??????}

????}

????关于线程的操作，要注意如下几个方面：

????(1) 防止过多的同步

????如上所示，不必要的同步常常会造成程式性能的下降。因此，如果程式是单线程，则一定不要使用同步。

????(2) 同步方法而不要同步整个代码段

????对某个方法或函数进行同步比对整个代码段进行同步的性能要好。

????(3) 对每个对象使用多”锁”的机制来增大并发。

????一般每个对象都只有一个”锁”，这就表明如果两个线程执行一个对象的两个不同的同步方法时，会发生”死锁”。即使这两个方法并不共享所有资源。为了避免这个问题，能对一个对象实行”多锁”的机制。如下所示：

????class foo

????{

??????private static int var1;

??????private static Object lock1=new Object();

??????private static int var2;

??????private static Object lock2=new Object();

??????public static void increment1()

??????{

????????synchronized(lock1)

????????{

??????????var1++;

????????}

??????}

??????public static void increment2()

??????{

????????synchronized(lock2)

????????{

??????????var2++;

????????}

??????}

????}

????4．输入和输出(I/O)

????输入和输出包括非常多方面，但涉及最多的是对硬盘，网络或数据库的读写操作。对于读写操作，又分为有缓存和没有缓存的；对于数据库的操作，又能有多种类型的JDBC驱动器能选择。但无论怎样，都会给程式的性能带来影响。因此，需要注意如下几点：

????(1) 使用输入输出缓冲

????尽可能的多使用缓存。但如果要经常对缓存进行刷新（flush）,则建议不要使用缓存。

????(2) 输出流(Output Stream)和Unicode字符串

当时用Output Stream和Unicode字符串时，Write类的开销比较大。因为他要实现Unicode到字节(byte)的转换.因此，如果可能的话,在使用Write类之前就实现转换或用OutputStream类代替Writer类来使用。

????(3) 当需序列化时使用transient

当序列化一个类或对象时，对于那些原子类型（atomic）或能重建的原素要表识为transient类型。这样就不用每一次都进行序列化。如果这些序列化的对象要在网络上传输，这一小小的改动对性能会有非常大的提高。

????(4) 使用高速缓存（Cache）

对于那些经常要使用而又不大变化的对象或数据，能把他存储在高速缓存中。这样就能提高访问的速度。这一点对于从数据库中返回的结果集尤其重要。

????(5) 使用速度快的JDBC驱动器（Driver）

JAVA对访问数据库提供了四种方法。这其中有两种是JDBC驱动器。一种是用JAVA外包的本地驱动器；另一种是完全的JAVA驱动器。具体要使用哪一种得根据JAVA布署的环境和应用程式本身来定。

????5.一些其他的经验和技巧

????(1) 使用局部变量。

????(2) 避免在同一个类中动过调用函数或方法(get或set)来设置或调用变量。

????(3) 避免在循环中生成同一个变量或调用同一个函数（参数变量也相同）。

????(4) 尽可能的使用static,final,private等关键字。

Java如何处理大数据的

文件读取：首先是一个文件上传，数据入库，10-200万条不等，这里主要考虑到一次性读取，JVM分配出来的栈内存不一定会够（个人对内存这一块还是处于一知半解的状态，所以比较谨慎，若诸位大神有好的认知，希望评论留下地址分享一下），是依行读取数据，设定一个批量值，当读取的数据达到一定量之后，执行批量入库操作，清空集合，再接着读取。

//读取文件内容

while((s = br.readLine())!=null){

//判断是否达到单次处理量

if(num%leadingNum==0num!=0){

int a = stencDao.insertBatch(listBean);

if(a!=leadingNum){

flag = false;

}

//清空集合

listBean.clear();

}

String value = s.trim();

//将读取到的内容放入集合中

if(!value.equals("")){

StencilCustomer bean = new StencilCustomer();

bean.setCustomerPhone(value);

bean.setLinkStencilId(id);

listBean.add(bean);

num ++;

}

}

数据处理：这里的思路也是将数据小化然后处理，这里使用了多线程，设定单个线程处理量，然后开启多个线程处理，这里需要考虑你的服务器的承载能力，如果线程开得太多了，处理不过来，会出现蹦死的情况。例如200万数据，我开了20个线程，单个线程处理600条。

//建立一个线程池 ThreadPoolExecutor threadPool = new ThreadPoolExecutor(

minTaskNumber, maxTaskNumber, 3L, TimeUnit.SECONDS,

new ArrayBlockingQueueRunnable(minTaskNumber),

new ThreadPoolExecutor.DiscardOldestPolicy());

//当正在执行的线程数达到最大执行线程数的时候等待

boolean flag = true;

while(flag){

Thread.sleep(1000);//休眠2ms查询一次

int c = threadPool.getActiveCount();//线程池中活动中的线程数量

if(cmaxTaskNumber){

flag = false;

}

}

上面的代码是我对线程池的一个控制，控制服务器一直最大线程执行，Thread.sleep(1000);用while的时候，这个休眠最好不要去掉，去掉之后很影响执行效率

关于java大数据处理方案和java大数据处理技术的介绍到此就结束了，不知道你从中找到你需要的信息了吗 ？如果你还想了解更多这方面的信息，记得收藏关注本站。