亚洲日韩在线第一页,国产日产亚洲系列最新,亚洲精品456人成在线

Tue, 09 Mar 2021 12:29:00 GMT

摘要: 很多�|�上下蝲的PDF文�g都包含各�U��Ş式的水印�Q�本文主要阐�q�如何��用易转换一键删除PDF文�g中的各种囄��水印和文字水�?nbsp; 阅读全文

三�h行，必有我师�?/a> 2021-03-09 20:29 发表评论

Tue, 08 Nov 2016 05:12:00 GMT

Spark源代码下载地址�Q?http://spark.apache.org/downloads.html

下蝲后，直接�?Scala IDE 通过已存在的��目导入到Eclipse workspace中去�Q�然后Eclipse会自动进行编译。第一�ơ编译会报很多错误，不过�ȝ��来说�Q�导致编译错误的源头有三个：
1、Scala�~�译器版本错�?br /> 2、Eclipse Maven插�g不能自动识别spark project的一些pom�Q�报Plugin execution not covered by lifecycle configuration异常
3、一些项目，maven会自动生成scala和java文�g�Q�但是这些自动生成的代码文�g没有配置在eclipse��目的classpath里�?br />
针对�W�一�U�错误，比较��单，对于每个scala��目�Q�右键属性选择spark对应的scala�~�译器版本�?br />

当然spark代码里的��目有几十个�Q�只能手工一个个讄��了，比较傻，没办法，�q�不停的弹出对话框，不停地回车吧�?br />
�~�译的难点主要在�W�二�U�错误上�Q�比如spark-sql��目的pom, 里面有个build-helper-maven-plugin�Q�它下面的execution�Q�eclipse maven插�g无法识别�Q�报Plugin execution not covered by lifecycle configuration异常�Q�解��x��案参�?https://www.eclipse.org/m2e/documentation/m2e-execution-not-covered.html�Q�先使用 Eclipse quick-fix选项自动修复�Q�忽略此 maven goal�Q�Eclipse 会�ؓ pom.xml自动��d��一�D�xml代码�Q�包含在 pluginManagement section中，里面有一�D?�Q�此处手动修�Ҏ��

<action>
  <execute>
  <runOnIncremental>falserunOnIncremental>
    execute>
action>

然后右键 maven update project ��OK了�?br />
一共有5个project需要修改pom�Q�如�?br />

修改pom后重新编译，依旧会报一些错误，�q�些错误都是�׃��maven自动生成的java和scala代码没有��d��到classpath里导致的�~�译错误�Q�只需要手工添加一下即可，需要手工添加项目有 spark-streaming-flume-sink �?src_managed\main\compiled_avro 目录 �?spark-sql ��目�?test\gen-java 目录�?br />
全部�~�译好以后的截图�Q?br />

修改完以后，Spark代码全部�~�译下来大概耗时25分钟左右�Q�CPU 双核 I7 4600�Q?br />
原文地址�Q?a id="Editor_Edit_hlEntryLink" title="view: 【原创】��用Scala IDE�~�译Spark源代�? href="http://www.tkk7.com/cnfree/archive/2016/11/08/431965.html" target="_blank" style="color: #002c99; text-decoration: none; font-family: arial; font-size: 12px; line-height: normal; background-image: inherit; background-attachment: inherit; background-color: #ffffff; background-size: inherit; background-origin: inherit; background-clip: inherit; background-position: inherit; background-repeat: inherit;">http://www.tkk7.com/cnfree/archive/2016/11/08/431965.html

三�h行，必有我师�?/a> 2016-11-08 13:12 发表评论

转：Spark知识体系完整解读

Thu, 08 Sep 2016 05:11:00 GMT

　　Spark��?/span>

　　Spark是整个BDAS的核心组�Ӟ��是一个大数据分布式编�E�框�Ӟ��不仅实现了MapReduce的算子map 函数和reduce函数及计��模型，�q�提供更��Z��富的��子�Q�如filter、join、groupByKey�{�。是一个用来实现快速而同用的集群计算的��^台�?/p>

　　Spark��分布式数据抽象为弹性分布式数据集（RDD�Q�，实现了应用�Q务调度、RPC、序列化和压�~�，�q��ؓ�q�行在其上的上层�l��g提供API。其底层采用Scala�q�种函数式语�a�书写而成�Q��ƈ且所提供的API深度借鉴Scala函数式的�~�程思想�Q�提供与Scala�c�M��的编�E�接�?/p>

　　Sparkon Yarn

　　从用��h��交作业到作业�q�行�l�束整个�q�行期间的过�E�分析�?/span>

　　一、客��L��q�行操作

�Ҏ��yarnConf来初始化yarnClient�Q��ƈ启动yarnClient
创徏客户端Application�Q��ƈ获取Application的ID�Q�进一步判断集��中的资源是否满��executor和ApplicationMaster甌��的资源，如果不满��_��抛出IllegalArgumentException�Q?/span>
讄��资源、环境变量：其中包括了设�|�Application的Staging目录、准备本地资源（jar文�g、log4j.properties�Q�、设�|�Application其中的环境变量、创建Container启动的Context�{�；
讄��Application提交的Context�Q�包括设�|�应用的名字、队列、AM的申��L��Container、标记该作业的类型�ؓSpark�Q?/span>
甌��Memory�Q��ƈ最�l�通过yarnClient.submitApplication向ResourceManager提交该Application�?/span>

　　当作业提交到YARN上之后，客户端就没事了，甚至在终端关掉那个进�E�也没事�Q�因为整个作业运行在YARN集群上进行，�q�行的结果将会保存到HDFS或者日志中�?/span>

　　二、提交到YARN集群�Q�YARN操作

�q�行ApplicationMaster的run�Ҏ��Q?/span>
讄��好相关的环境变量�?/span>
创徏amClient�Q��ƈ启动�Q?/span>
在Spark UI启动之前讄��Spark UI的AmIpFilter�Q?/span>
在startUserClass函数专门启动了一个线�E�（名称为Driver的线�E�）来启动用��h��交的Application�Q�也��是启动了Driver。在Driver中将会初始化SparkContext�Q?/span>
�{�待SparkContext初始化完成，最多等待spark.yarn.applicationMaster.waitTries�ơ数�Q�默认�ؓ10�Q�，如果�{�待了的�ơ数��过了配�|�的�Q�程序将会退出；否则用SparkContext初始化yarnAllocator�Q?/span>
当SparkContext、Driver初始化完成的时候，通过amClient向ResourceManager注册ApplicationMaster
分配�q�启动Executeors。在启动Executeors之前�Q�先要通过yarnAllocator获取到numExecutors个Container�Q�然后在Container中启动Executeors�?/span>
　　那么�q�个Application��失败，��Application Status标明为FAILED�Q��ƈ��关闭SparkContext。其实，启动Executeors是通过ExecutorRunnable实现的，而ExecutorRunnable内部是启动CoarseGrainedExecutorBackend的�?/span>
最后，Task��在CoarseGrainedExecutorBackend里面�q�行�Q�然后运行状况会通过Akka通知CoarseGrainedScheduler�Q�直��C��业运行完成�?/span>

　　Spark节点的概�?/strong>

　　一、Spark驱动器是执行�E�序中的main()�Ҏ��的进�E��?/strong>它执行用��L��写的用来创徏SparkContext(初始�?、创建RDD�Q�以及运行RDD的�{化操作和行动操作的代码�?/p>

　　驱动器节点driver的职责：

把用��L��序�{��Z�Q务task(driver)
　　Spark驱动器程序负责把用户�E�序转化为多个物理执行单元，�q�些单元也被�U�C��Z�Q务task(详解见备�?
为执行器节点调度��d��(executor)
　　有了物理计划之后�Q�Spark驱动器在各个执行器节点进�E�间协调��d��的调度。Spark驱动器程序会�Ҏ��当前的执行器节点�Q�把所有�Q务基于数据所在位�|�分配给合适的执行器进�E�。当执行��d��Ӟ��执行器进�E�会把缓存的数据存储��h��Q�而驱动器�q�程同样会跟�t�这些缓存数据的位置�Q��ƈ利用�q�些位置信息来调度以后的��d��Q�以��量减少数据的网�l�传输。（��是所谓的�U�d��计算�Q�而不�U�d��数据)�?/p>

　　二、执行器节点

　　作用�Q?/p>

负责�q�行�l�成Spark应用的�Q务，�q�将�l�果�q�回�l�驱动器�q�程�Q?/span>
通过自��n的块��理�?blockManager)为用��L��序中要求�~�存的RDD提供内存式存储。RDD是直接缓存在执行器进�E�内的，因此��d��可以在运行时充分利用�~�存数据加快�q�算�?/span>

　　驱动器的职责�Q?/p>

　　所有的Spark�E�序都遵循同��L��l�构�Q�程序从输入数据创徏一�p�d��RDD�Q�再使用转化操作�z��成新的RDD�Q�最后��用行动操作手机或存储�l�果RDD�Q�Spark�E�序其实是隐式地创徏��Z��一个由操作�l�成的逻辑上的有向无环图DAG。当驱动器程序执行时�Q�它会把�q�个逻辑图�{为物理执行计划�?/p>

　　�q�样 Spark��把逻辑计划转�ؓ一�p�d��步骤(stage)�Q�而每个步骤又由多个�Q务组成。这些�Q务会被打包送到集群中�?/p>

　　Spark初始�?/span>

每个Spark应用都由一个驱动器�E�序来发起集��上的各�U��ƈ行操作。驱动器�E�序包含应用的main函数�Q��ƈ且定义了集群上的分布式数据集�Q�以及对该分布式数据集应用了相关操作�?/span>
驱动器程序通过一个SparkContext对象来访问spark,�q�个对象代表对计��集��的一个连接。（比如在sparkshell启动时已�l�自动创��Z��一个SparkContext对象�Q�是一个叫做SC的变量�?下图�Q�查看变量sc)
　　
一旦创��Z��sparkContext�Q�就可以用它来创建RDD。比如调用sc.textFile()来创��Z��个代表文本中各行文本的RDD。（比如vallinesRDD = sc.textFile(“yangsy.text”),val spark = linesRDD.filter(line=>line.contains(“spark”),spark.count()�Q?/span>
　　执行�q�些操作�Q�驱动器�E�序一般要��理多个执行�?��是我们所说的executor节点�?/span>
在初始化SparkContext的同�Ӟ��加蝲sparkConf对象来加载集��的配置�Q�从而创建sparkContext对象�?/span>
　　从源码中可以看到�Q�在启动thriftserver�Ӟ��调用了spark- daemon.sh文�g�Q�该文�g源码如左图，加蝲spark_home下的conf中的文�g�?/span>
　　
　　�Q�在执行后台代码�Ӟ��需要首先创建conf对象�Q�加载相应参敎ͼ� val sparkConf = newSparkConf().setMaster("local").setAppName("cocapp").set("spark.executor.memory","1g"), val sc: SparkContext = new SparkContext(sparkConf))

　　RDD工作原理�Q?/strong>

　　RDD(Resilient DistributedDatasets)[1] ,�Ҏ��分布式数据集，是分布式内存的一个抽象概念，RDD提供了一�U�高度受限的�׃�n内存模型�Q�即RDD是只�ȝ��记录分区的集合，只能通过在其他RDD执行��定的�{换操作（如map、join和group by�Q�而创建，然而这些限制��得实现容错的开销很低。对开发者而言�Q�RDD可以看作是Spark的一个对象，它本�w�运行于内存中，如读文�g是一个RDD�Q�对文�g计算是一个RDD�Q�结果集也是一个RDD �Q�不同的分片、数据之间的依赖、key-value�c�d��的map数据都可以看做RDD�?/p>

　　主要分�ؓ三部分：创徏RDD对象�Q�DAG调度器创建执行计划，Task调度器分配�Q务�ƈ调度Worker开始运行�?/p>

　　SparkContext(RDD相关操作)→通过(提交作业)→(遍历RDD拆分stage→生成作业)DAGScheduler→通过�Q�提交�Q务集�Q?#8594;��d��调度��理(TaskScheduler)→通过�Q�按照资源获取�Q�?→��d��调度��理(TaskSetManager)

　　Transformation�q�回��D��是一个RDD。它使用了链式调用的设计模式�Q�对一个RDD�q�行计算后，变换成另外一个RDD�Q�然后这个RDD又可以进行另外一�ơ�{换。这个过�E�是分布式的�?/p>

　　Action�q�回��g��是一个RDD。它要么是一个Scala的普通集合，要么是一个��|��要么是空�Q�最�l�或�q�回到Driver�E�序�Q�或把RDD写入到文件系�l�中

　　转换(Transformations)(如：map, filter, groupBy, join�{?�Q�Transformations操作是Lazy的，也就是说从一个RDD转换生成另一个RDD的操作不是马上执行，Spark在遇到Transformations操作时只会记录需要这��L��操作�Q��ƈ不会��L��行，需要等到有Actions操作的时候才会真正启动计��过�E�进行计��?/p>

　　操作(Actions)(如：count, collect, save�{?�Q�Actions操作会返回结果或把RDD数据写到存储�pȝ��中。Actions是触发Spark启动计算的动因�?/p>

　　它们本质区别是：Transformation�q�回��D��是一个RDD。它使用了链式调用的设计模式�Q�对一个RDD�q�行计算后，变换成另外一个RDD�Q�然后这个RDD又可以进行另外一�ơ�{换。这个过�E�是分布式的。Action�q�回��g��是一个RDD。它要么是一个Scala的普通集合，要么是一个��|��要么是空�Q�最�l�或�q�回到Driver�E�序�Q�或把RDD写入到文件系�l�中。关于这两个动作�Q�在Spark开发指南中会有��p��一步的详细介绍�Q�它们是��Z��Spark开发的核心�?/p>

　　RDD基础

Spark中的RDD��是一个不可变的分布式对象集合。每个RDD都被分�ؓ多个分区�Q�这些分��行在集群的不同节点上。创建RDD的方法有两种�Q�一�U�是��d��一个外部数据集�Q�一�U�是在群东程序里分发驱动器程序中的对象集合，不如刚才的示例，��d��文本文�g作�ؓ一个字�W�串的RDD的示例�?/span>
创徏出来后，RDD支持两种�c�d��的操�?转化操作和行动操�?/span>
　　转化操作会由一个RDD生成一个新的RDD。（比如刚才的根据谓词筛选）
　　行动操作会对RDD计算��Z��个结果，�q�把�l�果�q�回到驱动器�E�序中，或把�l�果存储到外部存储系�l�（比如HDFS�Q�中。比如first()操作��是一个行动操作，会返回RDD的第一个元素�?/span>
　　注：转化操作与行动操作的区别在于Spark计算RDD的方式不同。虽然你可以在�Q何时候定义一个新的RDD�Q�但Spark只会惰性计��这些RDD。它们只有第一个在一个行动操作中用到�Ӟ��才会真正的计��。之所以这栯��计，是因为比如刚才调用sc.textFile(...)时就把文件中的所有行都读取�ƈ存储��h��Q�就会消耗很多存储空��_��而我们马上又要筛选掉其中的很多数据�?/span>
　　�q�里�q�需要注意的一�Ҏ��Q�spark会在你每�ơ对它们�q�行行动操作旉��新计��。如果想在多个行动操作中重用同一个RDD�Q�那么可以��用RDD.persist()或RDD.collect()让Spark把这个RDD�~�存下来。（可以是内存，也可以是��盘)
Spark会��用谱�p�d��来记录这些不同RDD之间的依赖关�p�，Spark需要用�q�些信息来按需计算每个RDD�Q�也可以依靠��q��囑֜�持久化的RDD丢失部分数据时用来恢复所丢失的数据�?如下图，�q��oerrorsRDD与warningsRDD,最�l�调用union()函数)

　　RDD计算方式

　　RDD的宽�H�依�?/strong>

　　�H�依�?(narrowdependencies) 和宽依赖 (widedependencies) 。窄依赖是指 �?RDD 的每个分区都只被�?RDD 的一个分区所使用。相应的�Q�那么宽依赖��是指父 RDD 的分��多个�?RDD 的分区所依赖。例如， map ��是一�U�窄依赖�Q��?join 则会��D��宽依�?/p>

　　�q�种划分有两个用处。首先，�H�依赖支持在一个结点上��道化执行。例如基于一对一的关�p�，可以�?filter 之后执行 map 。其�ơ，�H�依赖支持更高效的故障还原。因为对于窄依赖�Q�只有丢��q��?RDD 的分区需要重新计��。而对于宽依赖�Q�一个结点的故障可能��D��来自所有父 RDD 的分��Z��失，因此��需要完全重新执行。因此对于宽依赖�Q�Spark 会在持有各个父分区的�l�点上，��中间数据持久化来简化故障还原，��像 MapReduce 会持久化 map 的输��Z��栗��?/p>

　　SparkExample

　　步骤 1 �Q�创�?RDD �?/strong>上面的例子除��L��后一�?collect 是个动作�Q�不会创�?RDD 之外�Q�前面四个�{换都会创建出新的 RDD 。因此第一步就是创建好所�?RDD( 内部的五��信�?) �?/p>

　　步骤 2 �Q�创建执行计划�?/strong>Spark 会尽可能地管道化�Q��ƈ��Z��是否要重新组�l�数据来划分阶段 (stage) �Q�例如本例中�?groupBy() 转换��׃��整个执行计划划分成两阶�D�|��行。最�l�会产生一�?DAG(directedacyclic graph �Q�有向无环图 ) 作�ؓ逻辑执行计划�?/p>

　　步骤 3 �Q�调度�Q务�?nbsp;��各阶段划分成不同的 ��d�� (task) �Q�每个�Q务都是数据和计算的合体。在�q�行下一阶段前，当前阶段的所有�Q务都要执行完成。因��Z��一阶段的第一个�{换一定是重新�l�织数据的，所以必��ȝ��当前阶段所有结果数据都计算出来了才能��l��?/p>

　　假设本例中的 hdfs://names 下有四个文�g块，那么 HadoopRDD �?partitions ��׃��有四个分区对应这四个块数据，同时 preferedLocations 会指明这四个块的最佳位�|�。现在，��可以创建出四个��d��Q��ƈ调度到合适的集群�l�点上�?/p>

　　Spark数据分区

Spark的特性是�Ҏ��据集在节炚w��的分��行控制。在分布式系�l�中�Q�通讯的代��h��巨大的，控制数据分布以获得最��的�|�络传输可以极大地提升整体性能。Spark�E�序可以通过控制RDD分区方式来减��通讯的开销�?/span>
Spark中所有的键值对RDD都可以进行分区。确保同一�l�的键出现在同一个节点上。比如，使用哈希分区��一个RDD分成�?00个分区，此时键的哈希值对100取模的结果相同的记录会被攑֜�一个节点上�?/span>
　　�Q�可使用partitionBy(newHashPartitioner(100)).persist()来构�?00个分�?
Spark中的许多操作都引入了��数据根据键跨界点进行�؜�z�的�q�程�?比如�Q�join(),leftOuterJoin(),groupByKey(),reducebyKey()�{?对于像reduceByKey()�q�样只作用于单个RDD的操作，�q�行在未分区的RDD上的时候会��D��每个键的所有对应值都在每台机器上�q�行本地计算�?/span>

　　SparkSQL的shuffle�q�程

　　Spark SQL的核心是把已有的RDD�Q�带上Schema信息�Q�然后注册成�c�M��sql里的”Table”�Q�对其进行sql查询。这里面主要分两部分�Q�一是生成SchemaRD�Q�二是执行查询�?/p>

　　如果是spark-hive��目�Q�那么读取metadata信息作�ؓSchema、读取hdfs上数据的�q�程交给Hive完成�Q�然后根据这俩部分生成SchemaRDD�Q�在HiveContext下进行hql()查询�?/p>

　　SparkSQL�l�构化数�?/span>

首先说一下ApacheHive�Q�Hive可以在HDFS内或者在其他存储�pȝ��上存储多�U�格式的表。SparkSQL可以��d��Hive支持的�Q何表。要把Spark SQL�q�接已有的hive上，需要提供Hive的配�|�文件。hive-site.xml文�g复制到spark的conf文�g夹下。再创徏出HiveContext对象(sparksql的入�?�Q�然后就可以使用HQL来对表进行查询，�q�以��p��的RDD的�Ş式拿到返回的数据�?/span>
创徏Hivecontext�q�查询数�?/span>
　　importorg.apache.spark.sql.hive.HiveContext
　　valhiveCtx = new org.apache.spark.sql.hive.HiveContext(sc)
　　valrows = hiveCtx.sql(“SELECT name,age FROM users”)
　　valfitstRow – rows.first()
　　println(fitstRow.getSgtring(0)) //字段0是name字段
通过jdbc�q�接外部数据源更��C��加蝲
　　Class.forName("com.mysql.jdbc.Driver")
　　val conn =DriverManager.getConnection(mySQLUrl)
　　val stat1 =conn.createStatement()
　　stat1.execute("UPDATE CI_LABEL_INFO set DATA_STATUS_ID = 2 , DATA_DATE ='" + dataDate +"' where LABEL_ID in ("+allCreatedLabels.mkString(",")+")")
　　stat1.close()
　　//加蝲外部数据源数据到内存
　　valDIM_COC_INDEX_MODEL_TABLE_CONF =sqlContext.jdbc(mySQLUrl,"DIM_COC_INDEX_MODEL_TABLE_CONF").cache()
　　val targets =DIM_COC_INDEX_MODEL_TABLE_CONF.filter("TABLE_DATA_CYCLE ="+TABLE_DATA_CYCLE).collect

　　SparkSQL解析

　　首先说下传统数据库的解析�Q�传�l�数据库的解析过�E�是按Rusult、Data Source、Operation的次序来解析的。传�l�数据库先将��d��的SQL语句�q�行解析�Q�分辨出SQL语句中哪些词是关键字�Q�如select,from,where)�Q�哪些是表达式，哪些是Projection�Q�哪些是Data Source�{�等。进一步判断SQL语句是否规范�Q�不规范��报错，规范则按照下一步过�E�绑定（Bind)。过�E�绑定是��SQL语句和数据库的数据字�?�?�?视图�{�）�q�行�l�定�Q�如果相关的Projection、Data Source�{�都存在�Q�就表示�q�个SQL语句是可以执行的。在执行�q�程中，有时候甚至不需要读取物理表��可以返回结果，比如重新�q�行刚运行过的SQL语句�Q�直接从数据库的�~�冲池中获取�q�回�l�果。在数据库解析的�q�程中SQL语句�Ӟ��会把SQL语句转化成一个树形结构来�q�行处理�Q�会形成一个或含有多个节点(TreeNode)的Tree,然后再后�l�的处理政对该Tree�q�行一�p�d��的操作�?/span>

　　Spark SQL对SQL语句的处理和关系数据库对SQL语句的解析采用了�c�M��的方法，首先会将SQL语句�q�行解析�Q�然后�Ş成一个Tree�Q�后�l�如�l�定、优化等处理�q�程都是对Tree的操作，而操作方法是采用Rule,通过模式匚w��Q�对不同�c�d��的节炚w��用不同的操作。SparkSQL有两个分支，sqlContext和hiveContext。sqlContext现在只支持SQL语法解析器（Catalyst)�Q�hiveContext支持SQL语法和HiveContext语法解析器�?br />
原文地址�Q?span style="font-family: verdana, "courier new"; line-height: 21px;">http://mt.sohu.com/20160522/n450849016.shtml

三�h行，必有我师�?/a> 2016-09-08 13:11 发表评论

转：spark通过合理讄��spark.default.parallelism参数提高执行效率

Thu, 08 Sep 2016 05:07:00 GMT

spark中有partition的概念（和slice是同一个概念，在spark1.2中官�|�已�l�做��Z��说明�Q�，一般每个partition对应一个task。在我的��试�q�程中，如果没有讄��spark.default.parallelism参数�Q�spark计算出来的partition非常巨大�Q�与我的cores非常不搭。我在两台机器上�Q?cores *2 +6g * 2�Q�上�Q�spark计算出来的partition辑ֈ�2.8万个�Q�也��是2.9万个tasks�Q�每个task完成旉��都是几毫�U�或者零点几毫秒�Q�执行�v来非常缓慢。在我尝试设�|�了 spark.default.parallelism 后，��d��数减��到10�Q�执行一�ơ计��过�E�从minute降到20second�?/p>
参数可以通过spark_home/conf/spark-default.conf配置文�g讄��?/p>
eg.

spark.master spark://master:7077

spark.default.parallelism 10

spark.driver.memory 2g

spark.serializer org.apache.spark.serializer.KryoSerializer

spark.sql.shuffle.partitions 50

下面是官�|�的相关描述�Q?/p>
from:http://spark.apache.org/docs/latest/configuration.html

Property Name Default Meaning

spark.default.parallelism For distributed shuffle operations like reduceByKey and join, the largest number of partitions in a parent RDD. For operations likeparallelize with no parent RDDs, it depends on the cluster manager:

Local mode: number of cores on the local machine

Mesos fine grained mode: 8

Others: total number of cores on all executor nodes or 2, whichever is larger

Default number of partitions in RDDs returned by transformations like join, reduceByKey, and parallelize when not set by user.

from:http://spark.apache.org/docs/latest/tuning.html

Level of Parallelism

Clusters will not be fully utilized unless you set the level of parallelism for each operation high enough. Spark automatically sets the number of “map” tasks to run on each file according to its size (though you can control it through optional parameters to SparkContext.textFile, etc), and for distributed “reduce” operations, such as groupByKey and reduceByKey, it uses the largest parent RDD’s number of partitions. You can pass the level of parallelism as a second argument (see the spark.PairRDDFunctions documentation), or set the config propertyspark.default.parallelism to change the default. In general, we recommend 2-3 tasks per CPU core in your cluster.

原文地址�Q?span style="font-family: verdana, "courier new"; font-size: 14px; line-height: 21px;">http://www.cnblogs.com/wrencai/p/4231966.html

三�h行，必有我师�?/a> 2016-09-08 13:07 发表评论

Java反编译工�?Eclipse Class Decompiler 2.10 已发布，支持多种反编译器

Fri, 13 May 2016 06:23:00 GMT
Eclipse Class Decompiler是一�ƾEclipse插�g�Q?strong>整合了多�U�反�~�译器，和Eclipse Class Viewer无缝集成�Q�能够很方便的��用插件查看类库源码，�q�行Debug调试�?br />同时�q�提供了在线自动查找源代码，查看Class二进制字节码的功能�?/strong>

Eclipse Class Decompiler对JDK的最低要求�ؓJDK1.6, 能反�~�译和debug各版本的Class文�g�Q�支持JDK8的Lambda语法�Q�同时支持中文等非Ascii码字�W�集的解析，支持Eclipse 3.6及以上所有版本的Eclipse�?br />
本插件支持Windows�Q�Linux�Q�Macosx 32位及64位操作系�l��?/strong>

Github��目地址为：https://github.com/cnfree/Eclipse-Class-Decompiler

请通过以下地址选择一个可用的源在�U�安装：

http://cnfree.github.io/Eclipse-Class-Decompiler/update
http://raw.githubusercontent.com/cnfree/eclipse/master/decompiler/update/
http://www.cpupk.com/decompiler/update/

��ȝ��包下载地址�Q?br />
https://github.com/cnfree/Eclipse-Class-Decompiler/releases/download/v2.10.0/eclipse-class-decompiler-update_v2.10.0.zip

插�g使用说明�Q?br />
下图为Eclipse Class Decompiler的首选项��面�Q�可以选择�~�省的反�~�译器工��P��q�进行反�~�译器的基本讄��。缺省的反编译工具�ؓJD-Core�Q�JD-Core更�ؓ先进一些，支持泛型、Enum、注解等JDK1.5以后才有的新语法�?br />
首选项配置选项�Q?br />1.重用�~�存代码�Q�只会反�~�译一�ơ，以后每次打开该类文�g�Q�都昄��的是�~�存的反�~�译代码�?br />2.忽略已存在的源代码：若未选中�Q�则查看Class文�g是否已绑定了Java源代码，如果已绑定，则显�C�Java源代码，如果未绑定，则反�~�译Class文�g。若选中此项�Q�则忽略已绑定的Java源代码，昄��反编译结果�?br />3.昄��反编译器报告�Q�显�C�反�~�译器反�~�译后生成的数据报告及异�怿�息�?br />4.使用Eclipse代码格式化工��P��使用Eclipse格式化工具对反编译结果重新格式化排版�Q�反�~�译整个Jar包时�Q�此操作会消耗一些时间�?br />5.使用Eclipse成员排序�Q��用Eclipse成员排序对反�~�译�l�果重新格式化排版，反编译整个Jar包时�Q�此操作会消耗大量时间�?br />6.以注释方式输出原始行号信息：如果Class文�g包含原始行号信息�Q�则会将行号信息以注释的方式打印到反�~�译�l�果中�?br />7.�Ҏ��行号寚w��源代码以便于调试�Q�若选中该项�Q�插件会采用AST工具分析反编译结果，�q�根据行号信息调整代码顺序，以便于Debug�q�程中的单步跟踪调试�?br />8.讄��c�d��~�译查看器作为缺省的�c�L��件编辑器�Q�默认�ؓ选中�Q�将忽略Eclipse自带的Class Viewer�Q�每�ơEclipse启动后，默认使用本插件提供的�c�L��看器打开Class文�g�?br />

插�g提供了系�l�菜单，工具栏，当打开了插件提供的�c�d��~�译查看器后�Q�会�Ȁ�z�菜单和工具栏选项�Q�可以方便的�q�行首选项配置�Q�切换反�~�译工具重新反编译，以及导出反编译结果�?br />

�c�d��~�译查看器右键菜单包含了Eclipse自带�c�L��看器右键菜单的全部选项�Q��ƈ增加了一�?#8220;导出反编译源代码”菜单��V�?/div>

打开��目路径下的Class文�g�Q�如果设�|�类反编译查看器为缺省的查看器，直接双击Class文�g卛_��Q�如果没有设�|��ؓ�~�省查看器，可以使用右键菜单�q�行查看�?br />

同时插�g也支持直接将外部的Class文�g拖拽到Eclipse�~�辑器中�q�行反编译�?br />

Eclipse Class Decompiler插�g也提供了反编译整个Jar文�g或者Java包的反编译。该操作支持Package Explorer对包昄��布局的操作，如果是��^铺模式布局�Q�则导出的源代码不包含子包，如果是层�U�模式布局�Q�则导出选中的包及其所有的子包�?br />

Debug调试�Q�可以在首选项选中寚w��行号�q�行单步跟踪调试�Q�和普通的包含源代码时的调试操作完全一��_��同样的也可以讄��断点�q�行跟踪。当透视图�ؓDebug�Ӟ��插�g自动生成行号�q�进行对齐方便调试代码，无需�q�行��M��讄��?/div>

博文地址�Q?a href="http://www.tkk7.com/cnfree/archive/2012/10/30/390457.html">http://www.tkk7.com/cnfree/archive/2012/10/30/390457.html

三�h行，必有我师�?/a> 2016-05-13 14:23 发表评论

Sun, 03 Mar 2013 09:25:00 GMT
Java应用定制工厂�Q�以下简�U�CؓJCB�Q�Java Customization Builder�Q�是一个针对Java轻量�U�桌面应用进行精��优化的小工具�Q��用它可以�_��你的jar包，�q�自动生成一个精��的JRE�Q�也可以使用它生成一个Exe启动引导�E�序�Q��ƈ且能够对你的Java应用自动做Pack200和Unpack200处理。��用本工具定制的Java桌面应用通常不会��过10M�Q�包含JRE�Q�，SWT客户端程序相对于Swing客户端程序更��，一般不会超�q?M�?br />
JCB是一个Java应用�Q�所以目标机器上必须安装1.5以上版本的JDK用以启动JCB�Q�但是JCB可以用来�_��1.4版的JRE�Q��ƈ且JRE1.4�_��后的体积�q�小�?.5以上的版本�?br />
1.新徏JCB��目
�_��JRE的步骤比较繁琐，有可能精��p�|�Q��ؓ了不重复之前的步骤，JCB提供一个项目文件用来保存精��配置信息�Q�扩展名为jcprj。这里我们创��Z��个项目，名�ؓJCB

Wizard需要输入一个工�E�名和指定工�E�位�|�，至于下面的应用程序位�|�和定制JRE位置由JCB自动指定�Q�这儿显�C�出来仅供参考�?br />
此时最好Ctrl+S保存一下项目，否则退出后你之前的配置信息会全部丢失，因�ؓ你�ƈ没有制定一个可用的��目配置文�g�?/span>

2. 配置JCB��目

首先指定��目需要的jar文�g�Q�然后依�ơ选择��目的main class�Q�启动�\径默认�ؓ�I�，一般来说无需指定。然后设定应用程序参数和虚拟机参数。最后选定需要精��的JRE�Q�JCB当前支持1.4-1.7版本的JRE�Q�未来可能会支持更高版本的JRE�?br />
右下角有2个单选按钮：全部重新�q�行和增量运行。全部重新运行就会放弃之前的�q�行�l�果�Q�增量运行就是会保留以前的运行结果�?br />
然后点击“以Verbose模式�q�行”按钮。Verbose模式�q�行Java�E�序�Q�会昄��JVM加蝲的全部类信息�Q�JCB需要这些类信息�q�行JRE的精��Q�所以请��可能的把应用所有的功能��可能的跑一遍，跑的��全面，��D��_��出错的可能性就��低�?br />

Verbose�q�行�l�果�Q�这个页面的昄��信息仅供参考，无实际用处�?br />
3. 分析��目的类依赖��?br />

分析�c�M��赖模式有2个选项�Q�重新完全分析和增量分析。完全分析会��p��较多的时间。当使用verbose模式增量�q�行后，可以使用增量模式分析�c�M��赖项�Q�这样可以节�U�大量的旉��。类依赖分析会反�~�译所有运行的�c�，分析�c�d��用关�p�，但是无法获取Class.forName�q�类动态类加蝲信息�Q�所以需要Verbose模式�q�行的尽量全面，以避免这些动态加载的�cȝ��~�失�?br />
��Z��么需要分析类依赖关系呢？因�ؓ不同的操作系�l�，不同的硬仉��|�，JRE可能会采取策略模式加载不同的�c�，或者一些异常，Verbose模式一般不会加载，�q�样换个��g环境�Q�仅仅��用Verbose模式的类可能会导致ClassNotFound�q�样的异常，��D��Java�E�序崩溃�?br />

4. �_��JRE

�_��JRE有两�U�模式：使用Verbose�q�行�l�果和��用类依赖分析�l�果。前者只包含Verbose分析出来的类�Q�精��出来的JRE包很��，但是基本不具备跨�q�_��性。所以一般来说推荐选择后者�?br />
如果你的�E�序包含Swing的客��L��Q��ƈ且比较复杂的话，最好选中包含Swing选项。因为Swing的设计完全是动态化的加载，全部使用Class.forName方式�Q�类依赖分析对Swing是无效的。当焉��中该选项后，JRE的体�U�会增加许多。比较好的解��x��案，是��用SWT替代Swing�q�行开发，或者尽量把你的�E�序跑全面，包括各种异常界面都跑出来�?br />
右下角有两个按钮�Q�是用来自定义类和资源文件的�Q�比如移除JAR包的MD5文�g或者无用的文�g。或者测试运行发现ClassNotFound异常�Q�手动把�~�少的类加进去，然后JCB会自动运行增量类依赖分析加蝲所有可能需要的�c�R�?br />
选择左上角的“�_��Jar�?#8221;按钮�Q�就可以对JRE�q�行�_��了，�_��完毕后可以点�?#8220;查看�_��l�果”按钮�q�行查看�?br />
5.定制JRE

上图昄��了JRE�_��l�果�Q�JCB会自动分析所有的Class�Q�生成精��版JRE�Q�包括需要的JAR�Q�DLL和资源文件。一般来说精��出来的JRE�Q�普通功能都能正��完成，但是不排除有些功能不能正�怋�用，比如�~�少某个资源文�g或者DLL�Q�需要手工添加�?br />
��Z��保证�_��的正��性，你需要进行运行测试，�q�一步是必须的，而且最好和Verbose�q�行模式一��P��把所有的功能都跑一遍，��认�_��无误�?br />

如果��试�q�行有误的话�Q�请�Ҏ��q�行错误报告�q�行分析�Q�如果缺��类�Q�请使用Verbose模式重新�q�行相应的功能，或者在步骤四手工添加需要的�c�，然后重新生成依赖的JRE。如果缺��相关的DLL或者资源文�Ӟ��也请手工��d��Q��ƈ且取消步骤四�?#8220;清理工作区选项”�Q�否则每�ơ精��JRE都需要重新手工添加�?br />
到此为止�Q�精��JRE部分��q��全部完成了，你最好��用Ctrl+S保存一下结果，以避免下�ơ重做项目�?/span>

JCB��目下蝲地址�Q?a >http://www.sourceforge.net/projects/jcb

三�h行，必有我师�?/a> 2013-03-03 17:25 发表评论

Sat, 24 Nov 2012 14:21:00 GMT
1. 40亿个无符��h��敎ͼ�扑և�一个不在这40亿个整数中的数。可以换个方向思考， 99个小�?00的数�Q�找��Z��个不在这99个数中的��于100的数�?br />首先把这99个数分�ؓ10�l�，按高位�ؓ0-9分，然后计算每组的数量，数量最��的那个肯定��是�~�失的那个，然后递归……找最��的那个�Q�组合�v来的数肯定是�~�失的。答案是按位�q�算找，和这个类伹{�?br />
2. 43亿个无符��h��敎ͼ�扑և�一个重复的整数。也��是101个小�?00的数�Q�找出重复的那个数来�?br />首先把这99个数分�ؓ10�l�，按高位�ؓ0-9分，然后计算每组的数量，数量最多的那组�Q�肯定有重复的，一�ơ类推找�W�二�?#8230;…

三�h行，必有我师�?/a> 2012-11-24 22:21 发表评论

The difference between dependency and association

Mon, 19 Nov 2012 05:16:00 GMT
When a object creates a new object, please use the dependency.

When a object just uses a object, please use the association.

三�h行，必有我师�?/a> 2012-11-19 13:16 发表评论

研磨设计模式…�?

Tue, 13 Nov 2012 16:22:00 GMT

comparator
Decorator Pattern and Adapter Pattern have the same alias name: wrapper. But they face different aspects. Decorator pattern changes the object function, but the adapter pattern changes the interface.

The typical decorator pattern is the java OutputStream, you can use the BufferedOutputStream to wrap it, then get the extra function.
The typical adapter pattern in the BIRT is the ElementAdapter, it can convert any object to an other object.

Decorator pattern must extend the class which you want to wrap, but the adapter class must implements the interface using by the client.

FlyWeight pattern extracts the same part of some different objects, and the part doesn't be changed when these objects changed. String class uses the FlyWeight pattern, jface ImageRegistry also uses it.
FlyWeight can have a interface to get external data, and change the external data's status, but FlyWeight internal status shouldn't be changed.

The Collections.sort() method implementation contains template method design pattern and strategy design pattern, but it doesn't contain the visitor design pattern. The Collections.sort() method uses the merge sort algorithm, you can't change it, but you can change the comparator logic, it's one step of the sort algorithm. So it's a template method pattern, but not a classic implementation, it uses the callback method to implement the pattern, but not extending the parent template class. The comparator class use the strategy design pattern, it not a visitor pattern, visitor pattern have a accept method to operate the element to deal some logic.

三�h行，必有我师�?/a> 2012-11-14 00:22 发表评论

排序1+4�Q�归�q�排序（MergeSort�Q�和堆排序（HeapSort�Q�（转）

Sat, 10 Nov 2012 15:18:00 GMT

1 归�ƈ排序�Q�MergeSort�Q?/strong>

归�ƈ排序最差运行时间是O(nlogn)�Q�它是利用递归设计�E�序的典型例子�?br />
归�ƈ排序的最基础的操作就是合�q�两个已�l�排好序的序列�?br />
假设我们有一个没有排好序的序列，那么首先我们使用分割的办法将�q�个序列分割成一个一个已�l�排好序的子序列。然后再利用归�ƈ的方法将一个个的子序列合�ƈ成排序好的序列。分割和归�ƈ的过�E�可以看下面的图例�?br />

从上囑֏�以看出，我们首先把一个未排序的序列从中间分割�?部分�Q�再�?部分分成4部分�Q�依�ơ分割下去，直到分割成一个一个的数据�Q�再把这些数据两两归�q�到一��P��使之有序�Q�不停的归�ƈ�Q�最后成��Z��个排好序的序列�?br />
如何把两个已�l�排序好的子序列归�ƈ成一个排好序的序列呢�Q�可以参看下面的�Ҏ��?br />
假设我们有两个已�l�排序好的子序列�?br />序列A�Q? 23 34 65
序列B�Q? 13 14 87
那么可以按照下面的步骤将它们归�ƈ��C��个序列中�?br />
�Q?�Q�首先设定一个新的数列C[8]�?br />�Q?�Q�A[0]和B[0]比较�Q�A[0] = 1�Q�B[0] = 2�Q�A[0] < B[0]�Q�那么C[0] = 1
�Q?�Q�A[1]和B[0]比较�Q�A[1] = 23�Q�B[0] = 2�Q�A[1] > B[0]�Q�那么C[1] = 2
�Q?�Q�A[1]和B[1]比较�Q�A[1] = 23�Q�B[1] = 13�Q�A[1] > B[1]�Q�那么C[2] = 13
�Q?�Q�A[1]和B[2]比较�Q�A[1] = 23�Q�B[2] = 14�Q�A[1] > B[2]�Q�那么C[3] = 14
�Q?�Q�A[1]和B[3]比较�Q�A[1] = 23�Q�B[3] = 87�Q�A[1] < B[3]�Q�那么C[4] = 23
�Q?�Q�A[2]和B[3]比较�Q�A[2] = 34�Q�B[3] = 87�Q�A[2] < B[3]�Q�那么C[5] = 34
�Q?�Q�A[3]和B[3]比较�Q�A[3] = 65�Q�B[3] = 87�Q�A[3] < B[3]�Q�那么C[6] = 65
�Q?�Q�最后将B[3]复制到C中，那么C[7] = 87。归�q�完成�?br />
如果我们清楚了上面的分割和归�q�过�E�，那么我们��可以用递归的方法得到归�q�算法的实现�?/p>
    public class MergeSorter
    {
        private static int[] myArray;
        private static int arraySize;

        public static void Sort( int[] a )
        {
            myArray = a;
            arraySize = myArray.Length;
            MergeSort();
        }

        ///

        /// 利用归�ƈ的方法排序数�l�，首先��序列分�?br />        /// 然后��数列归�qӞ��q�个��法需要双倍的存储�I�间
        /// 旉��是O(nlgn)
        ///

        private static void MergeSort()
        {
            int[] temp = new int[arraySize];
            MSort( temp, 0, arraySize - 1);
        }

        private static void MSort(int[] temp, int left, int right)
        {
            int mid;

            if (right > left)
            {
                mid = (right + left) / 2;
                MSort( temp, left, mid); //分割左边的序�?/span>
                MSort(temp, mid+1, right);//分割双��的序�?/span>
                Merge(temp, left, mid+1, right);//归�ƈ序列
            }
        }

        private static void Merge( int[] temp, int left, int mid, int right)
        {
            int i, left_end, num_elements, tmp_pos;

            left_end = mid - 1;
            tmp_pos = left;
            num_elements = right - left + 1;

            while ((left <= left_end) && (mid <= right))
            {
                if (myArray[left] <= myArray[mid]) //��左端序列归�q�到temp数组�?/span>
                {
                    temp[tmp_pos] = myArray[left];
                    tmp_pos = tmp_pos + 1;
                    left = left +1;
                }
                else//��右端序列归�q�到temp数组�?/span>
                {
                    temp[tmp_pos] = myArray[mid];
                    tmp_pos = tmp_pos + 1;
                    mid = mid + 1;
                }
            }

            while (left <= left_end) //拯��左边剩余的数据到temp数组�?/span>
            {
                temp[tmp_pos] = myArray[left];
                left = left + 1;
                tmp_pos = tmp_pos + 1;
            }
            while (mid <= right) //拯��双��剩余的数据到temp数组�?/span>
            {
                temp[tmp_pos] = myArray[mid];
                mid = mid + 1;
                tmp_pos = tmp_pos + 1;
            }

            for (i=0; i < num_elements; i++) //��所有元素拷贝到原始数组�?/span>
            {
                myArray[right] = temp[right];
                right = right - 1;
            }
        }
    }

归�ƈ排序��法是一�U�O(nlogn)的算法。它的最差，�q�_��Q�最好时间都是O(nlogn)。但是它需要额外的存储�I�间�Q�这在某些内存紧张的机器上会受到限制�?br />
归�ƈ��法是又分割和归�q�两部分�l�成的。对于分割部分，如果我们使用二分查找的话�Q�时间是O(logn)�Q�在最后归�q�的时候，旉��是O(n)�Q�所以�ȝ��旉��是O(nlogn)�?br />
2 堆排序（HeapSort�Q?/strong>

堆排序属于百万俱乐部的成员。它特别适合��大数据量（百万条记录以上）的排序。因为它�q�不使用递归�Q�因��大数据量的递归可能会导致堆栈溢出）�Q�而且它的旉��也是O(nlogn)。还有它�q�不需要大量的额外存储�I�间�?br />
堆排序的思�\�?

(1)��原始未排序的数据徏成一个堆�?br />(2)建成堆以后，最大值在堆顶�Q�也��是�W?个元素，�q�时候将�W�零个元素和最后一个元素交换�?br />(3)�q�时候将�?到倒数�W�二个元素的所有数据当成一个新的序列，��Z��个新的堆�Q�再�ơ交换第一个和最后一个元素，依次�c�L��Q�就可以��所有元素排序完毕�?br />
建立堆的�q�程如下面的图所�C?

堆排序的具体��法如下�Q?/p>
public class HeapSorter
    {
        private static int[] myArray;
        private static int arraySize;

        public static void Sort( int[] a )
        {
            myArray = a;
            arraySize = myArray.Length;
            HeapSort();
        }

        private static void HeapSort()
        {
            BuildHeap();            //��原始序列徏成一个堆

            while ( arraySize > 1 )
            {
                arraySize--;
                Exchange ( 0, arraySize );//��最大值放在数�l�的最�?/span>
                DownHeap ( 0 );  //��序列从0到n-1看成一个新的序列，重新建立�?/span>
            }
        }

        private static void BuildHeap()
        {
            for (int v=arraySize/2-1; v>=0; v--)
                DownHeap ( v );
        }

        //利用向下遍历子节点徏立堆
        private static void DownHeap( int v )
        {
            int w = 2 * v + 1;                     // 节点w是节点v的第一个子节点

            while (w < arraySize)
            {
                if ( w+1 < arraySize )        // 如果节点v下面有第二个字节�?/span>
                    if ( myArray[w+1] > myArray[w] )
                        w++;                        // ��子节点w讄��成节点v下面值最大的子节�?br />
                 // 节点v已经大于子节点w�Q�有了堆的性质�Q�那么返�?/span>
                if ( myArray[v] >= myArray[w] )
                    return;

                Exchange( v, w );     // 如果不是�Q�就交换节点v和节点w的�?/span>
                v = w;
                w = 2 * v + 1;            // �l�箋向下扑֭�节点
            }
        }

        //交换数据
        private static void Exchange( int i, int j )
        {
            int t = myArray[i];
            myArray[i] = myArray[j];
            myArray[j] = t;
        }
    }

堆排序主要用于超大规模的数据的排序。因为它不需要额外的存储�I�间�Q�也不需要大量的递归�?/span>

3 几种O(nlogn)��法的初步比�?/span>

我们可以从下表看到几�U�O(nlogn)��法的效率的区别。所有的数据都��?Net的Random�c�M�生，每种��法�q�行100�ơ，旉��的单位�ؓ毫秒�?/span>

500随机整数 5000随机整数 20000随机整数
合�ƈ排序 0.3125 1.5625 7.03125
Shell排序 0.3125 1.25 6.875
堆排�?/td> 0.46875 2.1875 6.71875
快速排�?/td> 0.15625 0.625 2.8125

从上表可以明昑֜�看出�Q�快速排序是最快的��法。这也就�l�了我们一个结论，对于一般的应用来说�Q�我们��L��选择快速排序作为我们的排序��法�Q�当数据量非常大�Q�百万数量��Q�我们可以��用堆排序�Q�如果内存空间非常紧张，我们可以使用Shell排序。但是这意味着我们不得不损失速度�?nbsp;

/******************************************************************************************
*【Author】：flyingbread
*【Date】：2007�q?�?�?/span>
*【Notice】：
*1、本文�ؓ原创技术文章，首发博客园个人站�?http://flyingbread.cnblogs.com/)�Q��{载和引用��h��明作者及出处�?/span>
*2、本文必��d��文�{载和引用�Q��Q何组�l�和个�h未授权不能修改�Q何内容，�q�且未授权不可用于商业�?/span>
*3、本声明为文章一部分�Q��{载和引用必须包括在原文中�?/span>
******************************************************************************************/

三�h行，必有我师�?/a> 2012-11-10 23:18 发表评论

	500随机整数	5000随机整数	20000随机整数
合�ƈ排序	0.3125	1.5625	7.03125
Shell排序	0.3125	1.25	6.875
堆排�?/td>	0.46875	2.1875	6.71875
快速排�?/td>	0.15625	0.625	2.8125

亚洲日韩在线第一页,国产日产亚洲系列最新,亚洲精品456人成在线

转：Spark知识体系完整解读

转：spark通过合理讄���spark.default.parallelism参数提高执行效率

Level of Parallelism

Java反编译工�?Eclipse Class Decompiler 2.10 已发布，支持多种反编译器

The difference between dependency and association

研磨设计模式…�?

comparator

排序1+4�Q�归�q�排序（MergeSort�Q�和堆排序（HeapSort�Q�（转）

转：spark通过合理讄��spark.default.parallelism参数提高执行效率