Jarvis`s library

使用OpenRaft简单实现的分布式KV系统

Tue, 12 May 2026 00:00:00 +0000

简单实现了一个基于 Rust 实现的分布式 KV 系统，底层共识算法使用 Raft，具体实现依赖 OpenRaft。
这个项目没有自己从零实现一套 Raft 协议，而是把更多精力放在工程落地上。

从工程角度看，这个仓库的核心价值不在于“再讲一遍 Raft 原理”，而在于回答一个更实际的问题：

如果我基于 OpenRaft 做一个真正能跑起来的分布式 KV，除了把库接进来之外，还需要补齐哪些能力？

这篇文章就围绕这个问题展开，结合仓库 distribute_kv_openraft的实现，复盘一个最小可运行 Raft KV 系统该怎么实现，以及OpenRaft系统中的组件功能。

一道智力题, 25匹马, 5条赛道, 选出跑的最快的5匹马, 至少需要跑几次

Wed, 12 Feb 2025 00:00:00 +0000

最近在网上冲浪的刷博客的时候, 看到一个题目.

总共有25匹马, 一共有5个赛道, 现在要选出跑的最快的5匹马, 至少需要比赛几次?

这个问题刚看到的时候, 看了一眼下面的答案就略过去了, 但是后面突然回想到这道题, 然后没有想通为什么是这样, 特此记录一下.

SeaTunnel应用文章(一)-安装部署

Tue, 24 Dec 2024 00:00:00 +0000

前言

这篇文章会介绍一下, SeaTunnel如何在不同环境下进行安装部署, 以及一些可以去调节的参数配置. 这里仅设计Zeta引擎的相关内容, Spark, Flink引擎的提交不需要搭建集群, 所以不会涉及.

博客自动部署方案

Thu, 19 Dec 2024 00:00:00 +0000

趁着这次博客迁移, 更新记录下当前博客的写作, 同步, 发布方案.

SeaTunnel源码解析-(二)Zeta引擎源码讲解

Mon, 25 Nov 2024 00:00:00 +0000

省流

这篇文章以seatunnel 2.3.6版本，讲解了一个zeta引擎的一个任务是如何从提交到运行的全流程，希望通过这篇文档，对刚刚上手seatunnel的朋友提供一些帮助。

这篇文章将从

seatunnel server端的初始化
client端的任务提交流程
server端的接收到任务的执行流程三部分来记录下一个任务的整体流程

参考

[ST-Engine][Design] The Design of LogicalPlan to PhysicalPlan

集群拓扑

首先从整体了解下SeaTunnel的Zeta引擎架构， SeaTunnel是基于hazelcast来实现的分布式集群通信

在2.3.6版本之后，集群中的节点可以被分配为master或worker节点，从而将调度与执行分开，避免master节点的负载过高从而出现问题。

并且2.3.6版本还添加了一个功能是，可以对每个节点添加tag属性，当提交任务时可以通过tag来选择任务将要运行的节点，从而达到资源隔离的目的（2.3.6版本有问题，2.3.8版本中进行了修复，如果需要使用此功能请使用2.3.8版本）。

集群的服务端分为master和worker节点， master节点负责接收请求，逻辑计划生成，分配任务等（与之前的版本相比，会多了几个backup节点，但是对于集群稳定性来说是一个挺大的提升）。而worker节点则只负责执行任务，也就是数据的读取和写入。提交任务时可以创建hazelcast的客户端连接集群来进行通信，或者使用restapi来进行通信。

服务端启动

当我们对集群的整体架构有个大致的了解后，我们再来具体了解下具体的流程

首先看下server端的启动过程。 server端的启动命令为：


sh bin/seatunnel-cluster.sh -d -r <node role type>

当我们查看这个脚本的内容后就会发现，这个脚本最终的执行命令为：

`1`	`java -cp seatunnel-starter.jar org.apache.seatunnel.core.starter.seatunnel.SeaTunnelServer <other_java_jvm_config_and_args>`

我们查看这个starter.seatunnel.SeaTunnelServer的代码

public class SeaTunnelServer {
    public static void main(String[] args) throws CommandException {
        ServerCommandArgs serverCommandArgs =
                CommandLineUtils.parse(
                        args,
                        new ServerCommandArgs(),
                        EngineType.SEATUNNEL.getStarterShellName(),
                        true);
        SeaTunnel.run(serverCommandArgs.buildCommand());
    }
}

这个代码是使用了JCommander来解析用户传递的参数并构建并运行Command， serverCommandArgs.buildCommand返回的类为：

SeaTunnel源码解析-(三)Zeta引擎执行解析

Mon, 25 Nov 2024 00:00:00 +0000

这篇文章会聊些什么

SeaTunnel作为一款数据集成工具, 那么它最终的目的是来做数据同步的, 可以将数据从某个存储同步到另外一个存储中. 但是这篇文档并不会聊它使用层面的事情, 而是去聊一下这个工具/框架的设计, 任务的执行等.对于某个连接器(数据库)的实现不会深入的了解. 基于的源码版本: 2.3.6-release

任务是如何被执行的

在我的另外一篇文章2.Zeta引擎源码讲解中有一些关于Zeta引擎的分析, 聊了一下Zeta引擎的客户端, 服务端都会做一些什么事情, 也笼统的带了一点任务执行的内容, 想了解相关内容的朋友可以去看一下. 在下面的内容, 则主要是记录一下在SeaTunnel中, 一个任务是如何与连接器中的各种类进行关联的.

要聊任务与连接器的关联, 就要回到物理计划生成的这一部分(PhysicalPlanGenerator#generate()).

Stream<SubPlan> subPlanStream =  
        pipelines.stream()  
                .map(  
                        pipeline -> {  
                            this.pipelineTasks.clear();  
                            this.startingTasks.clear();  
                            this.subtaskActions.clear();  
                            final int pipelineId = pipeline.getId();  
                            final List<ExecutionEdge> edges = pipeline.getEdges();  
  
                            List<SourceAction<?, ?, ?>> sources = findSourceAction(edges);  
  
                            List<PhysicalVertex> coordinatorVertexList =  
                                    getEnumeratorTask(  
                                            sources, pipelineId, totalPipelineNum);  
                            coordinatorVertexList.addAll(  
                                    getCommitterTask(edges, pipelineId, totalPipelineNum));  
  
                            List<PhysicalVertex> physicalVertexList =  
                                    getSourceTask(  
                                            edges, sources, pipelineId, totalPipelineNum);  
  
                            physicalVertexList.addAll(  
                                    getShuffleTask(edges, pipelineId, totalPipelineNum));  
  
                            CompletableFuture<PipelineStatus> pipelineFuture =  
                                    new CompletableFuture<>();  
                            waitForCompleteBySubPlanList.add(  
                                    new PassiveCompletableFuture<>(pipelineFuture));  
  
                            checkpointPlans.put(  
                                    pipelineId,  
                                    CheckpointPlan.builder()  
                                            .pipelineId(pipelineId)  
                                            .pipelineSubtasks(pipelineTasks)  
                                            .startingSubtasks(startingTasks)  
                                            .pipelineActions(pipeline.getActions())  
                                            .subtaskActions(subtaskActions)  
                                            .build());  
                            return new SubPlan(  
                                    pipelineId,  
                                    totalPipelineNum,  
                                    initializationTimestamp,  
                                    physicalVertexList,  
                                    coordinatorVertexList,  
                                    jobImmutableInformation,  
                                    executorService,  
                                    runningJobStateIMap,  
                                    runningJobStateTimestampsIMap,  
                                    tagFilter);  
                        });

这是将执行计划转换为物理计划时的相关代码，里面有这样4行代码。生成EnumeratorTask, CommitterTask将其添加到协调器任务列表中生成SourceTask，ShuffleTask将其添加到物理任务列表中。

SeaTunnel源码解析-(一)SeaTunnel API解析

Mon, 25 Nov 2024 00:00:00 +0000

从接口定义来看SeaTunnel

从官网的这个图中, 可以看到在SeaTunnel中, 定义了

Source
Transform
Sink 三种类型/算子

所以我想先从接口的定义上来看下SeaTunnel的设计理念.

SeaTunnelSource

SeaTunnelSource是数据读取的接口定义, 在这个接口中, 定义了如何从某个数据源中抽取数据.

public interface SeaTunnelSource<T, SplitT extends SourceSplit, StateT extends Serializable>  
        extends Serializable,  
                PluginIdentifierInterface,  
                SeaTunnelPluginLifeCycle,  
                SeaTunnelJobAware {  
    /** 
    * 返回当前Source的类型，是[有界批数据]还是[无界流数据]  
    */
    Boundedness getBoundedness();  
    /** 
    * 此方法后面将弃用
    * 后面将使用Catalog来表示数据，可以添加更多的元数据来描述数据
    */
    default SeaTunnelDataType<T> getProducedType() {  
        return (SeaTunnelDataType) getProducedCatalogTables().get(0).getSeaTunnelRowType();  
    }
      
    /** 
    * 当前SeaTunnel是支持多表读取的, 所以这里会返回一个list类型的结构
    * 每个catalog则是对读取的表的元数据信息
    */
    default List<CatalogTable> getProducedCatalogTables() {  
        throw new UnsupportedOperationException(  
                "getProducedCatalogTables method has not been implemented.");  
    }  

    /** 
    * 创建 Reader，Reader是真正去读取数据的类
    */ 
    SourceReader<T, SplitT> createReader(SourceReader.Context readerContext) throws Exception;  

	/**
	* 这两个方法是创建/恢复 SplitEnumerator
	*/
    SourceSplitEnumerator<SplitT, StateT> createEnumerator(  
            SourceSplitEnumerator.Context<SplitT> enumeratorContext) throws Exception;  
    SourceSplitEnumerator<SplitT, StateT> restoreEnumerator(  
            SourceSplitEnumerator.Context<SplitT> enumeratorContext, StateT checkpointState)  
            throws Exception;  

	/**
	* 这两个方法一般不会修改, 如果需要对Enumerator自定义序列化方式可以重写
	*/
    default Serializer<SplitT> getSplitSerializer() {  
        return new DefaultSerializer<>();  
    }
    default Serializer<StateT> getEnumeratorStateSerializer() {  
        return new DefaultSerializer<>();  
    }
      
}

从这个接口中可以看到有两个主要的方法

Spark内容整理

Sat, 20 Jan 2024 00:00:00 +0000

最近在换工作, 抽个时间把这几年所学的内容整理一下. 接触spark已经3年多的时间, 把之前写的一些文章进行一下综合性的整理.

Iceberg

Thu, 23 Nov 2023 00:00:00 +0000

前言

本文将记录一下iceberg表的文件存储结构, 数据写入流程, 查询流程的等. 基于Spark引擎.

准备工作

java8
spark binary
iceberg jar, 并放到spark binary的jars文件夹下由于在Spark 3.3之后才支持Time Travel功能，所以我们使用Spark 3.5并下载相应的iceberg-spark-runtime-3.5_2.12-1.4.2 jar包，放入到spark的jars文件夹下. iceberg的meta信息使用avro格式存储，我们可以使用这个命令来查看文件内容java -jar avro-tools-1.11.1.jar tojson xxx.avro

正式测试

创建Catalog

这里使用type=hadoop创建一个名为local的Catalog，文件存储位置为当前路径下的warehouse目录

./bin/spark-sql \
--conf spark.sql.extensions=org.apache.iceberg.spark.extensions.IcebergSparkSessionExtensions \
    --conf spark.sql.catalog.spark_catalog=org.apache.iceberg.spark.SparkSessionCatalog \
    --conf spark.sql.catalog.spark_catalog.type=hive \
    --conf spark.sql.catalog.local=org.apache.iceberg.spark.SparkCatalog \
    --conf spark.sql.catalog.local.type=hadoop \
    --conf spark.sql.catalog.local.warehouse=$PWD/warehouse

`1`	`CREATE TABLE local.db.tb01 (id bigint not null, name string, ts timestamp not null) USING iceberg PARTITIONED BY (year(ts))`

这张表中包含三个字段，设置了两个不能为空，并且分区字段通过ts这个字段计算而来。下面插入一些数据

A media platform base on web3, IPFS

Mon, 18 Sep 2023 00:00:00 +0000

Purpose

Now there has a lot of media company, but they won the data, means they can delete your video at any time and tell you: you broke some rules. So I am thinking about create a new platform base on block chain, IPFS. there is no admin, no one can delete your video.

Some Feature

People need save video first to earn some COIN. when they have earn enough COIN, they can upload and share their videos(The cost depends on the size of the data).
When people view your video, give Thumbs up, save, donate. the data saver, the data uploader can earn the COIN.
No administer.
The ownership is clear, you have the data ownership that you uploaded.
videos can’t be deleted after they are uploaded, not even by the author.

Shortcoming

How to avoid pornography, violence.

Reference

图像处理入门-基础概念

Mon, 11 Sep 2023 00:00:00 +0000

最近买了台相机, 出去拍了一些照片, 然后突然想到AI来做照片的处理,优化等. 所以找了一些课程来学习一下图像处理的基础知识. 目前从这些课程中学习: https://www.bilibili.com/video/BV1Kh411X7Qv?p=3 https://www.bilibili.com/video/BV1R84y1f79o?p=1 https://www.bilibili.com/video/BV1tT4y1Y7Ak/?spm_id_from=333.788&vd_source=f7b0753424ba1b445914c36a2cbf1439

基础概念

像素

一张图片在计算机中使用二维数组表示array[m][n]，二维数组的的大小m*n就表示照片的像素相同的照片尺寸下，一张图片的像素越高，则显示的细节越多。以这个照片为例，左侧图片的像素为2*2，右侧照片像素为4*4, 当放大某个细节时，右侧照片能给出更多的细节。

灰度值

二维数组中填充值的范围，对于黑白照片，灰度值的范围是0-255. 白色为255，黑色为0. array[m][n]=k, 0<=k<=255

直方图

查看图片中灰度值的分布情况，横坐标是灰度值，纵坐标表示该灰度值出现的频率。 要注意的是，一个照片只有一个直方图，但一个直方图并不对应唯一的一张照片

使用直方图可以直观的展示出图像中各个灰度值的分布情况，占比情况。

图像增强

灰度变换
代数运算
空间域滤波
频域滤波

灰度变换

简单，常用的空间域图像增强方法
对输入图像像素的灰度级进行变换 $s=f(r)$, r/s 输入/输出灰度级

f(): 灰度变换函数，这个函数可以是线性变换, 也可以是非线性变换.

线性变换

$s = Ar+B$ 当A>1时, 相当于做灰度拉伸, 变换完的图像会比原来的图片亮. 当A<1时, 相当于做灰度压缩, 变换完的图像会比原来的图片暗.

在线性变换中, 还可以进行分段线性变换 $$ s= \begin{cases} f1(x), \quad 0 <r<a \ f2(x), \quad a\leq r< b \ f3(r), \quad b\leq r< N \end{cases} $$

可以对感兴趣的灰度区域进行突出, 对不感兴趣的灰度区域进行抑制.

非线性变换

对数变换

$s = c * log(1+r)$ 在灰度级比较小(暗)时做拉伸, 在灰度值大(亮)时做压缩, 可以使暗的图像更加亮

LSM-Tree

Sun, 10 Sep 2023 00:00:00 +0000

写入流程：

先将记录写到WAL Log中（磁盘）
将数据写到内存中的MemTable，MemTable使用树或其他可以有序的结构进行存储
当Memtable数据满了，将MemTable变成Immutable Memtable即不可变数据，将这个数据落地，并新建Memtable来接收数据
在level0层，接收的是Immutable Memtable落地的数据块，这一层每个SSTable里数据有序，但整层是无序的，并且还可能重复
定时触发Campaction操作即将level0层的数据块合并，写到level1层，将level1层的数据块合并写到level2层。。。从level1层之后每一层的数据全局有序，唯一。每一层的数据块大小不一致，越往下容量越大

比特币与区块链

Sun, 06 Aug 2023 00:00:00 +0000

前段时间看了一个web3的视频, 对区块链有了兴趣, 想了解一下这是什么内容, 底层原理等. 看了一段时间的材料, 用这篇文章总结一下目前的看法. 推荐课程: 北京大学肖臻老师《区块链技术与应用》公开课, 这个课程感觉是目前对比特币技术原理讲的最清楚的一门课了.

Spark源码解析-(二)SparkContext

Sun, 30 Jul 2023 00:00:00 +0000

继上一篇分析完Spark的提交流程之后, 这次继续分析下SparkContext的源码.

创建

当Spark通过反射调用用户提交类的主函数时, 用户的主函数内会完成SparkContext的创建. 还是以JavaWordCount为例

public static void main(String[] args) throws Exception {  
  ...
  SparkSession spark = SparkSession  
    .builder()  
    .appName("JavaWordCount")  
    .getOrCreate();  
  
  JavaRDD<String> lines = spark.read().textFile(args[0]).javaRDD();  
	...  
  List<Tuple2<String, Integer>> output = counts.collect();  
  for (Tuple2<?,?> tuple : output) {  
    System.out.println(tuple._1() + ": " + tuple._2());  
  }  
  spark.stop();  
}

在这里是手动创建了SparkSession, SparkContext由SparkSession间接完成创建.

Spark源码解析-(一)提交流程

Sat, 22 Jul 2023 00:00:00 +0000

本文以Spark3.4版本，提交任务方式为Yarn Cluster，以JavaWordCount这个应用程序为例来分析一下一个Spark任务的提交过程。过程中会对代码做一些删减，主要目的是了解从用户提交任务开始到一个任务如何开始运行. 本文主要记录两种提交任务的方式，spark-submit.sh与SparkLauncher.

Spark-submit.sh

以需要执行JavaWordCount为例，启动命令为：

./bin/spark-submit \
--master yarn \
--deploy-mode cluster \
--class org.apache.spark.examples.JavaWordCount \
/path/to/examples.jar \
/tmp/file1.txt

我们指定了在yarn上以cluster模式启动JavaWordCount程序，指定了jar包位置，以及要读取的文件

spark-submit

1
2
3

......

exec "${SPARK_HOME}"/bin/spark-class org.apache.spark.deploy.SparkSubmit "$@"

这个脚本最后调用了spark-class脚本，第一个参数为SparkSubmit的全类名，再加上我们本来的参数

spark-class

这个脚本做了这几件事：

查找spark的jar包

# Find Spark jars.  
if [ -d "${SPARK_HOME}/jars" ]; then  
SPARK_JARS_DIR="${SPARK_HOME}/jars"  
else  
SPARK_JARS_DIR="${SPARK_HOME}/assembly/target/scala-$SPARK_SCALA_VERSION/jars"  
fi  
  
if [ ! -d "$SPARK_JARS_DIR" ] && [ -z "$SPARK_TESTING$SPARK_SQL_TESTING" ]; then  
echo "Failed to find Spark jars directory ($SPARK_JARS_DIR)." 1>&2  
echo "You need to build Spark with the target \"package\" before running this program." 1>&2  
exit 1  
else  
LAUNCH_CLASSPATH="$SPARK_JARS_DIR/*"  
fi  
  
# Add the launcher build dir to the classpath if requested.  
if [ -n "$SPARK_PREPEND_CLASSES" ]; then  
LAUNCH_CLASSPATH="${SPARK_HOME}/launcher/target/scala-$SPARK_SCALA_VERSION/classes:$LAUNCH_CLASSPATH"  
fi

调用SparkLauncher里面的Main进行参数注入

build_command() {  
"$RUNNER" -Xmx128m $SPARK_LAUNCHER_OPTS -cp "$LAUNCH_CLASSPATH" org.apache.spark.launcher.Main "$@"  
printf "%d\0" $?  
}

执行被修改过的命令

1
2

CMD=("${CMD[@]:0:$LAST}")  
exec "${CMD[@]}"

经过修改后最终的命令为：

Flink学习(一)

Sun, 04 Dec 2022 00:00:00 +0000

时间语义

Flink中的时间有三种:

事件时间 Event Time. 事件真实发生的时间.
摄入时间 Ingestion time. 事件接入到Flink系统的时间
处理时间 Processing Time. 事件到到当前算子的时间举一个夸张点的例子: 有一条记录, 它与11:00:00这个时间点产生. 我们的Flink系统在12:00:00这个时间点接入并进入第一个算子. 在Flink系统中又有很多个算子, 到达最后一个算子的时间为13:00:00. 那么在这种情况下: 事件时间是11:00:00. 这个是不会变的. 对于第一个算子而言, 这时的摄入时间和处理时间都为12:00:00. 对于最后一个算子而言, 这时这条时间的摄入时间为12:00:00. 处理时间为13:00:00

设置时间语义 我们需要在Job中设置执行时采用哪种时间语义.

env.setStreamTimeCharacteristic(TimeCharacteristic.EventTime);

env.setStreamTimeCharacteristic(TimeCharacteristic.ProcessingTime);

env.setStreamTimeCharacteristic(TimeCharacteristic.IngestionTime);

Processing Time & Ingestion Time

这两个时间都由Flink系统自己生成. Processing Time是由每个算子自己生成, 实现起来非常简单, 延迟也是最小的. 但是由于每个时间都是获取的当前算子的时钟, 时钟可能不一致, 并且由于集群中不同机器的执行性能不同, 每个算子也有一定的耗时, 对于第N个算子来说的相同Processing Time, 可能到第N+1个算子上就会有改变. 因此Processing Time在时间窗口下的计算会有不确定性. Ingestion Time是指事件到底Flink Source的时间. 一个事件在整个处理过程中都使用这个时间. 但是Ingestion Time也还是无法解决事件乱序问题.

这两个时间语义如果对事件进行重新消费, 也不能保证幂等性.

Event Time

事件时间是这个事件真实产生的时间, 发生时伴随其他信息一起写入到时间中. 但是由于在网络中的传输或其他问题, 可能导致事件到底Flink系统时发生乱序、迟到等现象. 真实情况中的数据大概如上图所示, 我们可以知道在Flink中进行处理的时间必然是大于等于事件发生的时间, 也就是事件都应该在这条红色虚线以下. 对于红色虚线上的点, 如上图的红色事件, 在12:10收到了12:20的事件, 这是一条未来的事件, 必须要对这条事件进行处理, 比如忽略或者对事件时间进行修改等, 不然会造成后续计算上的错误. 而对于蓝色的事件, 在12:10收到了11:50的事件, 这个事件是历史事件, 如果使用Flink作为批处理系统或者重置Offset后重刷历史, 这个都属于正常事件. 再来看一下事件时间发生在12:10的一系列事件, 它可以在12:10之后的任一时间到达Flink系统

ClickHouse-MergeTree引擎

Sun, 09 Oct 2022 00:00:00 +0000

数据存储格式

首先是分区目录，这个与Hive上的分区表一致。

一些基础文件：checksum.txt是校验文件，count.txt明文记录了这个分区下数据量，columns.txt明文记录了这个表的schema结构

然后是数据文件，ClickHouse采用了列式存储，而且是每一列都会有单独的文件，比如一个表有id,name两列，就会有id.bin, name.bin数据文件，mrk(mrk2) 列字段标记文件，存储了bin文件中数据的偏移量信息，使用二进制格式存储。

primary.idx索引文件，记录了索引与mrk2文件直接的关系，索引在内存也保存了一份，查询时不会使用磁盘上的文件（重启时需要加载到内存中）

分区规则

ClickHouse支持分区，但是与Hive中的分区有所不同。

对于不同的分区字段有不同的规则：

没有设置分区
- 这个时候所有数据存到一个文件夹下，文件名称为all
分区为数字类型
- 分区文件夹为数字
分区为时间类型
- 文件夹为yyyyMMdd 格式
分区为其他类型（比如字符串）
- 对值做哈希后，作为文件夹名称

分区命名规则

***PartitionId_MinBlockNum_MaxBlockNum_Level***

文件夹总体的名称分为4部分

PartitionId是根据字段真实值与上面的规则生成。
Level：这个文件夹被merge的的次数
BlockNum: 在一个表中这个值从1开始累加，每次新生成一个文件夹，这个文件夹的MinBlockNum和MaxBlockNum是相同的值（比如说1），然后这个值加1，第二次生成的文件夹MinBlockNum和MaxBlockNum变成了2，在后续的Merge过程中，两个文件夹merge时，会取两个文件夹中的最小和最大值来作为新文件夹的MinBlockNum和MaxBlockNum。

数据写入过程

来解释一下上面这个图

首先是表的定义，被写入的这个表定义了一个按月分区的分区规则 partition by toYYYYMM(dt)。

T1时刻，写入了两条数据，两条数据的月份不一致（5月，6月），所以会写到两个分区文件夹下
T2时刻，写入了三条数据。这三条数据中，两条分别与上一次T1时刻插入的月份一致（5月，6月），还有一条与之前不一致（7月）。这个时候与之前相同月份的数据还会新创建一个文件夹来保存数据，并不会合并到之前已经创建的分区文件夹中。
T3时刻，这个时候后台会将相同时间的文件夹进行合并，这个时候我们有5个文件夹，里面有2个5月，2个6月，1个7月。合并时分区文件夹的命名会进行改变。最后面的level表示这个文件夹被merge的次数，BlockNum会取被merge的两个文件夹中最大最小值。

数据文件的写入过程

刚刚是数据文件夹的写入过程，让我们从文件夹进入到文件，看一下里面的这些文件是如何生成的。

ClickHouse中数据是按列来进行存储的，并且是每一列都有单独的.bin文件.

在bin文件夹中数据是经过压缩后进行存储的，数据压缩不是将全部的数据进行整体压缩，而是将数据分块，对每一块进行单独的压缩。

每一个压缩块的大小在64KB到1MB之间

用这样的一个图来说明一下索引文件(primary.idx)，数据标记文件(mrk2)，数据文件直接的关系(bin)

表的定义：

create table merge_tree_test_table_v1 (
	seller_id UInt32,
	clicks UInt16,
	buyer_id UInt32,
	date DateTime
) Engine = MergeTree()
Order By (seller_id, buyer_id)
Partition By (date)
settings index_granularity=4096

我将这个表的索引粒度修改为4096，意味着4096条记录会作为一个单位来进行存储。

ClickHouse-ReplacingMergeTree

Sun, 09 Oct 2022 00:00:00 +0000

在MergeTree的写入过程中可以看到，ClickHouse无法保证主键的唯一性。

如果在数据写入时做主键校验，那么这个时候就需要维护一个主键的列表，然后每次写入时都需要进行判断，这样做的话就降低了吞吐量。

ClickHouse利用了MergeTree需要合并相同分区的特性，实现了在合并过程中进行主键校验的过程。

例子

CREATE TABLE table_001
(
    id UInt32,
    name String,
  	age UInt8
) ENGINE = ReplacingMergeTree()
ORDER BY id
PARTITION BY age

这个表定义主键为id，分区在age字段上。

写入两条初始化数据：insert into table_001 values(1,'name1',18),(2,'name2',18);

这两条数据属于相同分区，但是主键值不一样，我们这个时候进行查询，可以查询到这两条数据。

然后再写入一条分区相同id相同的数据insert into table_001 values(1,'name3',18);

当插入完成后进行查询时，还是可以看到这条数据，因为合并文件夹不是立即生效的，而当我们过一段时间后再去进行查询就会看到第一次写入的name1 这一行已经被替换掉了。我们也可以设置替换规则，来决定当遇到多条相同主键数据时的保留策略。

再来写一条不同分区下的相同id数据: insert into table_001 values(1,'name3',19);

这条记录的id与之前的重复了，但是它并不会替换之前的值，因为它们属于不同的分区下，在merge过程中并不会被merge到一起，不会触发替换的过程。

数据替换策略

ReplacingMergeTree的引擎定义中可以传递一个参数，这个参数的类型可以是UInt*，Date或者DateTime类型的字段。

DDL：

create table replace_table_v1(
	id String,
	code String,
	create_time DateTime
) Engine = ReplacingMergeTree(create_time)
Partition By toYYYYMM(create_time)
Order By id

当我们向这个表进行插入时，当遇到重复数据时，会保留create_time最大的那一条记录。

ClickHouse-ReplicatedMergeTree

Sun, 09 Oct 2022 00:00:00 +0000

ClickHouse的备份机制依赖于zookeeper来实现，并且只有MergeTree系列的表可以支持副本。

副本是表级别的，不是整个服务器级别的，所以在相同的服务器(cluster)上可以同时存在备份表和非备份表。

副本不依赖与分片，每个分片都有它自己的独立副本。

修改配置

如果要使用副本，需要在配置文件中设置zookeeper集群的地址。例如：

<zookeeper>
    <node index="1">
        <host>192.168.10.1</host>
        <port>2181</port>
    </node>
    <node index="2">
        <host>192.168.10.2</host>
        <port>2181</port>
    </node>
    <node index="3">
        <host>192.168.10.3</host>
        <port>2181</port>
    </node>
</zookeeper>

对于不同的机器，这个配置不相同。

<macros>
    <layer>05</layer>
    <shard>02</shard>
    <replica>example05-02-1.yandex.ru</replica>
</macros>

如果配置文件中没有设置zk，则无法创建复制表，并且任何现有的复制表都将变为只读。

在zk中存储元数据的路径是在创建表时指定的。

DDL

CREATE TABLE test_table
(
    EventDate DateTime,
    CounterID UInt32,
    UserID UInt32,
    ver UInt16
) ENGINE = ReplicatedReplacingMergeTree('/clickhouse/tables/{layer}-{shard}/test_table', '{replica}', ver)
PARTITION BY toYYYYMM(EventDate)
ORDER BY (CounterID, EventDate, intHash32(UserID))

Replicated*MergeTree的参数

ClickHouse-SummingMergeTree

Sun, 09 Oct 2022 00:00:00 +0000

假设有这样一种需求，用户只需要查询数据的汇总结果，不关心明细数据，并且数据汇总的维度都是明确的（GROUP BY条件明确，不会随意改变）

对于这样的查询场景，在ClickHouse中最直接的方法就是使用MergeTree引擎存储数据，然后每次查询通过GROUP BY聚合查询，利用SUM聚合函数汇总结果。

但是这样存在两个问题：

存在额外的存储开销：用户不关心明细数据，只关系汇总结果，而我们会一直存储明细数据
额外的查询开销：对于相同的查询，每次都需要走一遍聚合计算

SummingMergeTree引擎可以解决这样的应用场景，它可以按照预先定义的维度进行聚合汇总数据，将同一分组下的多行数据汇总合并成一行，这样即可以减少数据量，也可以减少后期查询的运算量。

在MergeTree的每个数据分区内，数据会按照ORDER BY表达式排序。主键索引也会按照PRIMARY KEY表达式取值并排序。而且ORDER BY可以替代主键。所以之前一直使用ORDER BY来定义主键。

如果同时需要定义ORDER BY与PRIMARY KEY，通常只有一种可能，就是明确希望ORDER BY与PRIMARY KEY不同，这种情况只会使用在SummingMergeTree与AggregatingMergeTree时才会出现。因为SummingMergeTree与AggregatingMergeTree都需要根据GROUP BY条件来进行预先聚合，这个时候使用来ORDER BY来定义GROUP BY的字段，所以需要使用PRIMARY KEY来修改主键的定义

示例：

假如我们有一个表，这里面有A，B，C，D，E，F。6个字段，当我们需要按照A，B，C，D字段进行汇总时，则设置为：ORDER BY(A, B, C, D)。但是在查询过程中，我们只会对A字段进行过滤，所以我们只需要对A字段设置主键，这样表的定义就变成了：

1
2

ORDER BY(A, B, C, D)
PRIMARY KEY(A)

如果同时声明PRIMARY KEY与ORDER BY，则需要PRIMARY KEY是ORDER BY的前缀

定义：

`1`	`ENGINE = SummingMergeTree((col1, col2, ...))`

col1, col2为columnar的参数值，这是选填参数，用于设置除主键外其他数值类型字段，以指定被SUM汇总的列字段。如果参数为空，则会将所有非主键的数值类型字段进行SUM汇总。

总结：

对ORDER BY中字段相同值的记录进行提前聚合。

ClickHouse安装与配置

Sun, 09 Oct 2022 00:00:00 +0000

安装

docker run -d --name clickhouse-server \\
 -p 8123:8123 -p 9000:9000 \\
 -v <CONFIG_PATH>:/etc/clickhouse-server/ \\
 -v <DATA_PATH>:/var/lib/clickhouse/ 
yandex/clickhouse-server

拉取并将Clickhouse的8123端口, 9000端口映射到本机.

Clickhouse的默认配置文件路径为/etc/clickhouse-server/ , 默认文件存储位置为/var/lib/clickhouse/

MySQL连接Clickhouse

Clickhouse默认开放了9004端口, mysql client可以通过这个端口查询Clickhouse的数据.

开启Tabix

在配置文件中, 将Tabix的注释打开.

1
2

<!-- 这里默认被注释掉, 打开后即可使用Tabix来进行查询 -->
<http_server_default_response><![CDATA[<html ng-app="SMI2"><head><base href="<http://ui.tabix.io/>"></head><body><div ui-view="" class="content-ui"></div><script src="<http://loader.tabix.io/master.js>"></script></body></html>]]></http_server_default_response>

设置分布式表

由于Clickhouse的分布式表依赖zookeeper, 所以需要先配置zookeeper.

<zookeeper-servers>  
	 <node index="1">  
	 <host>10.0.55.17</host>  
	 <port>2181</port>  
	 </node>  
	 <node index="2">  
	 <host>10.0.10.23</host>  
	 <port>2181</port>  
	 </node>  
	 <node index="3">  
	 <host>10.0.55.16</host>  
	 <port>2181</port>  
	 </node>   
 </zookeeper-servers>

集群配置

<remote_servers>
    <clusterA>
        <shard>
            <!-- Optional. Shard weight when writing data. Default: 1. -->
            <weight>1</weight>
            <!-- Optional. Whether to write data to just one of the replicas. Default: false (write data to all replicas). -->
            <internal_replication>false</internal_replication>
            <replica>
                <host>ip001</host>
                <port>9000</port>
            </replica>
            <replica>
                <host>ip002</host>
                <port>9000</port>
            </replica>
        </shard>
        <shard>
            <weight>2</weight>
            <internal_replication>false</internal_replication>
            <replica>
                <host>ip003</host>
                <port>9000</port>
            </replica>
            <replica>
                <host>ip004</host>
                <port>9440</port>
            </replica>
        </shard>
    </clusterA>

		<clusterB>
        <shard>
            <weight>1</weight>
            <internal_replication>false</internal_replication>
            <replica>
                <host>ip001</host>
                <port>9000</port>
            </replica>
        </shard>
        <shard>
            <weight>1</weight>
            <internal_replication>false</internal_replication>
            <replica>
                <host>ip002</host>
                <port>9000</port>
            </replica>
        </shard>
        <shard>
            <weight>1</weight>
            <internal_replication>false</internal_replication>
            <replica>
                <host>ip003</host>
                <port>9000</port>
            </replica>
        </shard>
        <shard>
            <weight>1</weight>
            <internal_replication>false</internal_replication>
            <replica>
                <host>ip004</host>
                <port>9000</port>
            </replica>
        </shard>		
		</clusterB>
</remote_servers>

配置的意思:

Clickhouse分布式表引擎

Sun, 09 Oct 2022 00:00:00 +0000

定义

在生产环境下, 对于大表经常需要对其分表, 将数据分别存储在不同的节点上. ClickHouse的Distribbuted表引擎做的就是这件事情.

ClickHouse中的分布式表并不存储数据, 只是做请求和写入的转发, 类似view的概念.

如何定义:

1
2
3

CREATE TABLE table_all ON CLUSTER clusterName (
    id UInt64
) ENGINE = Distributed(clusterName, databaseName, tableName[, sharding_key])

在定义时支持sharding_key的定义, 这样我们可以自定义数据的分布, 但是这个值必须是数值型, 可以自己是一个数值型字段, 也可以是某个函数的结果

支持的分片策略:

None

只能写入一个分片, 如果这个集群存在多个分区就会报错.
rand()

随机写入, 默认是轮循.
数值型字段
hash(字段)

或者业务方, 自己对数据进行切片后, 将数据写入到对应节点的本地表中. 不通过ClickHouse进行分发.

数据分发过程

由于ClickHouse是多主架构, 所以数据可以被写入任意节点. ClickHouse会在内部自己进行数据的分片划分.

从上图可以看出, ClickHouse内部进行了二次的数据分发, 不属于自己节点的数据会有两次的网络传输, 所以有很多时候使用方会进行自己对数据进行切分, 将数据写入到对应节点的本地表上. 从而提高性能.

Java中的锁

Thu, 01 Sep 2022 00:00:00 +0000

Java中的锁机制主要分为Synchronized和Lock

Synchronized

Synchronized在JVM里的实现是基于Monitor来实现的, Monitor是依赖与底层的操作系统Mutex Lock(互斥锁)来实现的线程同步.

synchronized用的锁是存在Java对象头里的.

JVM基于进入和退出Monitor对象来实现方法同步和代码块同步. 代码块同步是使用monitorenter和monitorexit指令实现的, monitorenter指令是在编译后插入到同步代码块的开始位置, 而monitorexit是插入到方法结束处和异常处.

任何对象都有一个monitor与之关联, 当且一个monitor被持有后,它将处于锁定状态.

根据虚拟机规范的要求, 在执行monitorenter指令时, 首先要去尝试获取对象的锁, 如果这个对象没被锁定, 或者当前线程已经拥有了那个对象的锁, 把锁的计数器加1. 相应地, 在执行monitorexit指令时会将锁计数器减1, 当计数器被减到0时, 锁就释放了. 如果获取对象锁失败了, 那当前线程就要阻塞等待,直到对象锁被另一个线程释放为止.

synchronized同步快对同一条线程来说是可重入的, 不会出现自己把自己锁死的问题
同步块在已进入的线程执行完之前, 会阻塞后面其他线程的进入.
可重入, 不可中断, 非公平锁

Lock

Lock底层是基于AQS(AbstractQueuedSynchronizer)的, AQS是用来构建锁或者其他同步组件的基础框架, 它使用来一个int成员变量表示同步状态, 通过内置的FIFO队列来完成资源获取线程的排队工作.

使用时必须手动进行上锁, 解锁.

Lock接口有多种实现, 比如ReentrantLock和ReadWriteLock.

Lock可以通过tryLock来获取是否可以获取锁的状态.

可重入, 可以选择是否公平锁
可以响应在等待锁时的中断

AQS

这个类中几个主要的变量:

status (保存当前的状态)
head/tail (保存队列) 主要的几个方法:
acquire(int)
release(int)
acquireShared(int)
releaseShared(int) 分别表示独占式的加锁与释放锁的方法共享锁的加速与释放锁的方法

乘积为正数的最长子数组长度-LeetCode1567

Fri, 15 Apr 2022 00:00:00 +0000

题目描述

链接: https://leetcode-cn.com/problems/maximum-length-of-subarray-with-positive-product/

给定一个整数数组nums, 求乘积为正数的最长子数组的长度

示例1:

输入: [1, -2, -3, 4]

输出: 4

数组本身乘积就是正数

示例2:

输入: [0, 1, -2, -3, -4]

输出: 3

最长乘积为整数的子数组为[1, -2, -3]

乘积最大子数组-LeetCode152

Fri, 15 Apr 2022 00:00:00 +0000

题目描述

链接: https://leetcode-cn.com/problems/maximum-product-subarray/

给你一个整数数组nums, 请你找出数组中成绩最大的非空连续子数组(该子数组中至少包含一个数字), 并返回该子数组所对应的乘积.

示例1:

输入: [2, 3, -2, 4]

输出: 6

子数组 [2, 3]得到最大乘积6

输入 [-2, 0 -,1]

输出: 0

环形子数组的最大和-LeetCode918

Thu, 14 Apr 2022 00:00:00 +0000

题目描述

链接: https://leetcode-cn.com/problems/maximum-sum-circular-subarray/

给定一个长度为n的环形整数数组nums, 返回nums的非空子数组的最大和

环形数组意味着数组的末端和头部是相连的, 所以子数组可以为数组的中间某一段或者首尾两段.

示例1:

输入: nums = [1, -1, 3, -2]

输出: 3

子数组 [3] 为最大和

示例2:

输入: nums = [5, -3, 5]

输出: 10

首尾的子数组[5, 5]得到最大和10

示例3:

输入: [3, -2, 2, -3]

输出: 3

从子数组[3], [3, -2, 2]都可以得到最大和3

跳跃游戏-LeetCode55

Thu, 14 Apr 2022 00:00:00 +0000

题目描述

链接: https://leetcode-cn.com/problems/jump-game/

给定一个非负整数数组nums, 你最初位于数组的第一个下标, 数组中的每个元素代表你在该位置可以跳跃的最大长度.

判断你是否能够到达最后一个下标

示例1:

输入: nums=[2, 3, 1, 1, 4]

输出: true

可以先从下标0走1步到下标1, 然后从下标1走3步到最后一个下标

示例2:

输入: nums = [3, 2, 1, 0, 4]

输出: false

无论怎么走, 都会走到下标3的位置, 到了这里无法在继续往前走. 所以不可能到达最后一个坐标

跳跃游戏2-LeetCode45

Thu, 14 Apr 2022 00:00:00 +0000

题目描述

链接: https://leetcode-cn.com/problems/jump-game-ii/

给定一个非负整数数组nums, 最初位于数组的第一个位置. 数组中的每个元素代表你在该位置上可以跳跃的最大长度.

你的目标是使用最少的跳跃次数到达数组的最后一个位置. 求最少需要跳跃几次, 假设总是可以到达数组的最后一个位置.

示例1:

输入: nums = [2, 3, 1, 1, 4]

输出: 2

从下标0跳到下标1, 再从下标1跳3步到最后一个位置. 总共跳跃2次

示例2:

输入: nums = [2, 3, 0, 1, 4]

输出: 2

最大子数组和-LeetCode53

Thu, 14 Apr 2022 00:00:00 +0000

题目描述

链接: https://leetcode-cn.com/problems/maximum-subarray/

给你一个整数数组nums, 请你找出一个具有最大和的连续子数组(子数组最少包含一个元素), 返回其最大和

子数组是数组中的一个连续部分

示例1:

输入: nums =[-2, 1, -3, 4, -1, 2, 1, -5, 4]

输出: 6

连续子数组 [4, -1, 2, 1]的和最大, 为6.

示例2:

输入: nums = [1]

输出: 1

示例3:

输入: nums = [5, 4, -1, 7, 8]

输出: 23

打家劫舍—LeetCode198

Wed, 13 Apr 2022 00:00:00 +0000

题目描述

链接: https://leetcode-cn.com/problems/house-robber/

你是一个专业的小偷, 计划偷窃沿街的房屋, 每间房内都藏有一定的现金, 影响你偷窃的唯一限制因素是相邻的房屋装有相互连通的防盗系统. 如果两间相邻的房屋在同一晚上被小偷闯入, 系统会自动报警.

给定一个代表每个访问存放金额的非负整数数组, 计算你在不触发警报装置的情况下, 一夜之内能够偷窃到的最高金额.

示例1:

输入: [1, 2, 3, 1]

输出: 4

偷窃1号和3号. 得到1+3 = 4.

示例2:

输入: [2, 7, 9, 3, 1]

输出: 12

偷窃1号, 3号和5号. 得到2+9+1 = 12.

打家劫舍2-LeetCode213

Wed, 13 Apr 2022 00:00:00 +0000

题目描述

链接: https://leetcode-cn.com/problems/house-robber-ii/

你是一个专业的小偷, 计划偷窃沿街的房屋, 每间房内都藏有一定的现金. 这个地方所有的房屋都围成一圈, 这意味着第一个房屋和最后一个房屋是紧挨着的. 同时, 相邻的房屋装有相互连通的防盗系统, 如果两间相邻的房屋在同一晚上被小偷闯入, 系统会自动报警 .

给定一个代表每个房屋存放金额的非负整数数组, 计算你在不触动警报装置的情况下,今晚能够偷窃到的最高金额.

示例1:

输入：nums = [2,3,2]

输出：3

你不能先偷窃 1 号房屋（金额 = 2），然后偷窃 3 号房屋（金额 = 2）, 因为他们是相邻的。

示例2:

输入：nums = [1,2,3,1]

输出：4

你可以先偷窃 1 号房屋（金额 = 1），然后偷窃 3 号房屋（金额 = 3）. 偷窃到的最高金额 = 1 + 3 = 4 .

翻转单词顺序-LeetCode58

Wed, 13 Apr 2022 00:00:00 +0000

题目描述

链接: https://leetcode-cn.com/problems/fan-zhuan-dan-ci-shun-xu-lcof/

输入一个英文句子, 翻转句子中单词的顺序, 但单词内字符的顺序不变. 标点符号和普通字母一样处理. 例如输入字符串"I am a student.", 输出应该为"student. a am I"

示例1:

输入 : “the sky is blue”

输出 : “blue is sky the”

示例2:

输入 : " hello world! "

输出 : “world! hello”

忽略字符串前后的空格

示例3:

输入: “a good example”

输出: “example good a”

如果两个单词间有多余的空格，将反转后单词间的空格减少到只含一个。

和为s的两个数组-LeetCode57

Wed, 13 Apr 2022 00:00:00 +0000

题目描述

链接: https://leetcode-cn.com/problems/he-wei-sde-liang-ge-shu-zi-lcof/

输入一个递增排序的数组和一个数字s, 在数组中查找两个数, 使得它们的和正好是s, 如果有多对数字的和都等于s, 则输出任意一对即可. 示例1: 输入：nums = [2,7,11,15], target = 9 输出：[2,7] 或者 [7,2]

示例2: 输入：nums = [10,26,30,31,47,60], target = 40 输出：[10,30] 或者 [30,10]

删除并获取点数-LeetCode740

Wed, 13 Apr 2022 00:00:00 +0000

题目描述

链接: https://leetcode-cn.com/problems/delete-and-earn/

给你一个整数数组nums, 可以对他进行一些操作. 每次操作中, 选择任意一个nums[i], 删除它然后获取nums[i]的点数. 同时还需要删除所有等于nums[i]-1和nums[i]+1的元素. 例如删除3, 那么得到3个点数, 同时需要在数组中删除所有的2和4.

开始时拥有0个点数, 求你能通过这些操作获取的最大点数.

示例1:

输入: nums = [3, 4, 2]

输出: 6

删除4和2.得到6点.

删除4获取4个点数, 同时3也被删除.

还剩下2, 然后删除2再得到2个点数.

示例2:

输入: nums = [2, 2, 3, 3, 3, 4]

输出: 9

删除3, 总共可以得到9个点数(3*3). 同时删除2和4.

最终得到9个点数.

使用最小花费爬楼梯-LeetCode746

Wed, 13 Apr 2022 00:00:00 +0000

题目描述

链接: https://leetcode-cn.com/problems/min-cost-climbing-stairs/

给定一个整数数组cost, 其中cost[i]表示从楼梯第i个台阶向上爬需要支付的费用. 每次只能向上爬一个或两个台阶.

可以从下标0或下标1的台阶开始爬楼梯.

求到达楼梯顶部的最低花费

示例1:

输入 cost = [10, 15, 20]

输出: 15

从下标1开始爬, 向上2格. 到达楼梯顶部.

示例2:

输入：cost = [1,100,1,1,1,100,1,1,100,1] 输出：6 你将从下标为 0 的台阶开始。

支付 1 ，向上爬两个台阶，到达下标为 2 的台阶。

支付 1 ，向上爬两个台阶，到达下标为 4 的台阶。

支付 1 ，向上爬两个台阶，到达下标为 6 的台阶。

支付 1 ，向上爬一个台阶，到达下标为 7 的台阶。

支付 1 ，向上爬两个台阶，到达下标为 9 的台阶。

支付 1 ，向上爬一个台阶，到达楼梯顶部。总花费为 6

Airflow调度系统

Sat, 09 Apr 2022 00:00:00 +0000

前言

我们组内使用Airflow来做日常的任务调度也有一年多的时间了, 今天写这篇文章来对Airflow进行一下记录.

组件

Airflow需要的几个基础组件为:

airflow-scheduler
airflow-webserver
airflow-worker
airflow-flower
mysql(也可以使用其他数据库)
redis(也可以使用其他消息队列)

前缀为airflow的是airflow的内部组件, 除此之外还需要数据库和一个消息队列

Spark-AQE

Fri, 01 Apr 2022 00:00:00 +0000

AQE(Adaptive query execution, 自适应查询引擎)引入了3个重要的特性:

自动分区合并
自动数据倾斜处理
Join策略调整

AQE默认是禁用的, 调整spark.sql.adaptive.enabled参数来进行开启

自动分区合并

在Shuffle过程中, 由于数据分布不均衡, 导致Reduce阶段存在大量的小分区, 这些小分区的数据量很小, 但是调度的成本很大, 我们希望可以将这些小文件合并成大文件, 从而提高性能.

那么现在的问题就变成了:

如何判断一个分区是不是小, 需不需要进行合并?
合并的终止条件是什么? 我们不能无终止的合并下去. 合并过程:
AQE按照分区编号从左到右进行扫描, 扫描时记录分区尺寸.
当相邻分区的尺寸之和大于目标尺寸时, AQE就把这些扫描过的分区进行合并
继续向右扫描, 采用相同的算法, 按照目标尺寸合并剩余分区, 直至所有分区都处理完毕

AQE事先并不判断哪些分区足够小, 而是按照分区编号进行扫描, 当扫描量超过目标尺寸时, 就合并一次

目标尺寸由两个配置项来共同决定

spark.sql.adaptive.advisoryPartitionSizeInBytes 开发者建议的目标尺寸
spark.sql.adaptive.coalescePartitions.minPartitionNum 合并之后最小的分区数

假设我们Shuffle过后的数据大小为20GB, minPartitionNum设置为200, 这时每个分区的尺寸应该是20GB/200=100MB, advisoryPartitionSizeInBytes设置为200MB. 最终的目标尺寸会选择(100MB, 200MB)的最小值, 也就是100MB. 所以这个目标尺寸是由两个参数来共同决定的

自动数据倾斜处理

在进行Join时, AQE检测到有数据倾斜时, 会自动进行拆分操作, 把大分区拆分为多个小分区, 从而避免单个任务的数据处理量过大. Spark3.0的AQE只能在Sort Merge Join中自动处理数据倾斜.

AQE如何判定数据分区是否倾斜, 以及它是如何进行大分区的拆分的:

处理倾斜的几个参数:

spark.sql.adaptive.skewJoin.skewedPartitionThresholdInBytes 判断数据分区是否倾斜的最低阈值, 默认是256MB
spark.sql.adaptive.skewJoin.skewedPartitionFactor 判定数据分区是否倾斜的比例系数, 默认值是5
spark.sql.adaptive.advisoryPartitionSizeInBytes 以字节为单位, 拆分倾斜分区的数据粒度

首先, 只有当分区的尺寸大于skewedPartitionThresholdInBytes时才有资格被判定为倾斜分区.

Spark-AQE

Fri, 01 Apr 2022 00:00:00 +0000

AQE(Adaptive query execution, 自适应查询引擎)引入了3个重要的特性:

自动分区合并
自动数据倾斜处理
Join策略调整

AQE默认是禁用的, 调整spark.sql.adaptive.enabled参数来进行开启

自动分区合并

那么现在的问题就变成了:

如何判断一个分区是不是小, 需不需要进行合并?
合并的终止条件是什么? 我们不能无终止的合并下去. 合并过程:
AQE按照分区编号从左到右进行扫描, 扫描时记录分区尺寸.
当相邻分区的尺寸之和大于目标尺寸时, AQE就把这些扫描过的分区进行合并
继续向右扫描, 采用相同的算法, 按照目标尺寸合并剩余分区, 直至所有分区都处理完毕

AQE事先并不判断哪些分区足够小, 而是按照分区编号进行扫描, 当扫描量超过目标尺寸时, 就合并一次

目标尺寸由两个配置项来共同决定

spark.sql.adaptive.advisoryPartitionSizeInBytes 开发者建议的目标尺寸
spark.sql.adaptive.coalescePartitions.minPartitionNum 合并之后最小的分区数

自动数据倾斜处理

AQE如何判定数据分区是否倾斜, 以及它是如何进行大分区的拆分的:

处理倾斜的几个参数:

spark.sql.adaptive.skewJoin.skewedPartitionThresholdInBytes 判断数据分区是否倾斜的最低阈值, 默认是256MB
spark.sql.adaptive.skewJoin.skewedPartitionFactor 判定数据分区是否倾斜的比例系数, 默认值是5
spark.sql.adaptive.advisoryPartitionSizeInBytes 以字节为单位, 拆分倾斜分区的数据粒度

首先, 只有当分区的尺寸大于skewedPartitionThresholdInBytes时才有资格被判定为倾斜分区.

Spark-Broadcast

Fri, 01 Apr 2022 00:00:00 +0000

广播变量

val dict = List(“spark”, “tune”)
val words = spark.sparkContext.textFile(“~/words.csv”)
val keywords = words.filter(word => dict.contains(word))
keywords.map((_, 1)).reduceByKey(_ + _).collect

这段代码中的dict变量会被分发到每个task中, 由于每个executor上会运行多个task, 这样就造成了在每个executor上的数据冗余, 并且网络分发也会有消耗, 影响性能.

我们可以将这个dict变量作为广播变量, 分发到每个executor上, 每个task都从executor上获取数据.

val dict = List(“spark”, “tune”)
val bc = spark.sparkContext.broadcast(dict)
val words = spark.sparkContext.textFile(“~/words.csv”)
val keywords = words.filter(word => bc.value.contains(word))
keywords.map((_, 1)).reduceByKey(_ + _).collect

在广播变量的运行机制下，封装成广播变量的数据，由 Driver 端以 Executors 为粒度分发，每一个 Executors 接收到广播变量之后，将其交给 BlockManager 管理

广播分布式数据集

在创建广播变量时, 由于变量的创建本来就在Driver上, 所以Driver直接把数据分发到各个Executor就可以了, 但是由于分布式数据集并不在Driver上, 它需要从各个Executor上拉取数据.

步骤为:

Driver从所有的Executor拉取这些数据分区, 在本地构建全量数据 — 目前spark有个pr是关于将Driver获取到数据分布, 然后通知各个Executor进行拉取, 避免只有Drvier组装以后再一个个发送效率过低
Driver把汇总好的全量数据分发给各个Executor, Executors 将接收到的全量数据缓存到存储系统的 BlockManager 中

相比于广播变量的创建, 广播分布式数据集的代价更大, 一是广播分布式数据需要Driver从各个Executor上拉取数据, 多了一步网络开销. 二是分布式数据的体量通常比广播变量大.

如何让Spark SQL选择Broadcast Joins

配置项

spark.sql.autoBroadcastJoinThreshold 默认值为10MB.

Spark-Broadcast

Fri, 01 Apr 2022 00:00:00 +0000

广播变量

val dict = List(“spark”, “tune”)
val words = spark.sparkContext.textFile(“~/words.csv”)
val keywords = words.filter(word => dict.contains(word))
keywords.map((_, 1)).reduceByKey(_ + _).collect

我们可以将这个dict变量作为广播变量, 分发到每个executor上, 每个task都从executor上获取数据.

val dict = List(“spark”, “tune”)
val bc = spark.sparkContext.broadcast(dict)
val words = spark.sparkContext.textFile(“~/words.csv”)
val keywords = words.filter(word => bc.value.contains(word))
keywords.map((_, 1)).reduceByKey(_ + _).collect

在广播变量的运行机制下，封装成广播变量的数据，由 Driver 端以 Executors 为粒度分发，每一个 Executors 接收到广播变量之后，将其交给 BlockManager 管理

广播分布式数据集

步骤为:

Driver从所有的Executor拉取这些数据分区, 在本地构建全量数据 — 目前spark有个pr是关于将Driver获取到数据分布, 然后通知各个Executor进行拉取, 避免只有Drvier组装以后再一个个发送效率过低
Driver把汇总好的全量数据分发给各个Executor, Executors 将接收到的全量数据缓存到存储系统的 BlockManager 中

如何让Spark SQL选择Broadcast Joins

配置项

spark.sql.autoBroadcastJoinThreshold 默认值为10MB.

Spark-Catalyst的优化过程

Fri, 01 Apr 2022 00:00:00 +0000

Spark SQL完整优化流程主要包含两个阶段: Catalyst优化器和Tungsten. 其中Catalyst优化器包含逻辑优化和物理优化两个阶段.

select name, age, sum(price * volume) revenue
from 
(
select * from tx
) tx
inner join 
(
select name, age, userId
from user 
where age < 30 and gender in ('M')
) user
on tx.userId = user.userId
group by 1,2
;

ANTLR4

在编写完SQL或DataFrame后, spark会先使用Antlr来生成逻辑计划树Unresolved Logical Plan

Spark-Catalyst的优化过程

Fri, 01 Apr 2022 00:00:00 +0000

Spark SQL完整优化流程主要包含两个阶段: Catalyst优化器和Tungsten. 其中Catalyst优化器包含逻辑优化和物理优化两个阶段.

select name, age, sum(price * volume) revenue
from 
(
select * from tx
) tx
inner join 
(
select name, age, userId
from user 
where age < 30 and gender in ('M')
) user
on tx.userId = user.userId
group by 1,2
;

ANTLR4

在编写完SQL或DataFrame后, spark会先使用Antlr来生成逻辑计划树Unresolved Logical Plan

Spark-DPP特性

Fri, 01 Apr 2022 00:00:00 +0000

DPP(Dynamic Partition Pruning, 动态分区剪裁)是Spark 3.0版本中第二个引人瞩目的特性, 它指的是在星型数仓的数据关联场景中, 可以充分利用过滤之后的维度表, 大幅削减事实表的数据扫描量, 从整体上提升关联计算的执行性能.

分区剪裁

对partition字段的过滤条件会只扫描符合条件的一类文件夹. 不会扫描全部的文件.

动态分区剪裁

将维度表中的结果发送到事实表中, 事实表根据这个子集做过滤, 从而减少数据扫描量, 提升I/O效率.

需要满足这三个条件才会触发动态分区剪裁

事实表必须是分区表, 而且分区字段(可以是多个)必须包含Join Key
仅支持等值Join, 对于不等值Join是不支持的.
维度表过滤之后的数据集要小于广播阈值

在对维度表过滤完之后, 会把这份数据封装为广播变量, 然后

发送给事实表中, 来减少事实表的数据扫描量.
发送给后续的Reduce Task来进行关联操作.

小结

没啥用, 因为需要限制Join Key为分区字段.

Spark-DPP特性

Fri, 01 Apr 2022 00:00:00 +0000

分区剪裁

对partition字段的过滤条件会只扫描符合条件的一类文件夹. 不会扫描全部的文件.

动态分区剪裁

将维度表中的结果发送到事实表中, 事实表根据这个子集做过滤, 从而减少数据扫描量, 提升I/O效率.

需要满足这三个条件才会触发动态分区剪裁

事实表必须是分区表, 而且分区字段(可以是多个)必须包含Join Key
仅支持等值Join, 对于不等值Join是不支持的.
维度表过滤之后的数据集要小于广播阈值

在对维度表过滤完之后, 会把这份数据封装为广播变量, 然后

发送给事实表中, 来减少事实表的数据扫描量.
发送给后续的Reduce Task来进行关联操作.

小结

没啥用, 因为需要限制Join Key为分区字段.

Spark-OOM诊断

Fri, 01 Apr 2022 00:00:00 +0000

有哪些位置会发生OOM

首先我们要明确OOM是发生在Driver端还是Executor.

如果在Executor上, 是在哪个区域.

Driver端的OOM

Driver的主要职责是任务调度, 同时参与非常少量的任务计算.

Driver端的内存并没有明细的划分, 是整体的一块. 所以OOM问题只可能来自它设计的计算任务, 主要有两类:

创建小规模的分布式数据集: 通过parallelize、createDataFrame等API创建数据集
收集计算结果: 通过take、show、collect等算子把结果收集到Driver端

所以Driver端的OOM只会有这两类原因:

创建的数据集超过内存上限
收集的结果集超过内存上限

第一类原因不言而喻就是我们创建的数据集太大, 这类错误可以明显的在代码中找到进行修改.

而对于第二类原因, 有很多是间接调用了collect从而导致的OOM. 这类错误在代码中就没有那么明确的可以找到.

比如说我们对一个数据集进行broadcast操作, 在这个过程中就需要Driver从每个Executor的数据分片上把部分数据拉取到Driver端来构建全量数据集. 所以这个时候如果总大小超过Driver端内存就会报出OOM错误. 这个时候在日志中可以看到这样的错误:

`1`	`java.lang.OutOfMemoryError: Not enough memory to build and broadcast`

如何修改配置

对于这两种情况, 都可以通过spark.driver.memory 配置项增大Driver的内存来避免OOM.

但是我们可以看下能否通过优化代码来解决这类问题

例如是否需要构建大数据量的数据集. 以及预估要广播变量的数据集大小, 从而可以更准确的调整内存大小

val df: DataFrame = _
df.cache.count
val plan = df.queryExecution.logical
val estimated: BigInt = spark
.sessionState
.executePlan(plan)
.optimizedPlan
.stats
.sizeInBytes

Executor端的OOM

Executor的内存主要分为4个区域:

Reserved Memory 大小固定为300MB, 这部分是spark系统自己使用的内存
Storage Memory 缓存内存区域, 数据集如果超过Storage Memory大小, 要么会直接抛弃(Memory_Only), 要么会缓存到磁盘(Memory_And_Disk)上
User Memory 存储用户自定义的数据结构
Execution Memory

我们可以看出Reserved Memory和Storage Memory是不会出现内存溢出的问题的. 如果在Executor端出现OOM那么只有可能出现在User Memory或者Execution Memory上.

Spark-OOM诊断

Fri, 01 Apr 2022 00:00:00 +0000

有哪些位置会发生OOM

首先我们要明确OOM是发生在Driver端还是Executor.

如果在Executor上, 是在哪个区域.

Driver端的OOM

Driver的主要职责是任务调度, 同时参与非常少量的任务计算.

Driver端的内存并没有明细的划分, 是整体的一块. 所以OOM问题只可能来自它设计的计算任务, 主要有两类:

创建小规模的分布式数据集: 通过parallelize、createDataFrame等API创建数据集
收集计算结果: 通过take、show、collect等算子把结果收集到Driver端

所以Driver端的OOM只会有这两类原因:

创建的数据集超过内存上限
收集的结果集超过内存上限

第一类原因不言而喻就是我们创建的数据集太大, 这类错误可以明显的在代码中找到进行修改.

而对于第二类原因, 有很多是间接调用了collect从而导致的OOM. 这类错误在代码中就没有那么明确的可以找到.

`1`	`java.lang.OutOfMemoryError: Not enough memory to build and broadcast`

如何修改配置

对于这两种情况, 都可以通过spark.driver.memory 配置项增大Driver的内存来避免OOM.

但是我们可以看下能否通过优化代码来解决这类问题

例如是否需要构建大数据量的数据集. 以及预估要广播变量的数据集大小, 从而可以更准确的调整内存大小

val df: DataFrame = _
df.cache.count
val plan = df.queryExecution.logical
val estimated: BigInt = spark
.sessionState
.executePlan(plan)
.optimizedPlan
.stats
.sizeInBytes

Executor端的OOM

Executor的内存主要分为4个区域:

Reserved Memory 大小固定为300MB, 这部分是spark系统自己使用的内存
Storage Memory 缓存内存区域, 数据集如果超过Storage Memory大小, 要么会直接抛弃(Memory_Only), 要么会缓存到磁盘(Memory_And_Disk)上
User Memory 存储用户自定义的数据结构
Execution Memory

我们可以看出Reserved Memory和Storage Memory是不会出现内存溢出的问题的. 如果在Executor端出现OOM那么只有可能出现在User Memory或者Execution Memory上.

Spark-Shuffle过程

Fri, 01 Apr 2022 00:00:00 +0000

Map阶段的输出是什么

Map阶段最终生成的数据会以中间文件的形式物化到磁盘中, 这些文件存储在spark.local.dir设置的文件目录中. 中间文件包含两种类型:

后缀为data的数据文件

存储的内容是Map阶段生成的待分发数据
后缀为index的索引文件

记录的是数据文件中不同分区(Reduce阶段的分区)的偏移地址. 分区数量与Reduce阶段的并行度保持一致.

Map阶段的每个Task都会生成这样的一组文件, 因此中间文件的数量与Map阶段的并行度保持一致.

数据生成过程

计算目标分区

在Spark中, 每条数据的分区是由Key的哈希值决定的

写入缓存区或溢写到文件

GroupByKey的实现

计算完目标分区后, Map Task会把每条记录和它的目标分区, 放到一个特殊的数据结构PartitionedPairBuffer里, 这个数据结构本质上是一个数组形式的缓存结构.

每条数据都会占用数组中相邻的两个元素空间, 第一个元素存储(目标分区, Key), 第二个元素存储值.

这个数组的长度不可能无限大来存储所有Map端的元素. 所以Spark有一种机制, 来保障在数据总量超过可用内存的情况下, 依然能够完成计算. 这种机制就是: 排序、溢出、归并.

举个例子:

假如我们的PartitionedPairBuffer 的数组长度为8, 也就是说可以存储4个元素. 而我们的Map端共有16个元素, 那么就会需要4批才能完成计算. 在处理第二批的数据时, Spark会将第一批的数据溢写到磁盘的临时文件上.

在溢写时, 会对PartitionedPairBuffer 中已有的数据, 按照目标分区以及Key进行排序后再进行写入, 所以临时文件中的数据是有序的.

在处理第四批的时, 这时已经是最后一批, 所以这次不再需要溢写到临时文件. 现在的数据分布在3个临时文件中, 还有缓存在PartitionedPairBuffer中.

最后, 会从这两个输入源中(临时文件, 缓存区)生成最终的数据文件和索引文件. 并且由于每个文件都是有序的, 所以在合并时使用了归并算法.

主要步骤为:

对于分片中的数据记录, 逐一计算其目标分区, 并将其填充到PartitionedPairBuffer
PartitionedPairBuffer 填满后, 如果后续还有未处理的数据, 则对Buffer中的数据按(Partition ID, Key)进行排序, 将Buffer中的文件溢出到临时文件, 同时清空缓存区
重复步骤1, 2. 直到分片内的所有数据都被处理
对所有临时文件和PartitionedPairBuffer归并排序, 最终生成数据文件和索引文件

ReduceByKey

ReduceByKey的计算步骤与GroupByKey的一样, 都是先填充内存数据结构, 然后排序溢出, 最后归并排序.

Spark-Shuffle过程

Fri, 01 Apr 2022 00:00:00 +0000

Map阶段的输出是什么

Map阶段最终生成的数据会以中间文件的形式物化到磁盘中, 这些文件存储在spark.local.dir设置的文件目录中. 中间文件包含两种类型:

后缀为data的数据文件

存储的内容是Map阶段生成的待分发数据
后缀为index的索引文件

记录的是数据文件中不同分区(Reduce阶段的分区)的偏移地址. 分区数量与Reduce阶段的并行度保持一致.

Map阶段的每个Task都会生成这样的一组文件, 因此中间文件的数量与Map阶段的并行度保持一致.

数据生成过程

计算目标分区

在Spark中, 每条数据的分区是由Key的哈希值决定的

写入缓存区或溢写到文件

GroupByKey的实现

计算完目标分区后, Map Task会把每条记录和它的目标分区, 放到一个特殊的数据结构PartitionedPairBuffer里, 这个数据结构本质上是一个数组形式的缓存结构.

每条数据都会占用数组中相邻的两个元素空间, 第一个元素存储(目标分区, Key), 第二个元素存储值.

举个例子:

在溢写时, 会对PartitionedPairBuffer 中已有的数据, 按照目标分区以及Key进行排序后再进行写入, 所以临时文件中的数据是有序的.

在处理第四批的时, 这时已经是最后一批, 所以这次不再需要溢写到临时文件. 现在的数据分布在3个临时文件中, 还有缓存在PartitionedPairBuffer中.

最后, 会从这两个输入源中(临时文件, 缓存区)生成最终的数据文件和索引文件. 并且由于每个文件都是有序的, 所以在合并时使用了归并算法.

主要步骤为:

对于分片中的数据记录, 逐一计算其目标分区, 并将其填充到PartitionedPairBuffer
PartitionedPairBuffer 填满后, 如果后续还有未处理的数据, 则对Buffer中的数据按(Partition ID, Key)进行排序, 将Buffer中的文件溢出到临时文件, 同时清空缓存区
重复步骤1, 2. 直到分片内的所有数据都被处理
对所有临时文件和PartitionedPairBuffer归并排序, 最终生成数据文件和索引文件

ReduceByKey

ReduceByKey的计算步骤与GroupByKey的一样, 都是先填充内存数据结构, 然后排序溢出, 最后归并排序.

Spark-Tungsten

Fri, 01 Apr 2022 00:00:00 +0000

在Spark SQL中, Catalyst优化器负责把查询语句最终转换为可以执行的Physical Plan.

Spark在Physical Plan的基础上还会再利用Tungsten(钨丝计划)进行一次优化

Tungsten主要围绕内核引擎做了两方面的改进:

数据结构设计
全阶段代码生成(WSCG, Whole Stage Code Generation)

Tungsten在数据结构方面的设计

相比Spark Core, Tungsten在数据结构方面做了两个较大的改进, 一个是紧凑的二进制格式Unsafe Row, 另一个是内存管理.

Unsafe Row: 二进制数据结构

Unsafe Row是一种字节数组, 它可以用来存储下图所示Schema为(userId, name, age, gender)的用户数据条目总的来说, 所有字段都会按照Schema中的顺序安放在数组中. 其中, 定长字段的值会直接安插到字节中, 而变长字段会先在Schema的相应位置插入偏移地址, 再把字段长度和字段值存储到靠后的元素中.

优点:

节省存储空间

使用JVM的对象存储时, 有对象头信息, 哈希码等其他额外的开销.

降低对象数量, 提高垃圾回收效率

以JVM的对象存储, 每条记录都需要创建一个对象, 这样会造成频繁GC, 降低了系统性能

UnsafeRow以字节数组的存储方式来消除存储开销, 并且仅用一个数组对象就完成来一条数据的封装, 显著降低了GC压力

基于内存页的内存管理???

为了统计管理Off Head和On Heap内存空间, Tungsten定义了统一的128位内存地址, 简称Tungsten地址.

Tungsten地址分为两部分: 前64位预留给Java Object, 后64位是偏移地址Offset.

虽然Off Heap和On Heap都是128位内存地址, 但是Off Heap和On Heap两块内存空间在寻址方式上截然不同.

对于On Heap空间的Tungsten地址来说, 前64位存储的是JVM堆内对象的引用或者说指针, 后64位Offset存储的是数据在该对象内的偏移地址. — 有指针不就找到对象了吗? 为什么还加一个数据的偏移地址.

Spark-Tungsten

Fri, 01 Apr 2022 00:00:00 +0000

在Spark SQL中, Catalyst优化器负责把查询语句最终转换为可以执行的Physical Plan.

Spark在Physical Plan的基础上还会再利用Tungsten(钨丝计划)进行一次优化

Tungsten主要围绕内核引擎做了两方面的改进:

数据结构设计
全阶段代码生成(WSCG, Whole Stage Code Generation)

Tungsten在数据结构方面的设计

相比Spark Core, Tungsten在数据结构方面做了两个较大的改进, 一个是紧凑的二进制格式Unsafe Row, 另一个是内存管理.

Unsafe Row: 二进制数据结构

优点:

节省存储空间

使用JVM的对象存储时, 有对象头信息, 哈希码等其他额外的开销.

降低对象数量, 提高垃圾回收效率

以JVM的对象存储, 每条记录都需要创建一个对象, 这样会造成频繁GC, 降低了系统性能

UnsafeRow以字节数组的存储方式来消除存储开销, 并且仅用一个数组对象就完成来一条数据的封装, 显著降低了GC压力

基于内存页的内存管理???

为了统计管理Off Head和On Heap内存空间, Tungsten定义了统一的128位内存地址, 简称Tungsten地址.

Tungsten地址分为两部分: 前64位预留给Java Object, 后64位是偏移地址Offset.

虽然Off Heap和On Heap都是128位内存地址, 但是Off Heap和On Heap两块内存空间在寻址方式上截然不同.

Spark-避免Cache滥用

Fri, 01 Apr 2022 00:00:00 +0000

不同的缓存级别

Spark的cache支持多种缓存级别, 比如MEMORY_AND_DISC_SER_2、MEMORY_ONLY等等. 这些值是这几部分构成的:

存储介质: 内存还是磁盘, 还是两者都有
存储形式: 存储对象值还是序列化的字节数组, 带SER字样的表示以序列化方式存储, 不带SER表示采用对象值
副本数量: 拷贝数量, 没有数字默认为1份副本

Spark对RDD.cache函数默认使用MEMORY_ONLY, 对DataFrame.cache默认使用MEMORY_AND_DISK.

缓存的计算过程

在MEMORY_AND_DISK模式下, Spark会优先尝试把数据集全部缓存到内存, 内存不足的情况下, 再把剩余的数据落盘到本地.

MEMORY_ONLY则不管内存是否充足, 一股脑的把数据缓存到内存.

无论是RDD还是DataFrame, 它们的数据分片都是以迭代器Iterator的形式存储的. 因此, 要把数据缓存下来, 就要把迭代器展开成实实在在的数据值, 这一步叫做Unroll.
展开的对象暂存在一个叫做ValuesHolder的数据结构里, 然后转化为MemoryEntry. 这里转化的实现方式是toArray, 因此它不产生额外的内存开销, 这一步叫做Transfer.
最终, MemoryEntry和与之对应的BlockID, 以K, V的形式存储到哈希字典(LinkedHashMap)中

当分布式数据集所有的数据分片都从Unroll到Transfer, 再到注册哈希字典后, 数据在内存的缓存过程就结束了

缓存的销毁过程

将数据缓存进内存时, 如果发现内存不足, 则需要根据LRU算法来驱逐(Eviction)一些数据分片

由于Spark在存储MemoryEntry时使用了LinkedHashMap的数据结构, 所有可以很容易的找到最近最少使用的Block(链表头部).

Spark当试图缓存一个数据分片, 却发现可用内存不足时, 会对LinkedHashMap从头扫描, 当扫描过的MemoryEntry尺寸之和大于要写入的数据分片时, 将这些数据给删除掉.

在进行缓存清楚时, 同属一个RDD的MemoryEntry不会被选中

在缓存清除的过程中, Spark遵循两个基本原则

LRU, 按照元素的访问顺序, 优先清除那些“最近最少访问”的MemoryEntry
同属一个RDD的MemoryEntry不会被清除

数据丢失

在Memory_Only的模式下, 尽管有缓存销毁这个环境, 但是总会“驱无可驱”, 这个时候, Memory_Only就会放弃剩余的数据分片, 造成数据丢失.

Cache的注意事项

cache是惰性操作, 在调用cache只会, 需要用Action算子触发缓存的物化过程.

Spark-避免Cache滥用

Fri, 01 Apr 2022 00:00:00 +0000

不同的缓存级别

Spark的cache支持多种缓存级别, 比如MEMORY_AND_DISC_SER_2、MEMORY_ONLY等等. 这些值是这几部分构成的:

存储介质: 内存还是磁盘, 还是两者都有
存储形式: 存储对象值还是序列化的字节数组, 带SER字样的表示以序列化方式存储, 不带SER表示采用对象值
副本数量: 拷贝数量, 没有数字默认为1份副本

Spark对RDD.cache函数默认使用MEMORY_ONLY, 对DataFrame.cache默认使用MEMORY_AND_DISK.

缓存的计算过程

在MEMORY_AND_DISK模式下, Spark会优先尝试把数据集全部缓存到内存, 内存不足的情况下, 再把剩余的数据落盘到本地.

MEMORY_ONLY则不管内存是否充足, 一股脑的把数据缓存到内存.

无论是RDD还是DataFrame, 它们的数据分片都是以迭代器Iterator的形式存储的. 因此, 要把数据缓存下来, 就要把迭代器展开成实实在在的数据值, 这一步叫做Unroll.
展开的对象暂存在一个叫做ValuesHolder的数据结构里, 然后转化为MemoryEntry. 这里转化的实现方式是toArray, 因此它不产生额外的内存开销, 这一步叫做Transfer.
最终, MemoryEntry和与之对应的BlockID, 以K, V的形式存储到哈希字典(LinkedHashMap)中

当分布式数据集所有的数据分片都从Unroll到Transfer, 再到注册哈希字典后, 数据在内存的缓存过程就结束了

缓存的销毁过程

将数据缓存进内存时, 如果发现内存不足, 则需要根据LRU算法来驱逐(Eviction)一些数据分片

由于Spark在存储MemoryEntry时使用了LinkedHashMap的数据结构, 所有可以很容易的找到最近最少使用的Block(链表头部).

在进行缓存清楚时, 同属一个RDD的MemoryEntry不会被选中

在缓存清除的过程中, Spark遵循两个基本原则

LRU, 按照元素的访问顺序, 优先清除那些“最近最少访问”的MemoryEntry
同属一个RDD的MemoryEntry不会被清除

数据丢失

在Memory_Only的模式下, 尽管有缓存销毁这个环境, 但是总会“驱无可驱”, 这个时候, Memory_Only就会放弃剩余的数据分片, 造成数据丢失.

Cache的注意事项

cache是惰性操作, 在调用cache只会, 需要用Action算子触发缓存的物化过程.

Spark-参数配置

Fri, 01 Apr 2022 00:00:00 +0000

https://spark.apache.org/docs/latest/configuration.html

Spark-参数配置

Fri, 01 Apr 2022 00:00:00 +0000

https://spark.apache.org/docs/latest/configuration.html

Spark-配置项

Fri, 01 Apr 2022 00:00:00 +0000

内存相关配置项设置并行度, 并行度用spark.default.parallelism和spark.sql.shuffle.partitions 两个参数确定.

对于没有明确分区规则的RDD, 使用spark.default.parallelism来定义并行度
对于数据关联或聚合操作中可以使用spark.sql.shuffle.partitions来指定Reduce端的分区数量

什么是并行度: 指的是分布式数据集被划分为多少份, 从而用于分布式计算. 并行度的出发点是数据, 它明确了数据划分的粒度. 并行度越高, 数据的粒度越细, 数据分片越多, 数据越分散.

并行计算任务: 指的是在任意时刻整个集群能够同时计算的任务数量. 并行计算任务的出发点是计算任务, 是CPU. 由CPU有关的三个参数共同决定. — 具体说来，Executor 中并行计算任务数的上限是 spark.executor.cores 与 spark.task.cpus 的商，暂且记为 #Executor-tasks，整个集群的并行计算任务数自然就是 #Executor-tasks 乘以集群内 Executors 的数量，记为 #Executors。因此，最终的数值是：#Executor-tasks * #Executors。

并行度决定了数据粒度, 数据粒度决定了分区大小, 分区大小决定每个计算任务的内存消耗.

CPU相关配置项

CPU的配置项主要包括 spark.cores.max、spark.executor.cores 和 spark.task.cpus 这三个参数.

spark.cores.max — 限制整个job可以申请到的最大CPU数量, 当不设置时默认使用spark.deploy.defaultCores这个参数(默认为Integer.MAX_VALUE, 也就是不限制)
spark.executor.cores — 设置单个executor可以使用的CPU资源, executor的数量可以通过($spark.cores.max / spark.executor.cores$)来确定
spark.task.cpus — 设置单个task消耗的CPU核数, 一个executor上并行执行的task数量可以通过($spark.executor.cores / spark.task.cpus$)来确定

内存相关配置项

Spark管理的内存分为堆内内存和堆外内存.

堆外内存又分为两个区域, Execution Memory和Storage Memory. 要想启用堆外内存, 需要将参数spark.memory.offHeap.enabled设置为true .然后再用spark.memory.offHeap.size 参数来指定堆外内存的大小

Spark-配置项

Fri, 01 Apr 2022 00:00:00 +0000

内存相关配置项设置并行度, 并行度用spark.default.parallelism和spark.sql.shuffle.partitions 两个参数确定.

对于没有明确分区规则的RDD, 使用spark.default.parallelism来定义并行度
对于数据关联或聚合操作中可以使用spark.sql.shuffle.partitions来指定Reduce端的分区数量

并行度决定了数据粒度, 数据粒度决定了分区大小, 分区大小决定每个计算任务的内存消耗.

CPU相关配置项

CPU的配置项主要包括 spark.cores.max、spark.executor.cores 和 spark.task.cpus 这三个参数.

spark.cores.max — 限制整个job可以申请到的最大CPU数量, 当不设置时默认使用spark.deploy.defaultCores这个参数(默认为Integer.MAX_VALUE, 也就是不限制)
spark.executor.cores — 设置单个executor可以使用的CPU资源, executor的数量可以通过($spark.cores.max / spark.executor.cores$)来确定
spark.task.cpus — 设置单个task消耗的CPU核数, 一个executor上并行执行的task数量可以通过($spark.executor.cores / spark.task.cpus$)来确定

内存相关配置项

Spark管理的内存分为堆内内存和堆外内存.

Spark-如何高效利用CPU

Fri, 01 Apr 2022 00:00:00 +0000

执行内存抢占规则，

在同一个 Executor 中，当有多个（记为 N）线程尝试抢占执行内存时，需要遵循 2 条基本原则

执行内存总大小（记为 M）为两部分之和，一部分是 Execution Memory 初始大小，另一部分是 Storage Memory 剩余空间
每个线程分到的可用内存有一定的上下限，下限是 M/N/2，上限是 M/N，也就是均值

并行度、并发度与执行内存的关系

并行度

明确了数据的划分粒度, 并行度越高, 数据的粒度越细, 数据分片越多, 数据越分散.

并行度可以通过两个参数来设置: 分别是 spark.default.parallelism 和 spark.sql.shuffle.partitions. 前者用于设置 RDD 的默认并行度, 后者在 Spark SQL 开发框架下, 指定了 Shuffle Reduce 阶段默认的并行度.

并发度

****一个Executor内部可以同时运行的最大任务数量.

由Executor的线程池大小(spark.executor.cores)除以每个任务执行期间需要消耗的线程数(spark.task.cpus)得到. spark.task.cpus默认是1, 通常不会调整, 所以并发度基本由spark.executor.cores参数决定

就Executor的线程池来说, 尽管线程本身可以复用, 但每个线程同一时间只能计算一个任务, 每个任务负责处理一个数据分片. 因此, 在运行时, 线程、任务与分区是一一对应的关系.

分布式任务由Driver分发给Executor后, Executor将Task封装为TaskRunner, 然后将其交给可回收缓存线程池(newCachedThreadPool). 线程池中的线程领取到TaskRunner之后, 向Execution Memory申请内存, 开始执行任务.

执行内存

堆内执行内存的初始值:

spark.executor.memory * spark.memory.fraction * (1- spark.memory.storageFraction)

executor的内存 * 执行内存和缓存内存占总内存系数 * (1-缓存内存系数)

Spark-如何高效利用CPU

Fri, 01 Apr 2022 00:00:00 +0000

执行内存抢占规则，

在同一个 Executor 中，当有多个（记为 N）线程尝试抢占执行内存时，需要遵循 2 条基本原则

执行内存总大小（记为 M）为两部分之和，一部分是 Execution Memory 初始大小，另一部分是 Storage Memory 剩余空间
每个线程分到的可用内存有一定的上下限，下限是 M/N/2，上限是 M/N，也就是均值

并行度、并发度与执行内存的关系

并行度

明确了数据的划分粒度, 并行度越高, 数据的粒度越细, 数据分片越多, 数据越分散.

并发度

****一个Executor内部可以同时运行的最大任务数量.

执行内存

堆内执行内存的初始值:

spark.executor.memory * spark.memory.fraction * (1- spark.memory.storageFraction)

executor的内存 * 执行内存和缓存内存占总内存系数 * (1-缓存内存系数)

Spark-如何选择Join策略

Fri, 01 Apr 2022 00:00:00 +0000

Spark支持多种Join形式:

Inner Join 内连接, 取相同的部分
Left Join 左连接, 左表为主
Right Join 右连接
Anti Join 剔除可以和右表Join上的左表部分. 相当于not in.
Semi Join 相当于In

到目前为止, 数据关联总共有3中Join的实现方式, 分别是:

嵌套循环连接(NLJ, Nested Loop Join)
排序归并连接(SMJ, Shuffle Sort Merge Join)
哈希连接(HJ, Hash Join)

NLJ的工作原理:

使用两层循环, 将体量较大的表做外层循环, 体量较小的表做内层循环

NLJ的计算复杂度为O(M*N).

SMJ的工作原理

SMJ的思路是先排序, 再归并. 两张表先根据Join Key做排序, 然后使用两个游标对排好序的表进行归并关联.

SMJ的计算复杂度为O(M+N), 但是这个是依赖与排好序的基础上.

HJ的工作原理

将内表扫描的复杂度降至O(1).

首先将内表基于既定的哈希函数构建哈希表, 然后外表扫描时使用相同的哈希函数去哈希表中查找.

所以总体的复杂度为O(M)

分布式环境下的Join

分布式环境中的数据关联在计算环境依然遵循着NLJ, SMJ和HJ这三种实现方式, 只不过是增加了网络分发这一变数.

在Spark的分布式计算环境中, 数据在网络中的分发主要有两种形式, 分别是Shuffle和广播.

如果使用Shuffle的方式来完成分发, 那么外表和内表都需要按照Join Key在集群中做全量的数据分发.

如果采用广播机制的话, Spark只需要将内表封装到广播变量, 然后在全网进行分发.

结合Shuffle、广播这两种网络分发形式和NLJ, SMJ, HJ这三种计算方式, 对于分布式环境下的数据关联, 组合起来可以有6种Join策略, 分别是:

Spark-如何选择Join策略

Fri, 01 Apr 2022 00:00:00 +0000

Spark支持多种Join形式:

Inner Join 内连接, 取相同的部分
Left Join 左连接, 左表为主
Right Join 右连接
Anti Join 剔除可以和右表Join上的左表部分. 相当于not in.
Semi Join 相当于In

到目前为止, 数据关联总共有3中Join的实现方式, 分别是:

嵌套循环连接(NLJ, Nested Loop Join)
排序归并连接(SMJ, Shuffle Sort Merge Join)
哈希连接(HJ, Hash Join)

NLJ的工作原理:

使用两层循环, 将体量较大的表做外层循环, 体量较小的表做内层循环

NLJ的计算复杂度为O(M*N).

SMJ的工作原理

SMJ的思路是先排序, 再归并. 两张表先根据Join Key做排序, 然后使用两个游标对排好序的表进行归并关联.

SMJ的计算复杂度为O(M+N), 但是这个是依赖与排好序的基础上.

HJ的工作原理

将内表扫描的复杂度降至O(1).

首先将内表基于既定的哈希函数构建哈希表, 然后外表扫描时使用相同的哈希函数去哈希表中查找.

所以总体的复杂度为O(M)

分布式环境下的Join

分布式环境中的数据关联在计算环境依然遵循着NLJ, SMJ和HJ这三种实现方式, 只不过是增加了网络分发这一变数.

在Spark的分布式计算环境中, 数据在网络中的分发主要有两种形式, 分别是Shuffle和广播.

如果使用Shuffle的方式来完成分发, 那么外表和内表都需要按照Join Key在集群中做全量的数据分发.

如果采用广播机制的话, Spark只需要将内表封装到广播变量, 然后在全网进行分发.

结合Shuffle、广播这两种网络分发形式和NLJ, SMJ, HJ这三种计算方式, 对于分布式环境下的数据关联, 组合起来可以有6种Join策略, 分别是:

Spark-怎么用好AQE的三个特性

Fri, 01 Apr 2022 00:00:00 +0000

在2.0版本之前, Spark SQL仅仅支持启发式、静态的优化过程, 启发式的优化又叫RBO(Rule Based Optimization, 基于规则的优化), 它基于一些规则和策略实现, 如谓词下推、列剪枝. 这些规则和策略来源于数据库领域已有的应用经验. 启发式的优化是一种经验主义.

经验主义的弊端是对待相似的问题和场景都使用同一种套路.

在2.2版本中推出了CBO(Cost Based Optimization, 基于成本的优化), 特点是“实事求是”, 基于数据表的统计信息(如表大小、数据列分布)来选择优化策略. CBO支持的统计信息很丰富, 比如数据表的行数、每列的基数(Cardinality)、空间值、最大值、最小值和直方图等等. 因为有统计数据做支持, 所以CBO选择的优化策略往往优于RBO选择的优化规则.

但是CBO也有三个方面的缺点: 窄、慢、静.

窄 : 指的是适用面太窄, CBO仅支持注册到Hive Metastore的数据表
慢: 指的是统计信息的搜集效率比较低. 对于注册到Hive Metastore的数据表, 开发者需要调用ANALYZE TABLE COMPUTE STATISTICS语句收集统计信息, 而各类信息的收集会消耗大量时间
静: 指的是静态优化, 这一点与RBO一样, CBO结合各类统计信息指定执行计划, 一旦执行计划交付运行, CBO的使命就算完成了. 也就是说如果在运行时数据分布发送动态变化, CBO先前制定的执行计划并不会跟着调整、适配

AQE是什么

Spark在3.0推出了AQE(Adaptive Query Execution, 自适应查询执行). AQE是Spark SQL的一种动态优化机制, 在运行时, 每当Shuffle Map阶段执行完毕, AQE都会结合这个阶段的统计信息, 基于既定的规则动态的调整、修正尚未执行的逻辑计划和物理计划, 来完成对原始查询语句的运行时优化.

AQE的优化机制触发的时机是Shuffle Map阶段执行完毕. 也就是说, AQE优化的频次与执行计划中Shuffle的次数一致. 如果查询语句没有引入Shuffle操作, 那么Spark SQL是不会触发AQE的.

AQE依赖的统计信息是什么:

AQE赖以优化的统计信息与CBO不同, 这些统计信息并不是关于某张表或是哪个列, 而是Shuffle Map阶段输出的中间文件. 每个Map Task都会输出以data为后缀的数据文件, 还有以index为结尾的索引文件, 这些文件统称为中间文件. 每个data文件的大小、空文件数量与占比、每个Reduce Task对于的分区大小, 所有这些基于中间文件的统计值构成了AQE进行优化的信息来源.

Spark-怎么用好AQE的三个特性

Fri, 01 Apr 2022 00:00:00 +0000

经验主义的弊端是对待相似的问题和场景都使用同一种套路.

但是CBO也有三个方面的缺点: 窄、慢、静.

窄 : 指的是适用面太窄, CBO仅支持注册到Hive Metastore的数据表
慢: 指的是统计信息的搜集效率比较低. 对于注册到Hive Metastore的数据表, 开发者需要调用ANALYZE TABLE COMPUTE STATISTICS语句收集统计信息, 而各类信息的收集会消耗大量时间
静: 指的是静态优化, 这一点与RBO一样, CBO结合各类统计信息指定执行计划, 一旦执行计划交付运行, CBO的使命就算完成了. 也就是说如果在运行时数据分布发送动态变化, CBO先前制定的执行计划并不会跟着调整、适配

AQE是什么

AQE依赖的统计信息是什么:

Spark-最大化内存的使用效率

Fri, 01 Apr 2022 00:00:00 +0000

Reserved Memory

堆内内存可以划分为

Reserved Memory,
User Memory
Storage Memory
Execution Memory

其中Reserved Memory固定为300MB.

User Memory

再看一下之前在广播变量里提到的一段代码

val dict = List(“spark”, “tune”)
val words = spark.sparkContext.textFile(“~/words.csv”)
val keywords = words.filter(word => dict.contains(word))
keywords.map((_, 1)).reduceByKey(_ + _).collect

这里的dict变量, 会被分发到每个Executor上, 每个Executor上会同时存在N份(N为当前Executor上并行执行的task数量). 这些数据被存储到了堆内内存的User Memory区域

当使用广播变量将这个变量进行分发后, 这个数据就只会在Executor上存储一份. 并且这部分数据也不再存储到User Memory中, 转到了Storage Memory的存储区域

估算公式

User Memroy = 应用内自定义数据结构的对象总大小 * Executor的线程池大小

计算公式:

(spark.executor.memory - 300MB) * ( 1- spark.memory.fraction )

Storage Memory

Spark存储系统主要有3个对象

Shuffle中间文件
RDD缓存
广播变量

它们都由Executor上的BlockManager进行管理, 对于数据在内存和磁盘中的存储, BlockManager利用MemoryStore和DiskStore进行抽象和封装

广播变量所携带的数据内容会物化到MemoryStore中, 以Executor为粒度为所有Task提供唯一的一份数据拷贝.

广播变量消耗的就是 Storage Memory 内存区域

估算公式

Storage Memory = ( 所有broadcast变量的大小 + 数据缓存大小 ) / Executor数量

Spark-最大化内存的使用效率

Fri, 01 Apr 2022 00:00:00 +0000

Reserved Memory

堆内内存可以划分为

Reserved Memory,
User Memory
Storage Memory
Execution Memory

其中Reserved Memory固定为300MB.

User Memory

再看一下之前在广播变量里提到的一段代码

val dict = List(“spark”, “tune”)
val words = spark.sparkContext.textFile(“~/words.csv”)
val keywords = words.filter(word => dict.contains(word))
keywords.map((_, 1)).reduceByKey(_ + _).collect

当使用广播变量将这个变量进行分发后, 这个数据就只会在Executor上存储一份. 并且这部分数据也不再存储到User Memory中, 转到了Storage Memory的存储区域

估算公式

User Memroy = 应用内自定义数据结构的对象总大小 * Executor的线程池大小

计算公式:

(spark.executor.memory - 300MB) * ( 1- spark.memory.fraction )

Storage Memory

Spark存储系统主要有3个对象

Shuffle中间文件
RDD缓存
广播变量

它们都由Executor上的BlockManager进行管理, 对于数据在内存和磁盘中的存储, BlockManager利用MemoryStore和DiskStore进行抽象和封装

广播变量所携带的数据内容会物化到MemoryStore中, 以Executor为粒度为所有Task提供唯一的一份数据拷贝.

广播变量消耗的就是 Storage Memory 内存区域

估算公式

Storage Memory = ( 所有broadcast变量的大小 + 数据缓存大小 ) / Executor数量

一段代码在Spark中的执行过程

Fri, 01 Apr 2022 00:00:00 +0000

一段代码在Spark中的执行过程

假如我们的Spark的资源调度是基于Yarn的, 并且有这样一段代码, 我们来分析一下它从提交开始到返回结果的执行过程

select name, age, sum(price * volume) revenue
from 
(
select * from tx
) tx
inner join 
(
select name, age, userId
from user 
where age < 30 and gender in ('M')
) user
on tx.userId = user.userId
group by 1,2
;

提交任务

这里的提交一般有两种方式, 一种是client模式, 一种是cluster模式

矩阵中的路径-剑指Offer LeetCode12

Fri, 25 Mar 2022 00:00:00 +0000

题目描述

链接: https://leetcode-cn.com/problems/ju-zhen-zhong-de-lu-jing-lcof/

给定一个存储字母的m*n二维数组和一个字符串单词word. 如果word存在与二维数组中, 返回true, 否则返回flase

单词必须按照字母顺序, 通过相邻的单元格内的字母构成, 其他"相邻"单元格是那些水平相邻或垂直相邻的单元格. 同一个单元格内的字母不允许被重复使用.

例如, 在下面的3*4的矩阵中包含单词"ABCCED"

示例1:

输入: borad = [ [“A”, “B”, “C”, “E”], [“S”, “F”, “C”, “S”], [“A”, “D”, “E”, “E”], [“A”, “D”, “E”, “E”]], word = “ABCCED”

输出: true

示例2:

输入：board = [[“a”,“b”],[“c”,“d”]], word = “abcd” 输出：false

二叉树中和为某一值的路径- 剑指Offer LeetCode34

Thu, 24 Mar 2022 00:00:00 +0000

题目描述

链接: https://leetcode-cn.com/problems/er-cha-shu-zhong-he-wei-mou-yi-zhi-de-lu-jing-lcof/

给定二叉树的根节点root和一个整数目标targetSum, 找出所有从根节点到叶子节点路径总和等于给定目标和的路径

叶子节点是指没有子节点的节点

示例1:

输入：root = [5,4,8,11,null,13,4,7,2,null,null,5,1], targetSum = 22 输出：[[5,4,11,2], [5,8,4,5]]

有两条路径加起来之和等于22

示例2:

输入：root = [1,2,3], targetSum = 5 输出：[]

没有符合条件的路径

机器人的运动路径- 剑指Offer LeetCode13

Thu, 24 Mar 2022 00:00:00 +0000

题目描述

链接: https://leetcode-cn.com/problems/ji-qi-ren-de-yun-dong-fan-wei-lcof/

地上有一个m行n列的二维矩阵, 从坐标[0, 0]到[m-1, n-1]. 一个机器人从坐标[0, 0]的格子开始移动, 每次可以向左, 右, 上, 下移动一格.

不能移动到方格外, 也不能移动到行坐标和列坐标的数位之和大于K的格子. 例如当K=18时, 机器人可以进入方格[35, 37], 因为3+5+3+7=18. 但是不能进入[35, 38], 因为3+5+3+8=19. 求机器人能够到达多少个格子.

把数组排成最小的数-剑指Offer LeetCode45

Wed, 23 Mar 2022 00:00:00 +0000

题目描述

链接: https://leetcode-cn.com/problems/ba-shu-zu-pai-cheng-zui-xiao-de-shu-lcof/

输入一个非负整数数组, 把数组里所有数字拼接起来排出一个数, 打印能拼接出的数字中最小的一个.

示例1:

输入: [10, 2]

输出: “102”. 两个数字的排列可能为102, 210. 由于102小, 所以结果为102.

示例2:

输入: [3, 30, 34, 5, 9]

输出: ”3033459“

二叉搜索树的第K大节点-剑指Offer LeetCode54

Wed, 23 Mar 2022 00:00:00 +0000

题目描述

链接: https://leetcode-cn.com/problems/er-cha-sou-suo-shu-de-di-kda-jie-dian-lcof/

给定一颗二叉搜索树, 请找出其中第K大节点的值

示例1:

输入: 层序遍历 = [3, 1, 4, null ,2] , k = 1

3

/ \

1 4

\

2

输出: 4, 最大的节点为4

示例2:

输入: 层序遍历 = [ 5, 3, 6, 2, 4, null, null ,1], k = 3

5

/ \

3 6

/ \

2 4

/

1

输出: 4. 倒数第3个最大节点为4.

扑克牌中的顺子-剑指Offer LeetCode61

Wed, 23 Mar 2022 00:00:00 +0000

题目描述

链接: https://leetcode-cn.com/problems/bu-ke-pai-zhong-de-shun-zi-lcof/

从若干幅扑克牌中随机抽5张牌, 判断是不是一个顺子, 即这五张牌是不是连续的. 2~10为数字本身, A为1, J为11, Q为12, K为13. 大小王为0, 并且可以看出任意数字

示例1:

输入: [1,2,3,4,5]

输出: true

示例2:

输入: [0,0,1,2,5]

输出: true. 由于两个0可以代替为3和4, 所以可以构成顺子

GitTag

Wed, 09 Mar 2022 00:00:00 +0000

Git commit是一次文件提交. 而Git Tag则是对某个时间点的提交进行标记, 例如版本1, 版本2等等.

基本命令

列出标签


git tag
# 列出符合 1.0.*的所有标签
git tag -l "v1.0.*"

创建标签

轻量标签

git tag <tag_name>
git tag v1.1

附注标签

git tag -a <tag_name> "<commit_info>"
git tag -a v1.1 "这是1.1版本"

对历史的commit打标签

git tag -a <tag_name> <commit_id>

查看标签

git show <tag_name>

推送标签

git push origin <tag_name>

推送所有的标签

git push origin --tags

删除标签

git tag -d <tag_name> # 此操作不会删除远程标签

删除远程标签

git push origin --delete <tag_name>

检出标签

git checkout <tag_name> # 只检出不会创建新的分支, 通常不推荐这样做
git checkout -b <new_branch_name> <tag_name> # 从这个tag检出, 并创建一个新分支

Java Class Loader

Thu, 14 Oct 2021 00:00:00 +0000

Class Loader

站在Java虚拟机的角度来看，只存在两种不同的类加载器：

一种是启动类加载器(Bootstrap ClassLoader)，这个类加载器使用C++语言实现，是虚拟机自身的一部分；

另外一种就是其他所有的类加载器，这些类加载器都由Java语言实现，独立存在于虚拟机外部，并且全都继承自抽象类java.lang.ClassLoader。

站在Java开发人员的角度来看，类加载器就应当划分得更细致一些。自JDK 1.2以来，Java一直保持着三层类加载器、双亲委派的类加载架构，尽管这套架构在Java模块化系统出现后有了一些调整变动，但依然未改变其主体结构。

Java类加载机制

Sun, 10 Oct 2021 00:00:00 +0000

类加载机制

定义

Java虚拟机把描述类的数据从Class文件加载到内存，并对数据进行校验、转换解析和初始化，最终形成可以被虚拟机直接使用的Java类型，这个过程被称作虚拟机的类加载机制。

类的生命周期

加载、验证、准备、初始化和卸载这五个阶段的顺序是确定的，类型的加载过程必须按照这种顺序按部就班地开始，而解析阶段则不一定:它在某些情况下可以在初始化阶段之后再开始，这是为了支持Java语言的运行时绑定特性(也称为动态绑定或晚期绑定)。

GC-经典垃圾收集器

Sat, 25 Sep 2021 00:00:00 +0000

经典垃圾收集器

Serial收集器

Serial收集器是最基础、历史最悠久的收集器. 这个收集器是一个单线程工作的收集器, 在他进行垃圾收集时, 必须暂停其他所有工作线程, 直到它收集结束.

它是HotSpot虚拟机运行在客户端模式下的默认新生代收集器, 它简单高效, 额外内存消耗最少.

GC-垃圾回收算法

Mon, 20 Sep 2021 00:00:00 +0000

垃圾回收算法

从如何判定对象消亡的角度出发, 垃圾收集算法可以划分为“引用计数器垃圾收集”(Reference Counting GC)和“追踪式垃圾收集”(Tracing GC)两大类. 这两类也常被称作“直接垃圾收集“和”间接垃圾收集“. 但是引用计数式垃圾收集算法在主流Java虚拟机中均为涉及.

GC-垃圾收集器

Wed, 15 Sep 2021 00:00:00 +0000

垃圾收集器

垃圾收集需要完成三件事情:

哪些地方的内存需要回收?
如何判断能否回收?
如何回收?

Java OOM异常分析

Fri, 10 Sep 2021 00:00:00 +0000

Java OOM异常分析

OOM异常分析

Java堆溢出

Java堆内存的OutOfMemoryError异常是实际应用中最常见的内存溢出异常情况. 出现Java堆内存溢出时, 异常堆栈信息“java.lang.OutOfMemoryError”会跟随进一步提示“Java heap space“

可能的原因有:

内存泄漏
内存溢出

需要从代码上检查是否存在某些对象生命周期过长、持有状态时间过长、存储结构设计不合理的情况, 尽量减少程序运行期的内存消耗

要处理这个内存区域的异常, 常规的处理方法是通过内存映像分析工具对Dump出来的堆转储快照进行分析.

JVM中Java对象的创建、内存布局、访问定位

Wed, 01 Sep 2021 00:00:00 +0000

Java对象创建

当Java虚拟机遇到一条字节码new指令时, 首先将去检查这个指令的参数能否在常量池中定位到一个类的符号引用, 并且检查这个符号引用代表的类是否被加载, 解析和初始化. 如果没有则会先执行相应的类加载过程.

对象的创建过程大致分为以下四步:

为新生对象分配内存
虚拟机将分配到的内存空间(不包括对象头)都初始化为零值
对对象进行必要的设置, 例如这个对象是哪个类的实例, 如果找到这个类的元数据信息, 对象的GC分代年龄等, 这些信息存放在对象的对象头之上
执行Class文件额init方法

JVM运行时数据区域

Sat, 28 Aug 2021 00:00:00 +0000

JVM运行时数据区域

Java虚拟机所管理的内存包括以下几个运行时数据区域：

如何将多个git commit合并成一个

Sun, 04 Jul 2021 00:00:00 +0000

这篇文章记录下使用Git时的一些进阶操作, 命令.

ClickHouse(1)-写入过程

Sun, 14 Feb 2021 00:00:00 +0000

前言

这篇文章记录一下ClickHouse的几种原生引擎的数据写入过程

MergeTree

MergeTree是ClickHouse的最基础引擎，其它引擎都是基于这个引擎来进行扩展的，所以先来看一下这个引擎的写入过程。

先看一下要创建这个引擎的DDL语句：

CREATE TABLE [IF NOT EXISTS] [db.]table_name [ON CLUSTER cluster]
(
    name1 [type1] [DEFAULT|MATERIALIZED|ALIAS expr1] [TTL expr1],
    name2 [type2] [DEFAULT|MATERIALIZED|ALIAS expr2] [TTL expr2],
    ...
    INDEX index_name1 expr1 TYPE type1(...) GRANULARITY value1,
    INDEX index_name2 expr2 TYPE type2(...) GRANULARITY value2
) ENGINE = MergeTree()
ORDER BY expr
[PARTITION BY expr]
[PRIMARY KEY expr]
[SAMPLE BY expr]
[TTL expr [DELETE|TO DISK 'xxx'|TO VOLUME 'xxx'], ...]
[SETTINGS name=value, ...]

maven

Sat, 23 Jan 2021 00:00:00 +0000

Dependency-reduced-pom.xml*

这个文件会在使用maven-shade-plugin插件时生成，可以修改配置来避免产生这个文件

<plugin>
   <groupId>org.apache.maven.plugins</groupId>
   <artifactId>maven-shade-plugin</artifactId>
   <version>2.4.3</version>
   <configuration>
      <createDependencyReducedPom>false</createDependencyReducedPom>
   </configuration>
</plugin>

-U 强制更新

打包时将依赖同时打入jar包内

<plugins>
    <plugin>
        <artifactId>maven-assembly-plugin</artifactId>
          <configuration>
              <descriptorRefs>
                  <descriptorRef>jar-with-dependencies</descriptorRef>
              </descriptorRefs>
          </configuration>
          <executions>
              <execution>
                  <id>make-assembly</id> 
                  <phase>package</phase> 
                  <goals>
                      <goal>single</goal>
                  </goals>
              </execution>
          </executions>
    </plugin>
</plugins>

SBT加速

Sat, 23 Jan 2021 00:00:00 +0000

最近有一个项目使用到了sbt作为构建工具，在电脑上即便有科学工具，下载依赖也是巨慢无比，有时候一天都下不下来。所以这篇文章就记录一下如何对sbt进行加速。

编辑配置文件，添加国内源：

`1`	`vim ~/.sbt/repository`

将这个文件的信息修改为：

[repositories]
	local
	aliyun-ivy: http://maven.aliyun.com/nexus/content/groups/public, [organization]/[module]/(scala_[scalaVersion]/)(sbt_[sbtVersion]/)[revision]/[type]s/[artifact](-[classifier]).[ext]
	aliyun-maven: http://maven.aliyun.com/nexus/content/groups/public
	typesafe: http://repo.typesafe.com/typesafe/ivy-releases/, [organization]/[module]/(scala_[scalaVersion]/)(sbt_[sbtVersion]/)[revision]/[type]s/[artifact](-[classifier]).[ext], bootOnly
	typesafe2: http://repo.typesafe.com/typesafe/releases/
	sbt-plugin: http://repo.scala-sbt.org/scalasbt/sbt-plugin-releases/
	sonatype: http://oss.sonatype.org/content/repositories/snapshots
	uk_maven: http://uk.maven.org/maven2/
	repo2: http://repo2.maven.org/maven2/

更改IDE配置

我使用的是IDEA，找到sbt配置项，在VM parameters中填入：
```
-Dsbt.override.build.repos=true
-Dsbt.repository.config=~/.sbt/repositories
```

IPV4与Int的转换

Tue, 05 Jan 2021 00:00:00 +0000

题目描述

将IPV4的地址转换成int值，然后再将其转换回来

大数据分析工具之-kylin

Sun, 19 Jul 2020 00:00:00 +0000

kylin是什么

在进行数据分析时，随着数据量的提升，处理时间基本也是线性增长。kylin是一个预处理框架，它将一些预先定义的复杂分析预先完成并进行存储，预处理完成后，再次进行请求时，kylin可以进行亚秒级别的响应。

它是一个分析型数据仓库（也是OLAP引擎），为Hadoop提供标准SQL支持大部分查询功能

可以接入kafka等实时流处理数据，从而可以在妙极延迟下进行实时数据等多维分析。

处理引擎可以选用MapReduce和Spark。

于BI工具无缝整合，可以接入Tableau，PowerBI/Excel，SuperSet等可视化分析工具。

我总结出来的观点呢就是：当我们的数据量非常大之后，每次查询都需要花费很多时间，这时我们将查询结果缓存起来，后面查询从这个缓存里面查询速度就会非常快。在kylin中，将结果缓存到hbase表中。

这里需要预先设置一些维度和度量，所以说适合一些固定报表等一些维度固定的场景，如果说维度的组合太多或者变化很频繁，可能不是很适用。

Z字形变换—LeetCode6

Thu, 02 Jul 2020 00:00:00 +0000

题目描述

将一个给定字符串根据给定的行数，以从上往下、从左到右进行 Z 字形排列。

比如输入字符串为 “LEETCODEISHIRING” 行数为 3 时，排列如下：
L   C   I   R
E T O E S I I G
E   D   H   N
之后，你的输出需要从左往右逐行读取，产生出一个新的字符串，比如：“LCIRETOESIIGEDHN”。

请你实现这个将字符串进行指定行数变换的函数：

string convert(string s, int numRows); 示例 1:

输入: s = “LEETCODEISHIRING”, numRows = 3 输出: “LCIRETOESIIGEDHN” 示例 2:

输入: s = “LEETCODEISHIRING”, numRows = 4 输出: “LDREOEIIECIHNTSG” 解释:
L     D     R
E   O E   I I
E C   I H   N
T     S     G

gradle笔记

Sat, 20 Jun 2020 00:00:00 +0000

编译打包时，将依赖也打入jar包，在build.gradle文件中，添加这一部分即可

jar {
    from {
        configurations.runtime.collect { zipTree(it) }
    }
    enabled = true
}

去除依赖：

    compile('com.ebay.fount:managed-fount-client:0.1.1') {
        exclude group: 'com.ebay.platform.security', module: 'trustfabric-client'
    }

Helm常用命令

Sat, 20 Jun 2020 00:00:00 +0000

安装：

helm install -f xxx.yaml server-name chart-dir

更新：

helm upgrade -f xxx.yaml server-name chart-dir

查看部署记录

helm history [xxx]
 

REVISION	UPDATED                 	STATUS    	CHART           	APP VERSION	DESCRIPTION
1       	Wed Oct 21 18:33:37 2020	superseded	clickhouse-1.0.1	19.14      	Install complete
2       	Wed Oct 21 18:49:18 2020	deployed  	clickhouse-1.0.1	19.14      	Upgrade complete

回滚：

helm rollback [xxx] [version]
helm rollback clickhouse 1 #回滚到版本1

卸载：

helm uninstall server-name

我目前的git工作流程

Sat, 20 Jun 2020 00:00:00 +0000

好久没写博客了。。。

记录一下我在现在公司的一个git工作流程。

我之前使用git是不同用户在同一个git仓库下进行操作，而现在是使用fork出自己的仓库，通过提pr的方式来进行提交代码。

git fork后如何与原仓库同步

Fri, 08 May 2020 00:00:00 +0000

背景

当参与到开源项目开发后，我们需要先将代码fork到自己的仓库，对代码进行修改后再提交pr。

如果在这中间原仓库有提交过代码，我们这边是无法得知的，所以我们需要在提pr前先进行merge操作，先将原仓库的内容更新下来再进行提交。

大体流程如下所示：

mongo-读操作事务

Tue, 14 Apr 2020 00:00:00 +0000

读取数据的过程需要关注以下两个问题：

从哪里读？关注数据节点位置
什么样的数据可以读？关注数据的隔离性第一个问题是由readPreference来解决第二个问是题由readConcern来解决

什么是readPreference

readPreference决定使用哪一个节点来满足正在发起的读请求。可选值包括：

primary 主选择主节点
primaryPreferred 优先选择主节点，如果不可用则选择从节点
secondary 只选择从节点
nearest 选择最近的节点

readPreperfence使用场景举例

用户下订单后马上将用户转到订单详情页 primary/primaryPreferred。因为此时从节点可能还没复制到新订单
用户查询自己下过的订单 secondary/secondaryPreferred。查询历史订单对时效性通常没有太高要求
生成报表 secondary。报表对时效性要求不高，但要进行计算资源需求大，可以在从节点单独处理，避免对线上用户造成影响
将用户上传的图片分发到全世界，让各地用户能够就近读取 nearest。每个地区的应用选择最近的节点读取时间

readPreference与Tag readPreference只能控制使用一类节点。Tag则可以将节点选择控制到一个或多个节点。考虑以下场景：一个5个节点的复制集，3个节点硬件较好，专用于服务线上客户，2个节点硬件较差，专用于生成报表。

可以使用Tag来达到这样的控制目的：

为3个较好的节点打上{purpose:“online”}
为2个较差的节点打上{purpose:“analyse”}
在线应用读取时指定online，报表读取时指定reporting

readPreference配置

通过MongoDB的连接串参数mongodb://host1:port,host2:port,host3:port/?replicaSet=rs&readPreperence=secondary
通过MongoDB驱动程序API MongoCollection.withReadPreference(ReadPreference readPref)
Mongo Shelldb.collection.find({}).readPref("secondary")

实验

锁定写入（同步）的命令db.fsyncLock()，解锁:db.fsyncUnlock()

主节点写入{x:1},观察该条数据在各个节点均可见
在两个从节点分别执行db.fsyncLock()来锁定写入
主节点写入{x:2}，在各个节点观察数据变化
接触从节点锁定，观察各节点数据变化

注意事项

指定readPreference时也应注意高可用问题，利用将readPreference指定primary，则发生故障转移不存在primary期间将没有节点可读。所以如果业务允许，则应该选择primaryPreferred
使用Tag时也会遇到同样的问题，如果只有一个节点拥有一个特定Tag，则在这个节点失效将无节点可读。这在有时候是期望的结果，有时候不是。例如
- 如果报表使用的节点失效，即使不生成报表，通常也不希望将报表负载转移到其他节点上，此时只有一个节点有报表Tag是合理的选择
- 如果线上节点失效，通常希望有代替节点，所以应该保持多个节点有同样的Tag
Tag有时需要与优先级，选举权综合考虑。例如做报表的节点通常不会希望它成为主节点，则优先级应为0

什么是readConcern

在readPreference选择了指定的节点后，readConcern决定这个节点上的数据哪些是可读的，类似于关系数据库的隔离级别。可选值包括：

avaliable 读取所有可用的数据
local 读取所有可用且属于当前分片的数据
majority 读取在大多数节点上提交完成的数据
linearizable 可线性化读取文档
snapshot 读取最近快照中的数据

readConcern:local和avaliable 在复制集中local和avaliable是没有区别的。两者的区别主要是体现在分片集上考虑以下场景：

一个chunk x正在从shard1向shard2迁移
这个迁移过程中chunk x中的部分数据会在shard1和shard2中同时存在，但源分片shard1仍然是chunk 想的负责方
- 所有对chunk x的读写操作仍然进入shard1
- config中记录的信息chunk x仍然属于shard1
此时如果读shard2，则会体现出local和avaliable的区别：
- local：只去应该有shard2负责的数据（不包括x）
- avaliable：shard2上有什么就读什么（包括xß）

注意事项：

mongo-复制集机制

Tue, 14 Apr 2020 00:00:00 +0000

原理

MongoDB复制集的主要意义在于实现服务高可用它的现实依赖于两个方面的功能：

数据写入时将数据迅速的复制到另一个独立节点上
在接受写入的节点发生故障时自动选举出一个新的替代节点

在实现高可用的同时，复制集实现了其他几个附加功能：

数据分发：将数据从一个区域复制到另一个区域，减少另一个区域的读延迟
读写分离：不同类型的压力分别在不同的节点上执行
异地容灾：在数据中心故障时快速切换到异地

典型的复制集结构：

一个典型的复制集由3个以上具有投票权的节点组成，包括：

一个主节点（PRIMARY）接受写入操作和选举时投票
两个（或多个）从节点（SECONDARY）复制主节点上的新数据和选举时投票大部分分布式都需要奇数节点，因为投票时可以避免相同票数的情况

数据如何复制的

当一个修改操作，无论是插入，更新或删除，到达主节点时，它对数据的操作将被记录下来（经过一些必要的转换），这些记录称为oplog。当接到通过主节点上打开tailable游标不断获取新进入主节点的oplog，并在自己的数据上回放，依次保存跟主节点上的数据一致。

通过选举完成故障恢复

具有投票权的节点之间两两互相发送心跳
当5次心跳未收到时判断为节点失联
如果失联的是主节点，从节点会发起选举，选出新的主节点
如果失联的是从节点则不会产生新的选举
选举基于 RAST一致性算法实现，选举成功的必要条件是大多数投票节点存活
复制集中最多可以有50个节点，但具有投票权的节点最多7个

影响选举的因素

整个集群必须有大多数节点存活
被选举为主节点的节点必须：
- 能够与多数节点建立连接
- 具有较新的oplog
- 具有较高的优先级（优先级可以配置）

复制集节点有以下常见的选配项：

是否具有投票权（v参数）有则参与投票
优先级（priority参数）优先级越高的节点的节点越优先成为主节点。优先级为0的节点无法成为主节点
隐藏(hidden参数) 复制数据，但对应用不可见。隐藏节点可以拥有投票权，但优先级必须为0，即不能成为主节点。备份
延迟（slaveDelay参数）复制n秒之前的数据，保存与主节点的时间差。容错

注意事项

增加节点不会增加系统写性能！因为写的操作都是在主节点完成，增加节点并不能改变主节点的性能，所以不会增加系统的写性能。甚至会降低性能，因为当写请求发送到从节点，从节点需要将请求发送给主节点来完成，完成后再通过oplog发送给所有从节点。但增加节点可以增加系统读性能

搭建

准备配置文件

systemLog:
    destination: file
    path: /data/db1/mongod.log #日志存放位置
    logAppend: true
storage:
    db: /data/db1 #数据存储位置
net:
    bindIp: 0.0.0.0 #开启其他机器访问
    port: 28017 #端口
relication:
    replSetName: rs0 #集群名称
processManagement:
    fork: true #将进程作为后台进程

启动

指定配置文件启动：mongod -f /data/db1/mongod.conf

mongo-基本命令

Tue, 14 Apr 2020 00:00:00 +0000

docker下载：docker pull mongo 运行：docker run -itd --name mongo -p 27017:27017 mongo 进入容器并运行mongo命令：docker exec -it mongo mongo

基本操作命令：

插入操作`insert`

格式：

-   db.<集合>.insertOne(<JSON对象>)
-   db.<集合>.insertMany<[<JSON 1>,<JSON 2>, ...<JSON N>]> 示例：
-   `db.fruit.insertOne({name:"apple"})`
-   `db.fruit.insertMany([{name:"apple"},{name:"pear"}, {name:"orange"}])`

查询文档find

find是MongoDB中查询数据的基本指令，相当于SQL中的SELECT find返回的是游标示例：

db.movies.find({“year”:1975}) 单条件查询
db.movies.find({“year”:1989,“title”:“Batman”}) 多条件and查询
db.movies.find({$and:[{“title”:“Batman”},{“category”:“action”}]}) and的另一种形式
db.movies.find($or:[{“year”:1989},{“title”:“Batman”}]) 多条件or查询
db.movies.find({“title”:"/^B/"}) 按正则表达式查找

查询条件对照表:

    SQL | MQL
    ---|---
    a = 1 | {a : 1}
    a <> 1 (a!=1) | {a: {$ne: 1}}
    a > 1 | {a: {$gt: 1}}
    a >= 1 | {a: {$gte: 1}}
    a < 1 | {a: {$lt: 1}}
    a <= 1 | {a: {$lte: 1}}

查询逻辑对照表:

mongo-索引

Tue, 14 Apr 2020 00:00:00 +0000

MongoDB的索引是基于B树的，B树也称为B-树。 为什么MongoDB是B树，MySQL的B+树？ Mysql作为一个关系型数据库，数据的关联性是非常强的，区间访问是常见的一种情况，B+树由于数据全部存储在叶子节点，并且通过指针串在一起，这样就很容易的进行区间遍历甚至全部遍历。 MongoDB使用B-树，所有节点都有Data域，只要找到指定索引就可以进行访问，无疑单次查询平均快于Mysql。

Query Shape–查询的形状即查询语句中的条件，使用不同的条件会执行不同的索引。

Index Prefix–索引前缀即最左前缀原则，创建(a,b)联合索引后，就无需创建(a)索引

Selectivity–过滤性选择索引时会选择过滤性最强的一个，假设有这样的一个例子：根据条件a=1查询后得到记录1000条根据条件b=2查询后得到记录100条根据条件c=3查询后得到记录10条如果现在要执行查询条件为a=1 and b=2 and c=3并且只能创建一个索引，就应该将索引创建在c字段上

查看执行计划：explain()db.col.find({name:111}).explain(true)

支持的索引类型

单键索引
组合索引
多值索引
地理位置索引
全文索引
TTL索引
部分索引
哈希索引

组合索引

查询语句为db.members.find({ gender : "F" , age : {$gte : 18}}).sort("join_data":1) 这个查询中有精确匹配，排序，范围查询这三个条件。

组合索引的最佳方式：ESR原则

精确（Equal）匹配的字段放在最前面
排序（Sort）条件放中间
范围（Range）匹配的字段放最后

同样适合:ES,ER

创建索引：db.col.createIndex({name:1}) 后台创建索引：db.member.createIndex({city:1},{background:true})

mongo-写操作事务

Tue, 14 Apr 2020 00:00:00 +0000

什么是writeConcern

writeConcern决定一个写操作落到多少个节点上才算成功。writeConcern的取值包括：

0：发起写操作，不关心是否成功；
1~集群最大数据节点数，写操作需要被复制到指定节点数才算成功
majority：写操作需要被复制到大多数节点才算成功。发起写操作的程序将阻塞到写操作到达指定的节点数为止

默认行为：

3节点复制集不做任何特定设置（默认值）时的操作如下图所示：

大多数节点确认模式：

`w:“majority”

当写的操作被大多数节点写入成功后才返回

全部节点确认模式

w:"all" 设置后需要当所有的节点都将数据写入后才返回

journal

writeConcern可以决定写操作到达多少个节点才算成功，journal则定义如何才算成功。取值包括：

true:写操作落到journal文件中才算成功
false：写操作到达内存即算作成功

实验

在复制集测试writeConcern参数

db.test.insert({count:1,{writeConcern:{w:"majority"}}})
db.test.insert({count:1,{writeConcern:{w:"3"}}})
db.test.insert({count:1,{writeConcern:{w:"4"}}})

正常情况下，是可以正常返回的，可以手动修改配置，模拟延迟环境。修改复制延迟参数：

conf=rs.conf()
conf.members[i].slaveDelay=5 # 将第i个节点设置5秒的复制延迟
conf.members[i].priority=0 # 由于延迟所以不能设置为主节点
rs.reconfig(conf)  # 启用配置

设置超过延迟时间后失败：

db.test.inser({count:3},{writeConcern:{w:"majority",wtimeout:3000}}) #当大多数节点写入成功就算成功，超过3秒后如果未返回则失败

注意事项：我们假设使用上面的配置，对节点启用5秒的延迟写入，并且等待超时时间为3秒，那么会返回下面的信息：

WriteResult({
    "nInserted":1,
    "writeConcernError" :{
        ...
    }
})

可以看到上面有个属性nInserted，这个属性表示已经成功写入了多个个节点，这里表示已经成功写入了1个节点，并不是全部的节点都没有这个数据。所以这是需要注意的地方

注意事项

虽然多于办事的writeConcern都是安全的，但通常只会设置majority，这是因为等待写入延迟时间最短的选择
不要将writeConcern等于总节点数，因为一旦有一个节点故障，所有写操作都将失败
writeConcern虽然会增加写操作延迟时间，但并不会显著增加集群压力，因此无论是否等待，写操作最终都会复制到所有节点上。设置writeConcern只是让写操作复制后再返回而已
应对重要数据应用{w:"majority"}，普通数据可以应用{w:1}以确保最佳性能

Redis持久化

Tue, 14 Apr 2020 00:00:00 +0000

为什么要持久化数据

由于Redis是在内存中进行存储的，当机器重启后内存里面的数据就会丢失。我们不希望这些数据是临时数据，希望它能在重启之后仍然存在，或者我们能将数据导出在其他机器上直接进行导入。这时候都需要进行持久化，将数据落盘。

持久化的方式

持久化的方式在Redis 4.x版本后有了一些区别！

持久化方式主要有两种：

最小的k个数-LeetCodeM40

Mon, 13 Apr 2020 00:00:00 +0000

题目描述

输入整数数组 arr ，找出其中最小的 k 个数。例如，输入4、5、1、6、2、7、3、8这8个数字，则最小的4个数字是1、2、3、4。

示例 1：

输入：arr = [3,2,1], k = 2 输出：[1,2] 或者 [2,1] 示例 2：

输入：arr = [0,1,2,1], k = 1 输出：[0]

限制：

0 <= k <= arr.length <= 10000 0 <= arr[i] <= 10000

给定一个数组，找出最小的k个数，对这k个数的大小顺序没有要求。

解题思路

这个题目我最开始的想法是用堆来解决的，但我解答完成看题解的时候发现了一种做法：

排序后取前k个元素

在评论区中有很多人在讨论这一种解法，虽然的他复杂度比较高，实现方式很简单，有一些专业人士在鄙视这种做法，也有一些人说这个题目的难度是简单，所以用这个也没什么问题。我的看法是支持这种做法，并不因为他的难度级别，而是解决问题的思路。在解决问题的时候每一种思路都是可取的。

堆以及堆排序

Sun, 12 Apr 2020 00:00:00 +0000

什么是堆

堆是一种特殊的树，它满足以下两点：

堆是一个完全二叉树

完全二叉树要求，除最后一层，其他层的节点个数都是满的，最后一次的节点都靠左排列。
堆中每一个节点的值都必须大于等于（或小于等于）其子树中每个节点的值

当前节点的值是子树中的最大或最小值。

我们将每个节点的值都大于等于子树中每个节点值的堆，叫做“大顶堆”。对于每个节点的值都小于等于子树中每个节点值的堆，我们叫做“小顶堆”

我们来看一下例子：

在上面的四个实例中，我们根据以上两条规则，可以判断出：

第一个、第二个是大顶堆，第三个是小顶堆，第四个由于不是完全二叉树所以不是堆。

什么是fail-fast与fail-safe

Wed, 01 Apr 2020 00:00:00 +0000

fail-fast与fail-safe

在Collection集合的各个类中，有线程安全和线程不安全这2大类的版本。

对于线程不安全的类，并发情况下可能会出现fail-fast情况；而线程安全的类，可能出现fail-safe的情况。

**快速失败（fail—fast）**是java集合中的一种机制，在用迭代器遍历一个集合对象时，如果遍历过程中对集合对象的内容进行了修改（增加、删除、修改），则会抛出Concurrent Modification Exception。

**安全失败（fail-sage）**保存了该集合对象的一个快照副本。你可以并发读取，不会抛出异常，但是不保证你遍历读取的值和当前集合对象的状态是一致的！

fail-fast

来看一下线程不安全的类ArrayList，它实现fail-fast主要靠一个字段modCount。来从头认识一下它。

首先找到引用它的地方：

public boolean add(E e) {
  ensureCapacityInternal(size + 1);  // Increments modCount!!
  elementData[size++] = e;
  return true;
}

private void ensureCapacityInternal(int minCapacity) {
  ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
}

private void ensureExplicitCapacity(int minCapacity) {
  modCount++;

  // overflow-conscious code
  if (minCapacity - elementData.length > 0)
    grow(minCapacity);
}

public E remove(int index) {
  rangeCheck(index);

  modCount++;
  E oldValue = elementData(index);

  int numMoved = size - index - 1;
  if (numMoved > 0)
    System.arraycopy(elementData, index+1, elementData, index,
                     numMoved);
  elementData[--size] = null; // clear to let GC do its work

  return oldValue;
}

可以看出，在增加元素，删除元素时都会对modCount值加一。当我们查看更新，查找的代码时并没有找到对modCount的修改。

modCount字段翻译过来就是修改次数，再结合上面的代码可以了解到只有在结构发生变化，数量增减的时候才会修改。查找不会对结构发生变化也不用修改，至于更新操作，虽然它修改了值，但是在结构上总体的数量没有改变，结构上指的是：是谁不重要，有就行。

二叉树的锯齿形层次遍历-LeetCode103

Tue, 31 Mar 2020 00:00:00 +0000

题目描述

给定一个二叉树，返回其节点值的锯齿形层次遍历。（即先从左往右，再从右往左进行下一层遍历，以此类推，层与层之间交替进行）。

例如：给定二叉树 [3,9,20,null,null,15,7],
 	  3
   / \
  9  20
    /  \
   15   7
返回锯齿形层次遍历如下：
\[
  \[3],
  \[20,9],
  \[15,7]
]

所谓的锯齿形遍历，即是在第一层从左向右遍历，在第二层从右向左遍历，依次遍历完成。

多数元素-LeetCode169

Sun, 29 Mar 2020 00:00:00 +0000

题目描述

给定一个大小为 n 的数组，找到其中的多数元素。多数元素是指在数组中出现次数大于 ⌊ n/2 ⌋ 的元素。

你可以假设数组是非空的，并且给定的数组总是存在多数元素。

示例 1:

输入: [3,2,3] 输出: 3 示例 2:

输入: [2,2,1,1,1,2,2] 输出: 2

盛水最多的容器—LeetCode11

Thu, 26 Mar 2020 00:00:00 +0000

题目描述

给你 n 个非负整数 a1，a2，…，an，每个数代表坐标中的一个点 (i, ai) 。在坐标内画 n 条垂直线，垂直线 i 的两个端点分别为 (i, ai) 和 (i, 0)。找出其中的两条线，使得它们与 x 轴共同构成的容器可以容纳最多的水。

说明：你不能倾斜容器，且 n 的值至少为 2。

图中垂直线代表输入数组 [1,8,6,2,5,4,8,3,7]。在此情况下，容器能够容纳水（表示为蓝色部分）的最大值为 49。

示例：

输入：[1,8,6,2,5,4,8,3,7] 输出：49

自己动手实现一个RPC框架（二）

Wed, 25 Mar 2020 00:00:00 +0000

自己动手实现一个RPC框架
使用fastjson，netty，反射，动态代理，zookeeper实现一个RPC框架。

代码链接：https://github.com/liunaijie/self-rpc-framwork`

各模块说明：

rpc-commons 通用设置模块，包括网络传输的数据格式，请求编号工具类，反射工具类等一些底层协议，工具相关的内容
rpc-register
服务注册模块，主要包括服务的注册与发现功能。这里使用zookeeper来进行实现。
在这里，服务端注册时，使用通用模块中的ServiceDescriptor,ResponseServiceDescription类来进行注册 ResponseServiceDescription类是ServiceDescription的子类，添加了实现类，实例地址等属性。消费者查找服务时，发送ServiceDescription得到ResponseServiceDescription，一个类可能有多个实现类，多个实例，在返回时进行随机返回。对于同一个实现的不同版本实现，或多个服务实例这种情况随机返回没有问题。对于不同实现类，采用随机返回可能有些问题，但是在spring中对于多实现类也需要指定实现类，所以后面再考虑更改。

自己动手实现一个RPC框架(六)

Wed, 25 Mar 2020 00:00:00 +0000

rpc-server

消费者的部分，这里使用配置类，将各种实现的部分在配置类中进行定义。

public class ServerConfig {
	/**
	 * 监听端口
	 */
	private int port = 9090;
	/**
	 * 网络传输
	 */
	private Class<? extends TransportServer> transportClass = NettyServer.class;
	/**
	 * 注册中心
	 */
	private Class<? extends RpcRegister> rpcRegister = ZookeeperRegistry.class;
	/**
	 * 编码
	 */
	private Class<? extends Encoder> encoder = FastJsonEncoder.class;
	/**
	 * 解码
	 */
	private Class<? extends Decoder> decoder = FastJsonDecoder.class;

}

这这个配置中，定义了服务启动的端口，网络传输，注册中心，编解码的各种实现，当我们需要更换实现时只需要在这里修改即可。

自己动手实现一个RPC框架(七)

Wed, 25 Mar 2020 00:00:00 +0000

rpc-client

消费者端，通过代理来进行调用。

与生产者端类型，首先定义配置类：

public class ClientConfig {

	private Class<? extends Encoder> encoder = FastJsonEncoder.class;

	private Class<? extends Decoder> decoder = FastJsonDecoder.class;

	private Class<? extends TransportClient> transportClient = NettyClient.class;

	private Class<? extends RpcRegister> rpcRegister = ZookeeperRegistry.class;
}

自己动手实现一个RPC框架（三）

Wed, 25 Mar 2020 00:00:00 +0000

rpc-commons

这个模块主要是定义一些通信协议类，工具类。

自己动手实现一个RPC框架(四)

Wed, 25 Mar 2020 00:00:00 +0000

rpc-register

注册中心，这里使用zookeeper来实现。

生产者在启动服务时，将自己实现的服务注册到注册中心。

消费者调用服务时，来注册中心查找，返回调用服务实例的地址信息。

并且为了适应不同的注册实现，我们将功能定义为接口，在替换实现时在配置文件中进行替换即可。

public interface RpcRegister {
	/**
	 * 注册服务
	 * @param serviceDescriptor
	 * @param responseServiceDescription
	 */
	void register(ServiceDescriptor serviceDescriptor, ResponseServiceDescription responseServiceDescription);
	/**
	 * 根据服务名称查询实例地址
	 * @param serviceDescriptor
	 * @return
	 */
	ResponseServiceDescription lookup(ServiceDescriptor serviceDescriptor);
}

自己动手实现一个RPC框架(五)

Wed, 25 Mar 2020 00:00:00 +0000

rpc-transport

这个模块是有在观看消息队列高手课中的rpc示例完成的。

网络传输模块，这里使用netty来进行实现。

生产者调用来指定端口启动服务。

public interface TransportServer {
	void start(int port) throws InterruptedException;
	void stop();
}

有序链表转换为二叉搜索树—LeetCode109

Sat, 21 Mar 2020 00:00:00 +0000

题目描述

给定一个单链表，其中的元素按升序排序，将其转换为高度平衡的二叉搜索树。

本题中，一个高度平衡二叉树是指一个二叉树每个节点的左右两个子树的高度差的绝对值不超过 1。

示例:

给定的有序链表： [-10, -3, 0, 5, 9],

一个可能的答案是：[0, -3, 9, -10, null, 5], 它可以表示下面这个高度平衡二叉搜索树：
  	0
  -3	9
-10	 5
答案不唯一，只要满足平常二叉树的特性即可。

题目中给出的数组已经按升序排序，我们需要将其转换为平衡二叉树。

自己动手实现一个RPC框架（一）

Thu, 12 Mar 2020 00:00:00 +0000

前言

现在微服务体系流行，而RPC框架作为微服务中重要的一环，为了弄明白RPC的整体过程，决定要自己动手实现一个RPC框架。

我们先了解一下什么是RPC，RPC全程是Remote Procedure Call，翻译过来就是远程过程调用，我们先思考一下没有使用rpc的项目的调用流程：

通过@Autoware注解注入另外的类
在需要调用的地方直接调用即可

当需要调用其他功能的接口时，比如调用其他公司的接口，或者调用自己公司内部的其他业务或功能接口。这时一般需要使用http来进行网络调用。

那么使用http调用其他的功能接口算不算是rpc调用呢？我感觉也是算的，因为这也是一种通过网络从计算机程序上请求服务的过程。

只不过由于调用的功能不严格意义上属于一个大项目，所以不算一个程序直接的内部调用，所以这里只讨论一个大项目拆分成不同模块后，不同模块直接调用的过程。

RPC是原来一个程序分为多个不同的程序，分别运行在不同的jvm上。部署在多台机器上后，就涉及到网络通信，需要将调用的信息发送到被调用的机器上，调用完成后再进行返回。

rpc的流程图如下所示，

牵扯到网络请求，那么就可以使用之前的http请求，但是由于http请求需要封装一些对于我们而言无用的信息，所以使用http的方式可以采用，比如springcloud就采用了http来进行通信的方式，而这次我准备使用其他的网络通信方式，这一篇中先使用bio来实现网络通信。

还有一个序列化过程，它主要是将信息进行编解码，然后通过网络传输，因为网络传输中都是传输的二进制字节码文件，所以我们需要定义规则，将信息进行转换，消费者发送出去的信息生产者能明白其调用的内容，消费者也能明白生产者返回的信息。这一篇文章中也不去使用复杂的序列化方式，直接实现java中的Serializable接口。

二分查找及几种变形

Thu, 05 Mar 2020 00:00:00 +0000

二分查找

前置要求：数组有序

时间复杂度：log(n)

几种常见的问题：

数组中查找target
数组中有重复，查找第一个target
数组中有重复，查找最后一个target
查找等于target或第一个小于target的值
查找等于target或第一个大于target的值

几种排序方式

Wed, 04 Mar 2020 00:00:00 +0000

这篇文章主要记录几种排序方式，描述他们的排序过程，复杂度，代码实现，使用比较。

主要包括以下几种：

二叉树的层序遍历

Tue, 03 Mar 2020 00:00:00 +0000

题目链接

力扣

给你二叉树的根节点 root, 返回其节点值的 层序遍历. (即逐层地, 从左到右访问所有节点).

输入：root = [3,9,20,null,null,15,7]
输出：[[3],[9,20],[15,7]]

广度优先遍历的一个变种, 需要每一层放到一个数组中.

每次对队列遍历时, 当前队列的长度就是这一层的数据, 所以先获取到当前层的元素数量

public List<List<Integer>> levelOrder(TreeNode root) {
		if (root == null) {
			return Collections.emptyList();
		}
		List<List<Integer>> res = new LinkedList<>();
		Queue<TreeNode> queue = new LinkedList<>();
		queue.add(root);
		while (!queue.isEmpty()) {
			int curLevelSize = queue.size();
			List<Integer> curList = new LinkedList<>();
			for (int i = 0; i < curLevelSize; i++) {
				TreeNode node = queue.poll();
				curList.add(node.val);
				if (node.left != null) {
					queue.add(node.left);
				}
				if (node.right != null) {
					queue.add(node.right);
				}
			}
			res.add(curList);
		}
		return res;
    }

变种

力扣

二叉树展开为链表

Tue, 03 Mar 2020 00:00:00 +0000

题目链接

力扣

给你二叉树的根结点 root ，请你将它展开为一个单链表：

展开后的单链表应该同样使用 TreeNode ，其中 right 子指针指向链表中下一个结点，而左子指针始终为 null 。
展开后的单链表应该与二叉树先序遍历顺序相同。

一边遍历一边修改树

维护一个指针，表示上一次的节点，从栈中获取到节点后，如果上一次节点不为null，则将其左节点置为null，右节点置为当前访问节点如果左右节点不为null，则将它们放入栈中，但是要注意需要先放右节点

public void flatten(TreeNode root) {
		if (root == null) {
			return;
		}
		Stack<TreeNode> stack = new Stack<TreeNode>();
		stack.push(root);
		TreeNode prev = null;
		while (!stack.isEmpty()) {
			TreeNode curr = stack.pop();
			if (prev != null) {
				prev.left = null;
				prev.right = curr;
			}
			if (curr.right != null) {
				stack.push(curr.right);
			}
			if (curr.left != null) {
				stack.push(curr.left);
			}
			prev = curr;
		}
	}

先中序遍历再构建结果

public void flatten(TreeNode root) {
		List<TreeNode> list = new ArrayList<TreeNode>();
		Deque<TreeNode> stack = new LinkedList<TreeNode>();
		TreeNode node = root;
		while (node != null || !stack.isEmpty()) {
			while (node != null) {
				list.add(node);
				stack.push(node);
				node = node.left;
			}
			node = stack.pop();
			node = node.right;
		}
		int size = list.size();
		for (int i = 1; i < size; i++) {
			TreeNode prev = list.get(i - 1), curr = list.get(i);
			prev.left = null;
			prev.right = curr;
		}
	}

树的几种遍历方式

Tue, 03 Mar 2020 00:00:00 +0000

主要记录一下对于二叉树，进行遍历的几种方式，包括：

前序遍历
中序遍历
后序遍历
深度优先遍历
广度优先遍历

我们以下面的这个二叉树结构为例，分别描述一下这几种遍历的方式有什么不同，以及给出java实现的代码。

树的几种遍历方式

Tue, 03 Mar 2020 00:00:00 +0000

对于一个二叉树, 有根节点、左节点、右节点.

前序遍历为: 根节点, 左节点, 右节点

中序遍历为: 左节点, 根节点, 右节点 — 二叉搜索树的遍历结果为升序

后序遍历为: 左节点, 右节点, 根节点

使用栈模拟递归

后序遍历时, 由于弹出根节点时还需要判断右节点是否访问过, 如果没有访问过, 则需要将根节点再次访问栈中, 同时访问右节点.

	/**
	 * 前序遍历
	 */
	public List<Integer> preOrderStack(TreeNode root) {
		List<Integer> res = new LinkedList<>();
		Stack<TreeNode> stack = new Stack<>();
		while (root != null || !stack.isEmpty()) {
			// 将根节点添加到结果集中，并将根节点添加到栈中
			while (root != null) {
				stack.push(root);
				res.add(root.val);
				root = root.left;
			}
			root = stack.pop();
			root = root.right;
		}
		return res;
	}

	/**
	 * 中序遍历
	 */
	public List<Integer> inOrderStack(TreeNode root) {
		List<Integer> res = new LinkedList<>();
		Stack<TreeNode> stack = new Stack<>();

		while (root != null || !stack.isEmpty()) {
			//将左节点放入栈中，直至没有左节点为止，此时root为null
			while (root != null) {
				stack.push(root);
				root = root.left;
			}
			//最左节点
			root = stack.pop();
			res.add(root.val);
			// 从最左节点向上遍历右节点
			root = root.right;
		}
		return res;
	}

	/**
	 * 后序遍历
	 */
	public static List<Integer> postOrderStack(TreeNode root) {
		List<Integer> res = new LinkedList<>();
		Stack<TreeNode> stack = new Stack<>();
		//保存上一次访问右子树的值，这样就可以判断右子树是否访问过
		TreeNode prev = null;
		while (root != null || !stack.isEmpty()) {
			//将左子树添加到栈中
			while (root != null) {
				stack.push(root);
				root = root.left;
			}
			root = stack.pop();
			// 这时需要判断右子树是否被访问过
			if (root.right == null || prev == root.right) {
				//没有右子树，或者已经访问过
				res.add(root.val);

				prev = root;
				root = null;
			} else {
				//未访问过
				stack.push(root);
				root = root.right;
			}
		}
		return res;
	}

递归

	/**
	 * 前序遍历，遍历顺序为：根节点，左节点，右节点
	 */
	public List<Integer> preOrder(TreeNode root) {
		List<Integer> res = new LinkedList<>();
		preOrderHelp(root, res);
		return res;
	}

	public void preOrderHelp(TreeNode node, List<Integer> res) {
		if (node == null) {
			return;
		}
		res.add(node.val);
		preOrderHelp(node.left, res);
		preOrderHelp(node.right, res);
	}
	
	/**
	 * 中序遍历，遍历顺序为：左节点，根节点, 右节点
	 */
	public List<Integer> inOrder(TreeNode root) {
		List<Integer> res = new LinkedList<>();
		inOrderHelp(root, res);
		return res;
	}

	public void inOrderHelp(TreeNode node, List<Integer> res) {
		if (node == null) {
			return;
		}
		inOrderHelp(node.left, res);
		res.add(node.val);
		inOrderHelp(node.right, res);
	}



	/**
	 * 后序遍历，遍历顺序为：左节点，右节点，根节点
	 *
	 * @param root
	 * @return
	 */
	public List<Integer> postOrder(TreeNode root) {
		List<Integer> res = new LinkedList<>();
		postOrderHelp(root, res);
		return res;
	}

	public void postOrderHelp(TreeNode node, List<Integer> res) {
		if (node == null) {
			return;
		}
		postOrderHelp(node.left, res);
		postOrderHelp(node.right, res);
		res.add(node.val);
	}

用单链表简单实现LRU算法

Wed, 26 Feb 2020 00:00:00 +0000

什么是LRU算法

Least Recently Used，最近最少使用，当数据超过容量时，淘汰最近最少使用的一个然后再进行添加。

用单链表来进行实现：

维护一个链表，从头插入数据。当新数据插入时将新数据作为头部，指向旧的头结点。

向一个单链表插入数据，首先遍历这个链表，查看数据是否已经存在于链表中。如果存在，则删除原有数据，将新数据插入到头结点。

如果不存在，先看是否已经到达容量，如果没有到达容量则插入到头结点。如果到达容量则删除尾部节点，再进行插入。

在这个过程中，将最近使用过的又重新插入到了头部，在链表尾部的就是最近最少使用的一项，所以从尾部删除。

统计位数为偶数的数字—LeetCode1295

Fri, 21 Feb 2020 00:00:00 +0000

题目描述

给你一个整数数组 nums，请你返回其中位数为偶数的数字的个数。

示例 1：

输入：nums = [12,345,2,6,7896] 输出：2 解释： 12 是 2 位数字（位数为偶数） 345 是 3 位数字（位数为奇数）
2 是 1 位数字（位数为奇数） 6 是 1 位数字位数为奇数） 7896 是 4 位数字（位数为偶数）
因此只有 12 和 7896 是位数为偶数的数字示例 2：

输入：nums = [555,901,482,1771] 输出：1 解释：只有 1771 是位数为偶数的数字。

提示：

1 <= nums.length <= 500 1 <= nums[i] <= 10^5

二叉树的最大深度-LeetCode104

Thu, 20 Feb 2020 00:00:00 +0000

题目描述

给定一个二叉树，找出其最大深度。

二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。

说明: 叶子节点是指没有子节点的节点。

示例：给定二叉树 [3,9,20,null,null,15,7]，
3
/
9 20 /
15 7 返回它的最大深度 3 。

整数的各位积和之差—LeetCode1281

Wed, 19 Feb 2020 00:00:00 +0000

题目描述

给你一个整数 n，请你帮忙计算并返回该整数「各位数字之积」与「各位数字之和」的差。

示例 1：

输入：n = 234 输出：15 解释：各位数之积 = 2 * 3 * 4 = 24 各位数之和 = 2 + 3 + 4 = 9 结果 = 24 - 9 = 15 示例 2：

输入：n = 4421 输出：21 解释：各位数之积 = 4 * 4 * 2 * 1 = 32 各位数之和 = 4 + 4 + 2 + 1 = 11 结果 = 32 - 11 = 21

提示：

1 <= n <= 10^5

猜数字-LeetCodeLCP1

Fri, 14 Feb 2020 00:00:00 +0000

题目描述

小A 和小B 在玩猜数字。小B 每次从 1, 2, 3 中随机选择一个，小A 每次也从 1, 2, 3 中选择一个猜。他们一共进行三次这个游戏，请返回小A 猜对了几次？

输入的guess数组为小A 每次的猜测，answer数组为小B 每次的选择。guess和answer的长度都等于3。

示例 1：

输入：guess = [1,2,3], answer = [1,2,3] 输出：3 解释：小A 每次都猜对了。

示例 2：

输入：guess = [2,2,3], answer = [3,2,1] 输出：1 解释：小A 只猜对了第二次。

限制：

guess的长度 = 3 answer的长度 = 3 guess的元素取值为 {1, 2, 3} 之一。 answer的元素取值为 {1, 2, 3} 之一。

链表中的倒数第K个节点-LeetCodeM22

Sat, 08 Feb 2020 00:00:00 +0000

题目描述

输入一个链表，输出该链表中倒数第k个节点。为了符合大多数人的习惯，本题从1开始计数，即链表的尾节点是倒数第1个节点。例如，一个链表有6个节点，从头节点开始，它们的值依次是1、2、3、4、5、6。这个链表的倒数第3个节点是值为4的节点。

示例：

给定一个链表: 1->2->3->4->5, 和 k = 2.

返回链表 4->5.

基于Docker的MySQL主从复制环境搭建

Thu, 30 Jan 2020 00:00:00 +0000

1. 前言

之前的程序架构可能是这样的一种形式：

当程序体量扩大后，我们进行扩展，可能会扩展多个后台服务实例，但数据库还是只有一个，所以系统的瓶颈还是在数据库上面，所以这次的主要任务就是对数据库进行扩展，主要形式为：扩展多台数据库实例，实现读写分离，对于一些写的任务分配到主数据库，对于读的任务使用子数据库进行读取。从而提高系统性能。

修改后的架构如下所示：

好用的一些软件

Wed, 29 Jan 2020 00:00:00 +0000

记录一些我在日常用到的一些好用的软件。我现在用的系统是mac系统，所以下面大部分是mac系统的，也会记录一些在Windows上用到过的好用的软件。

主要分为几个部分：1.日常使用。2.编程工具

日常使用

图片上传
- picgo
  
  利用它结合github可以白嫖一个网络图床
脑图
- 百度脑图
  
  网页端
- xmind
浏览器
- Chrome
视频、音乐
- IINA
- potplayer（Windows系统）
- 网易云音乐
rss订阅
- reeder
日历
- itsycal
  
  用它替换了系统自带的日历
密码存储
- 1password
窗口管理
- magnet
下载工具
- transmission
网盘
- 百度网盘
- oneDrive
视频处理工具
- 直播工具
  - obs
- 视频剪辑
  - final cut pro
  - arctime pro（字幕工具）

编程工具

makedown编辑工具
- typora
原型流程，作图工具
- omnigraffle
文本编辑
- sublime text
数据库工具
- navicat
IDE
- Intelij全家桶
ssh工具
- termius
- iterm2 + oh my zsh
api测试工具
- postman
ftp工具
- transmit
- xshell和xftp（Windows系统）
虚拟机
- parallels desktop
api文档查询
- dash

Mybatis是如何防止SQL注入的,不用Mybatis如何实现SQL注入

Mon, 06 Jan 2020 00:00:00 +0000

Mybatis这个框架在日常开发中用的很多，比如面试中经常有一个问题：$和#的区别，它们的区别是使用#可以防止SQL注入，今天就来看一下它是如何实现SQL注入的。

什么是SQL注入

在讨论怎么实现之前，首先了解一下什么是SQL注入，我们有一个简单的查询操作：根据id查询一个用户信息。它的sql语句应该是这样：select * from user where id = 。我们根据传入条件填入id进行查询。

如果正常操作，传入一个正常的id，比如说2，那么这条语句变成select * from user where id =2。这条语句是可以正常运行并且符合我们预期的。

但是如果传入的参数变成 '' or 1=1，这时这条语句变成select * from user where id = '' or 1=1。让我们想一下这条语句的执行结果会是怎么？它会将我们用户表中所有的数据查询出来，显然这是一个大的错误。这就是SQL注入。

Java位运算符详解

Tue, 24 Dec 2019 00:00:00 +0000

前言

之前了解过位运算符，左移<<等于乘以2，右移>>等于除以2。但是我在看jdk源码的时候发现了一个>>>三个符号的，不明白这是什么意思，就去搜了一下，发现还挺多的知识点的，就整理了一下。

首先我们知道，我们编写的程序最终都是在计算机底层进行的，计算机底层也仅支持0、1两种符号。所以当时网上有个键盘只有0、1两个键，那才是大佬用的键盘。扯远了。。。

先来复习一下java的基本类型都占多少字节，占多少位（1字节等于8位）：

类型	字节数	位数	大小范围
byte	1	8	-2^8^~2^8^-1
short	2	16	-2^16^~2^16^-1
int	4	32	-2^32^~2^32^-1
long	8	64	-2^64^~2^64^-1
float	4
double	8
char	2	16	一个char类型可以存储一个汉字
boolean	1		true or false

移位操作是把数据看作二进制数，然后将其向左或向右移动若干位的运算。在Java中，移位操作符包含三种：<<左移运算符，>>带符号右移运算符，>>>无符号右移运算符。这三种操作符都只能作用于long,int,short,byte这四种基本整形类型上和char类型上。其他类型如double都无法使用位运算符，大家可以在ide中自行试验一下。

在java中，第一位用来表示数字的正负，第一位为零时表示正数，第一位为1时表示负数。我们拿最简单的8位byte类型举例：0000 0000表示0，0111 1111这个表示最大值(2^8^-1)，再进行加一后就变成了1000 0000这时就变成了最小值(-2^8^)。再加一后变成1000 0001这时的值为-127。也就是从0到最大值然后转为最小值，然后再从最小值向零靠近。

手写红黑树的简单实现

Tue, 24 Dec 2019 00:00:00 +0000

基于《算法》一书的红黑树的插入和删除。看过不同的教材，也有不同的实现方式，但是最终的结果也大致相同，感觉这个比较容易理解，就采用这种的方式来进行简单实现。

定义树节点的实体类型

private static final boolean RED = true;
private static final boolean BLACK = false;

/**
	 * 红黑树的节点结构
	 * 保存的值，左节点，右节点以及颜色(true为红色，false为黑色)
	 * 默认添加一个红节点
	 *
	 * @param <E>
	 */
static final class RedBlackTreeNode<E extends Comparable<E>> {

  E val;
  RedBlackTreeNode<E> left;
  RedBlackTreeNode<E> right;
  boolean color = RED;


  RedBlackTreeNode(E val) {
    this.val = val;
  }

}

这里简单的定义了一下红黑树，并且只有节点，并不是map这样的k-v结构。如果定义k-v结构到时比较的时候比较k即可。

用了泛型，并且要支持比较(继承自Comparable)，不然无法比较大小进行插入。

然后定义了一个值，左节点和右节点，然后颜色默认为红色。

再增加一个构造函数即可

Java古老的集合类之Vector

Mon, 23 Dec 2019 00:00:00 +0000

今天继续来看一下Java中古老的集合类-Vector

变量

//容器存储实体的底层数据结构，Vector也是使用数组来进行存储的
protected Object[] elementData;
//实体的数量
protected int elementCount;
//每次扩容时增加的长度，当为0是扩容原数组长度的两倍
protected int capacityIncrement;

从上面的变量可以得知，Vector也是使用数组来进行底层的数据存储，并且还设置了扩容容量。

Java关键字-transient

Sun, 22 Dec 2019 00:00:00 +0000

最近在看源码的时候看到一个关键字transient，之前对这个字没有印象，所以就去看了一下它的作用。

transient的作用

首先放上来着维基百科的解释：

Java 提供自动序列化，需要以java.io.Serializable接口的实例来标明对象。实现接口将类别标明为“可序列化”，然后Java在内部处理序列化。在Serializable接口上并没有预先定义序列化的方法，但可序列化类别可任意定义某些特定名称和签署的方法，如果这些方法有定义了，可被调用运行序列化/反序列化部分过程。该语言允许开发人员以另一个Externalizable接口，更彻底地实现并覆盖序列化过程，这个接口包括了保存和恢复对象状态的两种特殊方法。

在默认情况下有三个主要原因使对象无法被序列化。其一，在序列化状态下并不是所有的对象都能获取到有用的语义。例如，Thread对象绑定到当前Java虚拟机的状态，对Thread对象状态的反序列化环境来说，没有意义。其二，对象的序列化状态构成其类别兼容性缔结（compatibility contract）的某一部分。在维护可序列化类别之间的兼容性时，需要额外的精力和考量。所以，使类别可序列化需要慎重的设计决策而非默认情况。其三，序列化允许访问类别的永久私有成员，包含敏感信息（例如，密码）的类别不应该是可序列化的，也不能外部化。上述三种情形，必须实现Serializable接口来访问Java内部的序列化机制。标准的编码方法将字段简单转换为字节流。

原生类型以及永久和非静态的对象引用，会被编码到字节流之中。序列化对象引用的每个对象，若其中未标明为transient的字段，也必须被序列化；如果整个过程中，引用到的任何永久对象不能序列化，则这个过程会失败。开发人员可将对象标记为暂时的，或针对对象重新定义的序列化，来影响序列化的处理过程，以截断引用图的某些部分而不序列化。Java并不使用构造函数来序列化对象。

从上面的最后一段可以了解，如果没有添加transient关键字，则会被进行序列化。也就是说添加了这个关键字后就不会被序列化。

接下来我们将用一个例子来测试一下

环形链表—LeetCode141

Sat, 21 Dec 2019 00:00:00 +0000

题目描述

给定一个链表，判断链表中是否有环。

为了表示给定链表中的环，我们使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。如果 pos 是 -1，则在该链表中没有环。

示例 1：
输入：head = \[3,2,0,-4], pos = 1
输出：true
解释：链表中有一个环，其尾部连接到第二个节点。
示例 2：
输入：head = \[1,2], pos = 0
输出：true
解释：链表中有一个环，其尾部连接到第一个节点。
示例 3：
输入：head = \[1], pos = -1
输出：false
解释：链表中没有环。
进阶：

你能用 O(1)（即，常量）内存解决此问题吗？

Java古老的集合类之Hashtable

Fri, 20 Dec 2019 00:00:00 +0000

Hashtable虽然现在不经常被用到，但是它作为Java最早的集合类，今天来看一下它的源码。

首先说明一个问题，在Java中大部分都是驼峰式写法，但是Hasbtable并没有采用这种写法。

继承与实现关系

1
2
3

public class Hashtable<K,V> 
  	extends Dictionary<K,V>
    implements Map<K,V>, Cloneable, java.io.Serializable {}

可以看出它继承的是Dictionary与HashMap并不是同一个父类。但是它也实现了Map，Cloneable，Serializable接口。说明它可以被克隆，可以执行序列化。

变量

private transient Entry<?,?>[] table;

private transient int count;

private int threshold;

private float loadFactor;

private transient int modCount = 0;

来一个一个的解释每一个变量的意义：

table

与HashMap一样，利用数组作为底层的存储容器，并且添加了关键字transient。这个关键字的意思是在进行序列化的时候不会被序列化。这个关键字具体可以看一下这篇文章。

count

表示容器中存储的数量

threshold

扩容阈值，当容器中的数量到达这个值后会进行扩容机制。这个值默认情况下为（capacity* loadFactor）

loadFactor

扩容系数，默认为0.75f。

modCount

修改次数，当增加或删除时，这个值会进行加一。表示这个容器结构修改的次数。这个变量在迭代，序列化等操作、多线程的操作下都尽量保证了安全性。

微服务之SpringCloud-注册中心eureka

Wed, 18 Dec 2019 00:00:00 +0000

简单项目

首先我们建立一个项目，它作为我们的全部项目的容器，并负责公共依赖的版本管理等。

项目结构是这样的：

然后我们在pom.xml中导入我们所需要的依赖，我们全部使用 springboot 来启动项目，并且需要修改packaging的方式为pom。最终的文件如下所示：

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>
	<groupId>learn.spring.cloud.eureka.demo</groupId>
	<artifactId>learn-spring-cloud-eureka</artifactId>
	<version>1.0-SNAPSHOT</version>
	<packaging>pom</packaging>
	<name>simple-parent</name>
	<description>学习eureka</description>
	<parent>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-parent</artifactId>
		<version>2.0.3.RELEASE</version>
		<relativePath/>
	</parent>
	<properties>
		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
		<project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
		<java.version>1.8</java.version>
		<spring-cloud.version>Finchley.RELEASE</spring-cloud.version>
	</properties>
	<dependencies>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-test</artifactId>
			<scope>test</scope>
		</dependency>
	</dependencies>
	<dependencyManagement>
		<dependencies>
			<dependency>
				<groupId>org.springframework.cloud</groupId>
				<artifactId>spring-cloud-dependencies</artifactId>
				<version>${spring-cloud.version}</version>
				<type>pom</type>
				<scope>import</scope>
			</dependency>
		</dependencies>
	</dependencyManagement>
	<build>
		<plugins>
			<plugin>
				<groupId>org.springframework.boot</groupId>
				<artifactId>spring-boot-maven-plugin</artifactId>
			</plugin>
		</plugins>
	</build>

</project>

将链表转换为树

Sun, 15 Dec 2019 00:00:00 +0000

题目来源

今天做了个题：

将一个链表里的数据组装树形结构，链表里的数据已经满足树形结构要求

这道题描述的很简单，但是有很多种情况。他只说了链表数据满足树形结构要求，并没有说明数据到底是什么样的，也就是题目参数具有多样性，这样其实我们给出一种解决方案就可以。而且也只要求将链表转换为树，并没有说是什么树。所以这道题说难也难，说简单也简单。

解题思路

最近也将平衡二叉树的原理看了一下，正好借着这道题将代码手写一下。

我写了一个平衡二叉树的插入方法。我们不管链表里面的数据是如何排序的，我们只要调用树的插入方法即可。在插入方法内部实现树的平衡。

所以我们这道题也就转换成了手写平衡二叉树的插入过程。

移除元素-LeetCode27

Sat, 14 Dec 2019 00:00:00 +0000

题目描述

给你一个数组 nums 和一个值 val，你需要原地移除所有数值等于 val 的元素，并返回移除后数组的新长度。

不要使用额外的数组空间，你必须仅使用 O(1) 额外空间并原地修改输入数组。

元素的顺序可以改变。你不需要考虑数组中超出新长度后面的元素。

示例 1:

给定 nums = [3,2,2,3], val = 3,

函数应该返回新的长度 2, 并且 nums 中的前两个元素均为 2。

你不需要考虑数组中超出新长度后面的元素。示例 2:

给定 nums = [0,1,2,2,3,0,4,2], val = 2,

函数应该返回新的长度 5, 并且 nums 中的前五个元素为 0, 1, 3, 0, 4。

注意这五个元素可为任意顺序。

你不需要考虑数组中超出新长度后面的元素。

说明:

为什么返回数值是整数，但输出的答案是数组呢?

请注意，输入数组是以「引用」方式传递的，这意味着在函数里修改输入数组对于调用者是可见的。

你可以想象内部操作如下:

// nums 是以“引用”方式传递的。也就是说，不对实参作任何拷贝 int len = removeElement(nums, val);

// 在函数里修改输入数组对于调用者是可见的。 // 根据你的函数返回的长度, 它会打印出数组中该长度范围内的所有元素。 for (int i = 0; i < len; i++) { print(nums[i]); }

AVL，红黑树学习

Mon, 09 Dec 2019 00:00:00 +0000

二叉树

定义

二叉树由节点的有限集合构成
这个有限集合或者为空集
或者为由一个根节点(root)及两棵互不相交、分别称为这个根的左子树和右子树的二叉树组成的集合

在 java 中用代码定义为：

class TreeNode {
    Object val;
    TreeNode leftNode;
    TreeNode rightNode;
    
    ...
        
}

性质

在二叉树中，第 i 层上最多有2^i^ 个节点(i>=0)
深度为 k 的二叉树至多有2^k+1^-1个节点(k>=0)
有 n 个节点的完全二叉树的高度为 log2(n+1)

它主要有五种基本形态：

满二叉树

定义：除最后一层无任何子节点外，每一层上的所有节点都有两个子节点的二叉树。

大体的意思就是：一颗二叉树的节点要么是叶子节点（也就是最后一层），要么它就要有两个子节点。如果这个二叉树的层数为 k，且节点总数是(2^k^-1)，则它就是满二叉树。

完全二叉树

定义：设二叉树的深度为 k，除第 k 层外，其他各层(1~(k-1)层)的节点都都达到最大值，其第 k 层所有的节点都连续集中在最左边，这样的树就是完全二叉树

这些是二叉树的一些基本定义以及变形，它对于数据的存储并没有要求，只是要求了结构。所以对于实际应用中还存在很多的不足，比如对于一个 n 个节点的树，判断一个节点是不是在树里面，它的复杂度还是 o(n)。所以我们下面介绍几种对于存储有要求的树。

Java注解

Fri, 06 Dec 2019 00:00:00 +0000

注解，这个经常在开发中使用到的东西，它的使用语法是怎么样的？如何去自定义一个注解呢？

什么是注解

我们在日常开发中，比如 java 中的@Override，在 springboot 中用到的@SpringBootApplication等一系列标注在类或者方法上的注解。我们添加上注解后会有对应的事件处理，比如我们的@Override注解标明这个方法是重写了父类或者接口的方法，当参数不一致、返回类型不一致等不符合重写的要求时，编译器会报错。类似的@SpringBootApplication也是标明这个项目的一个 springboot 项目，默认会启动一个 tomcat 容器等。

注解是从 jdk5 开始引入的新特性。

注解的语法

`1`	`public @interface FirstAnnotation {}`

通过@interface即可声明一个注解。

K个一组翻转链表-LeetCode25

Wed, 27 Nov 2019 00:00:00 +0000

题目描述

给你一个链表，每 k 个节点一组进行翻转，请你返回翻转后的链表。 k 是一个正整数，它的值小于或等于链表的长度。如果节点总数不是 k 的整数倍，那么请将最后剩余的节点保持原有顺序。示例 : 给定这个链表：1->2->3->4->5 当 k = 2 时，应当返回: 2->1->4->3->5 当 k = 3 时，应当返回: 3->2->1->4->5 说明 : 你的算法只能使用常数的额外空间。你不能只是单纯的改变节点内部的值，而是需要实际的进行节点交换

解题思路

首先根据 k，分隔每一组。将这一组反转，将下面的一组递归调用函数，然后将这一组的最后一个节点（就是参数中的头结点）与下一组反转后的头结点相连接。

SpringBoot使用@ControllerAdvice处理异常

Sun, 24 Nov 2019 00:00:00 +0000

背景

我们知道，当前端请求的后端程序抛出异常时，此时的 http 状态码变成了 500，并有一大串错误信息。今天要做的是整合后台返回信息，不管后台程序有异常，都能返回一个统一格式的信息，前端根据里面的信息来判断是否请求失败。

定义一下正常返回的信息如下：

{
    code:1,
    msg:"请求成功", //或其他自定义信息
    data:{
        //这里存储这个接口的返回信息
    }
}

错误的信息如下：

{
    code:-1, //可以根据不同的情况返回不同的状态码
    msg:"请求失败", //或其他自定义信息
    data:{}
}

实现

在 spring 框架下，这个要求我们可以利用 aop 去实现它，比如对我们所有的接口进行一个横切，对返回信息遇到异常后进行处理。

在 springboot 框架下，已经有现成的东西让我们可以直接去使用了。那就直接上代码了。

定义返回信息实体类：

@Data
public class ResultBean<T> {

	private String code;
	private String msg;
	private T data;

}

然后定义一个自定义异常，必须继承自RuntimeException。如果直接继承Exception则事务不一定回滚

反转一个单链表-LeetCode206

Sun, 24 Nov 2019 00:00:00 +0000

题目描述

反转一个单链表。

示例:
输入: 1->2->3->4->5->NULL
输出: 5->4->3->2->1->NULL
进阶: 你可以迭代或递归地反转链表。你能否用两种方法解决这道题？

用队列实现栈-LeetCode225

Sun, 24 Nov 2019 00:00:00 +0000

题目描述

使用队列实现栈的下列操作： push(x) – 元素 x 入栈 pop() – 移除栈顶元素 top() – 获取栈顶元素 empty() – 返回栈是否为空注意:

你只能使用队列的基本操作– 也就是 push to back, peek/pop from front, size, 和 is empty 这些操作是合法的。你所使用的语言也许不支持队列。你可以使用 list 或者 deque（双端队列）来模拟一个队列 , 只要是标准的队列操作即可。你可以假设所有操作都是有效的（例如, 对一个空的栈不会调用 pop 或者 top 操作）。

解题思路

使用两个队列

将元素添加到第一个队列中。

在获取元素时，将第一个队列中除了最后一个元素都添加到第二个队列中，剩下的这个就是要返回的元素。

将两个队列进行交换，这样在添加元素时都能放到第一个队列中。

使用一个变量来存储最后一个元素，这样在调用 top 方法时直接返回这个变量即可。
使用一个队列

添加元素时添加到队列中，然后将队列中的元素除了最后一个再重新放入一遍

在获取元素和查看元素时都拿第一个即可

用栈实现队列-LeetCode232

Sun, 24 Nov 2019 00:00:00 +0000

题目描述

使用栈实现队列的下列操作：

push(x) – 将一个元素放入队列的尾部。 pop() – 从队列首部移除元素。 peek() – 返回队列首部的元素。 empty() – 返回队列是否为空。示例:

MyQueue queue = new MyQueue();

queue.push(1); queue.push(2);
queue.peek(); // 返回 1 queue.pop(); // 返回 1 queue.empty(); // 返回 false 说明:

你只能使用标准的栈操作 – 也就是只有 push to top, peek/pop from top, size, 和 is empty 操作是合法的。你所使用的语言也许不支持栈。你可以使用 list 或者 deque（双端队列）来模拟一个栈，只要是标准的栈操作即可。假设所有操作都是有效的（例如，一个空的队列不会调用 pop 或者 peek 操作）

解题思路

栈（先进后出）来实现队列（先进先出）。

可以用两个栈来实现，第一个栈存储，当进行 peek 或 pop 操作时，将第一个栈内元素按照先进后出的原则拿出来放到第二个栈里面。这时第二个栈里面在取就是我们总的第一个元素。

两两交换链表中的节点—LeetCode24

Thu, 21 Nov 2019 00:00:00 +0000

题目描述

给定一个链表，两两交换其中相邻的节点，并返回交换后的链表。

你不能只是单纯的改变节点内部的值，而是需要实际的进行节点交换。

示例:
给定 1->2->3->4, 你应该返回 2->1->4->3.

可以看出，链表每两个一组交换了前后位置，然后再跟其他元素按照原有顺序连接。

StringBuilder为什么线程不安全?

Sun, 17 Nov 2019 00:00:00 +0000

在脉脉上看到一篇文章，StringBulider 为什么线程不安全，然后想了一下，确实不知道。

之前问string 相关问题，只了解了 string 不可变，stringbuffer 线程安全，stringbuilder 线程不安全。但却没有搞清楚为什么是不安全的，今天就去看了一下 stringbuilder 的源码，来了解一下原因。

首先来测试一下多线程下的不安全问题：

public static void main(String[] args) {
    StringBuilder stringBuilder = new StringBuilder();

    for (int i = 0; i < 100000; i++) {
        new Thread(() -> stringBuilder.append("a")).start();
    }

    System.out.println(stringBuilder.length());

}

这个方法最终的理想结果应该是 100000，但是当我们多运行几次，发现他的结果出错了！结果变成了99999或者更小的数值。有时候甚至还抛出了数组越界异常（概率极小）。

整数反转—LeetCode7

Fri, 15 Nov 2019 00:00:00 +0000

题目描述

给出一个 32 位的有符号整数，你需要将这个整数中每位上的数字进行反转。

示例 1:

输入: 123 输出: 321 示例 2:

输入: -123 输出: -321 示例 3:

输入: 120 输出: 21 注意:

假设我们的环境只能存储得下 32 位的有符号整数，则其数值范围为 [−231, 231 − 1]。请根据这个假设，如果反转后整数溢出那么就返回 0。

题目中给出了条件，我们只能存储32位有符号整数，如果溢出后则返回0，避免出现溢出错误

TreeMap源码学习

Tue, 12 Nov 2019 00:00:00 +0000

之前看过了HashMap,LinkedHashMap的源码，这次来看一下TreeMap的源码。

从这个名字就能看出，TreeMap底层使用的是树来进行存储的。

变量

//比较器，用于左右子树的判断。
//正常情况下，左子树为 1，父节点为 2，右子树为 3。如果比较器设置 3<1<2。则左子树为3，父节点为 1，右子树为 2。
private final Comparator<? super K> comparator;
//根节点
private transient Entry<K,V> root;
//容量
private transient int size = 0;
//修改的次数，在迭代和序列化时用到
private transient int modCount = 0;

看一下 root 节点的数据结构:

static final class Entry<K,V> implements Map.Entry<K,V> {
        K key;
        V value;
        Entry<K,V> left;
        Entry<K,V> right;
        Entry<K,V> parent;
        boolean color = BLACK;

	...
}

由于有一个color=BLACK属性，所以底层数据结构应该是红黑树

回文数—LeetCode9

Thu, 07 Nov 2019 00:00:00 +0000

题目描述

判断一个整数是否是回文数。回文数是指正序（从左向右）和倒序（从右向左）读都是一样的整数。

示例 1:

输入: 121 输出: true 示例 2:

输入: -121 输出: false 解释: 从左向右读, 为 -121 。从右向左读, 为 121- 。因此它不是一个回文数。示例 3:

输入: 10 输出: false 解释: 从右向左读, 为 01 。因此它不是一个回文数。进阶:

你能不将整数转为字符串来解决这个问题吗？

从示例2中可以看出，负数不是回文数，可以先对此进行判断。

而提示中有一个提示，能否不使用字符串来解决这个问题，那么使用字符串肯定是可以解决这个问题的。

翻转二叉树—LeetCode226

Fri, 01 Nov 2019 00:00:00 +0000

题目描述

翻转一棵二叉树。

示例：

输入：

     4
   /   \
  2     7
 / \   / \
1   3 6   9

输出：

     4
   /   \
  7     2
 / \   / \
9   6 3   1

代码实现

public TreeNode invertTree(TreeNode root) {
    if (root == null) {
        return null;
    }
    TreeNode right = invertTree(root.right);
    TreeNode left = invertTree(root.left);
    root.left = right;
    root.right = left;
    return root;
}

二叉搜索树的范围和-LeetCode938

Thu, 31 Oct 2019 00:00:00 +0000

题目描述

给定二叉搜索树的根结点 root，返回 L 和 R（含）之间的所有结点的值的和。

二叉搜索树保证具有唯一的值。

示例 1：

输入：root = [10,5,15,3,7,null,18], L = 7, R = 15 输出：32 示例 2：

输入：root = [10,5,15,3,7,13,18,1,null,6], L = 6, R = 10 输出：23

提示：

树中的结点数量最多为 10000 个。最终的答案保证小于 2^31。

三数之和—LeetCode15

Fri, 25 Oct 2019 00:00:00 +0000

题目描述

给你一个包含 n 个整数的数组 nums，判断 nums 中是否存在三个元素 a，b，c ，使得 a + b + c = 0 ？

请你找出所有满足条件且不重复的三元组。

注意：答案中不可以包含重复的三元组。

示例：

给定数组 nums = [-1, 0, 1, 2, -1, -4]，

满足要求的三元组集合为： [ [-1, 0, 1], [-1, -1, 2] ]

这个题目中有一个条件，答案中不可以包含重复的三元组，即给定的数组中会有重复值，所以答案可能会存在重复答案，当答案存在时，不在添加到答案中

布隆过滤器

Tue, 15 Oct 2019 00:00:00 +0000

布隆过滤器

一个很长的二进制向量和一个映射函数

布隆过滤器可以用于检索一个元素是否在一个集合中

它的优点是空间效率和查询时间都远远超过一般的算法，缺点是有一定的误识别率和删除困难。

先来看这张图：

步骤一：对参数 A经过映射函数得到一个二进制向量，进行标记。再对参数B进行映射，这时他们两个存在相同的向量位置（类似于哈希冲突）。

步骤二：检查参数C是否在过滤器中，经过映射函数得到 C 的向量，去过滤器中查看，得到结果 C 不在过滤器中，并且是肯定不在。

步骤三：检查参数 D是否在过滤器中，经过映射函数得到 D 的向量，发现 D 的向量已经存在于过滤器中，但之前并没有插入 D 这个参数，所以从这里可以看出布隆过滤器在判断参数在过滤器中有一定的误识别率，但是在判断参数不在过滤器中没有问题。

步骤四：删除参数B，从图中也可以很明显的看出，A,B 存在交集，那么删除 B 的时候怎么删除。这就是删除困难。

反转部分单向链表

Tue, 15 Oct 2019 00:00:00 +0000

题目

给定一个链表, 再给定起止位置, 要求将起止位置之间的链表进行反转, 其他部分不变

解答

先移动到开始位置前一个位置此节点的next节点需要修改为反转后的头节点
反转给定位置的链表
将两部分的链表相连

public Node reversePart(Node head, int from, int to) {
		Node startNode = head;
		Node startNodePre = null;
		for (int i = 0; i < from - 1; i++) {
			startNodePre = startNode;
			startNode = startNode.next;
		}
		Node cur = startNode;
		Node pre = null;
		for (int i = 0; i <= (to - from); i++) {
			Node next = cur.next;
			cur.next = pre;
			pre = cur;
			cur = next;
		}
		Node headRes = startNodePre == null ? pre : head;
		if (startNodePre != null) {
			startNodePre.next = pre;
		}
		startNode.next = cur;
		return headRes;
	}

链表

Tue, 15 Oct 2019 00:00:00 +0000

链表

与数组一样也是一种线性数据结构

查找的速度：O(n)，要查找一个元素需要从头结点进行遍历

插入的速度：O(1)，删除的速度：O(1)

删除和插入的情况多，或者不知道元素的数量时应该要考虑使用链表的数据结构。

单向链表

每个结点有一个next属性，指向下一个节点
双向链表

每个结点除了有next属性指向下一个节点外，还有一个pre属性指向上一个节点
环

当最后一个元素的 next 结点指向第一个结点，就构成了一个环。

习题

两个单链表生成相加链表

Tue, 15 Oct 2019 00:00:00 +0000

题目

假设链表中每一个节点的值都在0~9之间, 那么链表整体就可以代表一个整数

例如: 9→3→7, 可以代表整数937

给定两个这种链表的头节点, 请生成代表两个整数相加值的结果链表.

例如: 链表1为9→3→7. 链表2为6→3. 最终生成的结果链表为1→0→0→0

题解

有两种方式

借助栈
将链表反转后再进行相加

借助栈


public Node addLists1(Node head1, Node head2) {
		Stack<Integer> s1 = new Stack<>();
		Stack<Integer> s2 = new Stack<>();
		while (head1 != null) {
			s1.push(head1.value);
			head1 = head1.next;
		}
		while (head2 != null) {
			s2.push(head2.value);
			head2 = head2.next;
		}
		Node node = null;
		Node pre = null;
		int ca = 0;
		while (!s1.isEmpty() || !s2.isEmpty()) {
			int n1 = s1.isEmpty() ? 0 : s1.pop();
			int n2 = s2.isEmpty() ? 0 : s2.pop();
			int n = n1 + n2 + ca;
			ca = n / 10;
			pre = node;
			node = new Node(n % 10);
			node.next = pre;
		}
		if (ca == 1) {
			pre = node;
			node = new Node(1);
			node.next = pre;
		}
		return node;
	}

反转链表

public Node addLists2(Node head1, Node head2) {
		head1 = reverseList(head1);
		head2 = reverseList(head2);

		Node c1 = head1, c2 = head2;
		Node node = null, pre = null;
		int ca = 0;
		while (c1 != null || c2 != null) {
			int n1 = c1 != null ? c1.value : 0;
			int n2 = c2 != null ? c2.value : 0;
			int n = n1 + n2 + ca;
			ca = n / 10;
			pre = node;
			node = new Node(n % 10);
			node.next = pre;
			c1 = c1 != null ? c1.next : null;
			c2 = c2 != null ? c2.next : null;
		}
		if (ca == 1) {
			pre = node;
			node = new Node(1);
			node.next = pre;
		}
		// 将head1, head2再反转回去
		return node;
	}

	private Node reverseList(Node head) {
		Node pre = null;
		while (head != null) {
			Node next = head.next;
			head.next = pre;
			pre = head;
			head = next;
		}
		return pre;
	}

判断一个链表是否为回文结构

Tue, 15 Oct 2019 00:00:00 +0000

题目

回文结构是指从中间节点的两边对称. 如 1→2-3→2→1.

给定一个链表, 判断链表是否为回文结构

解答

先使用双指针, 将链表从中间节点分为两部分.

将右边链表插入到栈中.

从链表头部, 即左边链表的头部开始遍历. 如果与栈顶元素不一致, 则不是回文结构

public boolean isPalindrome(Node head) {
		if (head == null || head.next == null) {
			return true;
		}
		// 找到右边部分的开始节点
		Node temp = head, right = head.next;
		while (temp.next != null && temp.next.next != null) {
			temp = temp.next.next;
			right = right.next;
		}
		// 将右边部分写入栈中
		Stack<Node> stack = new Stack<>();
		while (right != null) {
			stack.push(right);
			right = right.next;
		}
		// 对比左边部分与右边部分
		while (!stack.isEmpty()) {
			if (head.value != stack.pop().value) {
				return false;
			}
			head = head.next;
		}
		return true;
	}

设计一个有getMin功能的栈

Tue, 15 Oct 2019 00:00:00 +0000

题目：

实现一个特殊的栈，在实现栈的基本功能的基础上，再实现返回栈内最小元素的操作

要求：

pop, push, getMin操作的时间复杂度都是O(1)
设计的栈类型可以使用现成的栈结构

解答：

使用辅助栈

使用两个栈，一个栈完成基础的操作，这样pop，push的时间复杂度都是O(1)。然后使用辅助栈完成getMin的功能。

辅助栈内的存储也有两种方式：

辅助栈内元素的数量与基础栈内元素数量一致，对应位置上存储当前时刻的最小值。
辅助栈内的元素数量少于基础栈内元素数量，如果对应位置上的最小值已存在则不进行存储。

实现1：

public class GetMin1 {

	private Stack<Integer> stackData;
	private Stack<Integer> stackMin;

	private GetMin1() {
		stackData = new Stack<Integer>();
		stackMin = new Stack<Integer>();
	}

	public void push(int num) {
		if (this.stackMin.isEmpty()) {
			// 如果最小栈为空，直接放
			this.stackMin.push(num);
		} else if (num < this.getMin()) {
			// 如果值小于现在的最小值，那么插入值就是当前位置的最小值，将插入值写入到最小栈中
			this.stackMin.push(num);
		} else {
			// 否则当前位置的最小值就是最小栈的第一个元素，重新写入一次
			int min = this.stackMin.peek();
			this.stackMin.push(min);
		}
		this.stackData.push(num);
	}

	public int pop() {
		if (this.stackData.isEmpty()) {
			throw new RuntimeException("empty stack!");
		}
		this.stackMin.pop();
		return this.stackData.pop();
	}

	public int getMin() {
		if (this.stackMin.isEmpty()) {
			throw new RuntimeException("empty stack!");
		}
		return this.stackMin.peek();
	}

}

实现2:

数组

Tue, 15 Oct 2019 00:00:00 +0000

数组

定义

它是一种线性数据结构，在内存里是连续的存储区域。在声明数组时需要声明他的初始容量。

查找的速度：O(1)，新增的速度：O(n)，删除的速度：O(n)

查找时根据内存地址就可以直接找到对应的数据，而向中间插入和删除时需要将后面的元素挪动位置，所以速度比较慢，为 O(n)

习题

算法与数据结构

Tue, 15 Oct 2019 00:00:00 +0000

最近在看极客时间覃超的《算法面试通关 40 讲》，也一起看了一些数据结构，正好在这里进行一下整理。

主要分为数据结构和算法两大章节，每个章节里面都会先结合自己的理解对它的定义进行一下解释，然后会拿出例题来进行实战。

数据结构

数组

链表

队列

先入先出（first in first out FIFO）

习题：用栈实现队列

普通队列

优先队列

堆栈

后入先出(last in first out LIFO)

习题：用队列实现栈

树

链表是一种特殊的树，当每个链表节点的链表变成多个时就变成了树

二叉搜索树（binary search tree BST）

性质：

左子树上所有节点的值均小于它的根节点的值
右子树上所有节点的值均大于它的根节点的值；
左，右子树也分别满足以上性质

AVL,红黑树学习

红黑树

手写红黑树的简单实现

B 树

B+树

MySQL 的 Innodb 中使用的索引就是采用的 B+树的数据结构进行存储的。

移调K位数字

Tue, 15 Oct 2019 00:00:00 +0000

给定一个以字符串表示的非负整数num和一个整数k, 移除这个数中的k位数字, 使得剩下的数字最小.

题解

删除规则为

当左侧数字大于当前数字时, 则将左侧数字删除
如果全部数字是从小到达排列, 即全部左侧数字小于右侧数字. 则从尾部开始删除

public static String removeKdigits(String num, int k) {
		Deque<Character> deque = new LinkedList<Character>();
		int length = num.length();
		for (int i = 0; i < length; ++i) {
			char digit = num.charAt(i);
			// 如果上一位数字比当前位数字大，则删除上一位数字
			// 并将需要删除的位数减1，当需要删除的位数为0时不再进行删除
			while (!deque.isEmpty() && k > 0 && deque.peekLast() > digit) {
				deque.pollLast();
				k--;
			}
			//将当前位放入栈中
			deque.offerLast(digit);
		}
		// 如果k仍然大于0，则从后向前删除k位
		for (int i = 0; i < k; ++i) {
			deque.pollLast();
		}
		// 将剩下的元素拼接成结果
		// 需要注意的一点是，可能存在0开头的数字，这时需要将0去掉，即结果为01时需要返回1
		StringBuilder ret = new StringBuilder();
		boolean leadingZero = true;
		while (!deque.isEmpty()) {
			char digit = deque.pollFirst();
			if (leadingZero && digit == '0') {
				continue;
			}
			leadingZero = false;
			ret.append(digit);
		}
		return ret.length() == 0 ? "0" : ret.toString();
	}

用递归函数和栈操作逆序一个栈

Tue, 15 Oct 2019 00:00:00 +0000

题目：

实现一个函数，将栈内元素的顺序进行翻转。如果当前栈内元素顺序为：1，2，3，4，5. 在调用这个函数后顺序为：5，4，3，2，1.

要求：

只能使用递归函数来实现，不能使用其他的数据结构。

解答：

该函数需要将栈内的元素顺序进行反转, 并且只能使用递归来实现.

我们需要分为两部分来实现:

实现一个通过递归来获取当前栈内最后一个元素的函数, 并保证其他元素顺序不变
递归调用获取最后一个元素的函数直至栈为空, 此时获取的元素为栈内的第一个元素, 将其插入栈中, 然后将其他元素再写会栈内. 完成逆序.

public class ReverseStack {

	public void reverse(Stack<Integer> stack) {
		if (stack.isEmpty()) {
			return;
		}
		int last = getAndRemoveLatestElement(stack);
		reverse(stack);
		stack.push(last);
	}

	private int getAndRemoveLatestElement(Stack<Integer> stack) {
		Integer res = stack.pop();
		if (stack.isEmpty()) {
			return res;
		} else {
			int last = getAndRemoveLatestElement(stack);
			stack.push(res);
			return last;
		}
	}

}

设计模式

Mon, 14 Oct 2019 00:00:00 +0000

复杂度无法被消除, 只能被转移.

总共有23种设计模式, 它们可以分为以下三类:

创建性
结构性
行为型这三类又分别有以下几种模式:
创建型

[[Blog-Posts/coding/design/单例模式]]
[[Blog-Posts/coding/design/工厂模式]]
[[Blog-Posts/coding/design/建造者模式]]
[[Blog-Posts/coding/design/原型模式]]

结构性

[[Blog-Posts/coding/design/代理模式]]
[[Blog-Posts/coding/design/桥接模式]]
[[Blog-Posts/coding/design/装饰器模式]]
[[Blog-Posts/coding/design/门面模式]]
[[Blog-Posts/coding/design/组合模式]]
[[Blog-Posts/coding/design/享元模式]]

行为型

[[Blog-Posts/coding/design/观察者模式]]
[[Blog-Posts/coding/design/模板模式]]
[[Blog-Posts/coding/design/策略模式]]
[[Blog-Posts/coding/design/职责链模式]]
[[Blog-Posts/coding/design/状态模式]]
[[Blog-Posts/coding/design/迭代器模式]]
[[Blog-Posts/coding/design/访问者模式]]
[[Blog-Posts/coding/design/备忘录模式]]
[[Blog-Posts/coding/design/命令模式]]
[[Blog-Posts/coding/design/解释器模式]]
[[Blog-Posts/coding/design/中介模式]]

代理、桥接、装饰器、适配器4种设计模式的区别

这4种是比较常见的结构型设计模式, 它们的代码结构非常相似. 笼统来说, 它们都可以被称为Wrapper模式, 也就是通过Wrapper类二次封装原始类.

尽管代码结构相似, 但是这4种设计模式的用意完全不同, 也就是说要解决的问题, 应用场景.

代理模式: 代理模式在不改变原始类接口的条件下, 为原始类定义一个代理类, 主要目的是控制访问, 而为加强功能.

桥接模式: 桥接模式的目的是将接口和实现分离, 从而让它们可以较为容易、也相对独立的加以改变.

装饰器模式: 装饰器模式在不改变原始类接口的情况下, 对原始类功能进行增强, 并且支持多个装饰器的嵌套使用.

适配器模式: 适配器模式是一种事后的补救策略. 适配器提供跟原始类不同的接口, 而代理模式, 装饰器模式提供的都是跟原始类相同的接口.

设计模式-备忘录模式

Mon, 14 Oct 2019 00:00:00 +0000

也叫快照模式, 在不违背封装原则的前提下, 捕获一个对象的内部状态, 并在该对象之外保存这个状态, 以便之后恢复对象为先前的状态.

设计模式-策略模式

Mon, 14 Oct 2019 00:00:00 +0000

策略模式最场景的应用场景是利用它来避免冗长的if-else或switch分支判断. 还可以提供框架的扩展点.

定义一组算法类, 将每个算法分别封装起来, 让他们可以互相替换. 策略模式可以使算法的变化独立与使用它们的客户端.

定义一个接口, 每个子类有不同场景下的实现, 并且通过工厂模式来进行子类的创建. 例如实现一个对不同文件大小的排序算法, 首先定义一个排序接口, 然后创建大中小三种文件的子类, 再创建一个工厂模式定义文件大小与具体子类的关系.

设计模式-代理模式

Mon, 14 Oct 2019 00:00:00 +0000

原理解析

代理模式(Proxy Design Pattern)在不改变原始类(或叫被代理类)代码的情况下, 通过引入代理类来给原始类附加功能.

我们可以通过继承或其他方式来实现静态代理, 来实现对原始类的功能扩展.

动态代理

如果需要代理的类太多, 使用静态代理就需要为每个类都创建一个代理类, 这样过于复杂, 我们可以使用动态代理来实现. 事先不为每个原始类编写代理类, 而是在运行时, 动态的创建原始类对应的代理类, 然后在系统中用代理类替换掉原始类.

Spring AOP底层的实现原理就是基于动态代理, 用户配置好需要给哪些类创建代理, 并定义好在执行原始类的业务代码前后执行哪些附加功能. Spring为这些类创建动态代理对象, 并在JVM中替代原始类对象.

代理模式的应用场景

业务系统的非功能性需求开发

比如需要开发一些非功能性的需求, 监控, 统计, 鉴权, 限流等等. 将这些附加功能与业务功能解耦, 放到代理类中同样处理.
代理模式在RPC, 缓存中的应用

实际上RPC框架也可以看作一种代理模式. 通过远程代理, 将网络通信, 数据编解码等细节隐藏起来.

同样在缓存中, 我们对于某些接口希望在一定时间内的相同参数使用缓存中的结果, 而不是进行数据库查询或者其他计算, 我们可以利用代理模式, 先从缓存中查询, 如果查询不到结果再去走原始类的逻辑.

代理、桥接、装饰器、适配器4种设计模式的区别

设计模式-单例模式

Mon, 14 Oct 2019 00:00:00 +0000

概念

一个类只允许创建一个对象（或者实例），那这个类就是一个单例类

为什么要使用单例

有些数据在系统中只应该保存一份，当使用多个对象时会造成一些错误。有一些资源访问冲突时也可以使用单例模式来解决。

实现方式

由于对象只能有一个，所以构造函数的权限必须是private私有的，这样外部就无法通过new来创建实例

还有一些需要关注的点

创建对象的线程安全问题
是否支持延迟加载
获取实例方法的性能是否高

饿汉式

优点：写法简单。在类装载时就完成了实例化。线程安全

缺点：由于在类装载时就完成了实例化，如果从始至终都没有用到这个实例，会造成内存浪费

 class Single {
 /**
  * 设置成私有的，保证无法在其它类中使用 new 关键字进行实例化
  */
 private Single() {}
 
 private final static Single INSTANCE = new Single();
 
     /**
  * 从外界获取实例的唯一方法，从这个方法拿到的实例肯定是全局唯一的
  * @return
  */
 public static Single getInstance() {
 return INSTANCE;
 }
 
 }
 
 /**
  * 与上面的类似，用了静态代码块，不同的代码写法其他完全一样
  */
 class SingleTest2 {
 
 private SingleTest2() {}
 
 private static SingleTest2 SINGLE_TEST_2;
 
 static {
 SINGLE_TEST_2 = new SingleTest2();
 }

 public static SingleTest2 getInstance() {
 return SINGLE_TEST_2;
 }
 }

懒汉式

在需要用到实例时才进行初始化，所以不会造成内存浪费，但多线程情况下会出现多个实例的情况

设计模式-迭代器模式

Mon, 14 Oct 2019 00:00:00 +0000

迭代器模式将集合中的遍历操作从集合类中拆分出来, 放到迭代器类中, 让两者的职责更加单一.

迭代器模式的优势

可以封装一些复杂的遍历逻辑, 比如树的各种遍历方式(BFS, DFS, 前序等等)
后期如果需要变更遍历方式, 只需要替换掉迭代器的实现.

设计模式-访问者模式

Mon, 14 Oct 2019 00:00:00 +0000

允许一个或者多个操作应用到一组对象上, 解耦操作和对象本身

访问者模式针对到是一组类型不同的对象. 不过, 尽管这组对象的类型是不同的, 但是, 它们继承相同的父类或者实现相同的接口. 在不同的应用场景下, 我们需要对这组对象进行一系列不相关的业务操作, 但为了避免不断添加功能导致类不断膨胀, 职责越来越不单一, 以及避免频繁地添加功能导致的频繁代码修改, 我们使用访问者模式, 将对象与操作解耦, 将这些业务操作抽离出来, 定义在独立细分的访问者类中.

public abstract class ResourceFile {
  protected String filePath;
  public ResourceFile(String filePath) {
    this.filePath = filePath;
  }
  abstract public void accept(Visitor vistor);
}

public class PdfFile extends ResourceFile {
  public PdfFile(String filePath) {
    super(filePath);
  }

  @Override
  public void accept(Visitor visitor) {
    visitor.visit(this);
  }

  //...
}
//...PPTFile、WordFile跟PdfFile类似，这里就省略了...

public interface Visitor {
  void visit(PdfFile pdfFile);
  void visit(PPTFile pdfFile);
  void visit(WordFile pdfFile);
}

public class Extractor implements Visitor {
  @Override
  public void visit(PPTFile pptFile) {
    //...
    System.out.println("Extract PPT.");
  }

  @Override
  public void visit(PdfFile pdfFile) {
    //...
    System.out.println("Extract PDF.");
  }

  @Override
  public void visit(WordFile wordFile) {
    //...
    System.out.println("Extract WORD.");
  }
}

public class Compressor implements Visitor {
  @Override
  public void visit(PPTFile pptFile) {
    //...
    System.out.println("Compress PPT.");
  }

  @Override
  public void visit(PdfFile pdfFile) {
    //...
    System.out.println("Compress PDF.");
  }

  @Override
  public void visit(WordFile wordFile) {
    //...
    System.out.println("Compress WORD.");
  }

}

public class ToolApplication {
  public static void main(String[] args) {
    Extractor extractor = new Extractor();
    List<ResourceFile> resourceFiles = listAllResourceFiles(args[0]);
    for (ResourceFile resourceFile : resourceFiles) {
      resourceFile.accept(extractor);
    }

    Compressor compressor = new Compressor();
    for(ResourceFile resourceFile : resourceFiles) {
      resourceFile.accept(compressor);
    }
  }

  private static List<ResourceFile> listAllResourceFiles(String resourceDirectory) {
    List<ResourceFile> resourceFiles = new ArrayList<>();
    //...根据后缀(pdf/ppt/word)由工厂方法创建不同的类对象(PdfFile/PPTFile/WordFile)
    resourceFiles.add(new PdfFile("a.pdf"));
    resourceFiles.add(new WordFile("b.word"));
    resourceFiles.add(new PPTFile("c.ppt"));
    return resourceFiles;
  }
}

设计模式-工厂模式

Mon, 14 Oct 2019 00:00:00 +0000

工厂模式可以分为三种更加细分的类型: 简单工厂, 工厂方法和抽象工厂.

什么时候用工厂方法

当创建逻辑比较复杂时, 可以考虑使用工厂模式, 封装对象的创建过程, 将对象的创建和使用相分离. 对象创建逻辑比较复杂大概为这两种情况:

代码中存在if/else的分支判断, 动态地根据不同类型创建不同的对象. 针对这种情况我们就可以考虑使用工厂模式, 来将这一大坨if/esle创建对象的逻辑抽离出来, 放到工厂类中
尽管我们不需要根据不同的类型创建不同的对象, 但是, 单个对象的创建过程比较负责, 比如需要组合其他类对象, 做各种初始化操作. 在这种情况下, 也可以考虑使用工厂模式, 将对象的创建过程封装到工厂类中.

工厂模式的作用大概是这四个:

封装变化: 创建逻辑有可能变化, 封装成工厂类之后, 创建逻辑的变更对调用者透明
代码复用: 创建代码抽离到独立的工厂类之后可以复用
隔离复杂性: 封装复杂的创建逻辑, 调用者无需了解如何创建对象
控制复杂度: 将创建代码抽离出来, 让原本的函数或类职责更单一, 代码更简洁

简单工厂

在下面这段代码中, 我们根据配置文件的后缀(json, xml, yaml), 选择不同的解析器. 将存储在文件中的配置解析成内存对象RuleConfig.

public class RuleConfigSource {
  public RuleConfig load(String ruleConfigFilePath) {
    String ruleConfigFileExtension = getFileExtension(ruleConfigFilePath);
    IRuleConfigParser parser = RuleConfigParserFactory.createParser(ruleConfigFileExtension);
    if (parser == null) {
      throw new InvalidRuleConfigException(
              "Rule config file format is not supported: " + ruleConfigFilePath);
    }

    String configText = "";
    //从ruleConfigFilePath文件中读取配置文本到configText中
    RuleConfig ruleConfig = parser.parse(configText);
    return ruleConfig;
  }

  private String getFileExtension(String filePath) {
    //...解析文件名获取扩展名，比如rule.json，返回json
    return "json";
  }
}

public class RuleConfigParserFactory {
  public static IRuleConfigParser createParser(String configFormat) {
    IRuleConfigParser parser = null;
    if ("json".equalsIgnoreCase(configFormat)) {
      parser = new JsonRuleConfigParser();
    } else if ("xml".equalsIgnoreCase(configFormat)) {
      parser = new XmlRuleConfigParser();
    } else if ("yaml".equalsIgnoreCase(configFormat)) {
      parser = new YamlRuleConfigParser();
    } else if ("properties".equalsIgnoreCase(configFormat)) {
      parser = new PropertiesRuleConfigParser();
    }
    return parser;
  }
}

将创建RuleParser单独抽取到一个单独的类中, 让这个类只负责对象的创建, 这就是简单工厂模式的实现.

设计模式-观察者模式

Mon, 14 Oct 2019 00:00:00 +0000

Observer Design Pattern也被称为发布订阅模式(Publish-Subscribe Design Pattern)

在对象之间订阅一个一对多的依赖, 当一个对象状态改变的时候, 所以依赖的对象都会自动收到通知.

设计模式-建造者模式

Mon, 14 Oct 2019 00:00:00 +0000

我们明明可以直接使用构造函数或者配合set方法就能创建对象, 为什么还需要通过建造者模式来创建呢.

建造者模式和工厂模式都可以创建对象, 他们之间的区别是什么?

为什么需要建造者模式

在某些配置类中, 有大量的参数需要传入, 并且这些参数有一些是必须的, 有一些是可选的.

某些参数之间有依赖关系, 比如当用户设置了A, 那么就必须设置B等等.

并且我们希望类对象是不可变对象, 也就是说对象在创建好之后, 就不能修改内部的属性值. 要实现这个功能, 我们就不能暴露set方法.

这时我们对这个类的创建虽然还可以通过构造函数来进行创建, 但是复杂度和可读性都不友好. 这时就可以使用建造者模式来进行对象的创建.

将校验逻辑放到Builder类中, 先创建建造者, 并通过set方法来设置建造者的变量值, 然后在build方法真正创建对象之前, 做集中的校验, 校验通过之后才会创建对象. 并且将类的构造函数设置成private, 这样就只能通过建造者来创建对象. 同时将不再提供set方法, 这样创建出来的对象就是不可变对象了

实现

 public class ResourcePoolConfig {
   private String name;
   private int maxTotal;
   private int maxIdle;
   private int minIdle;
 
   private ResourcePoolConfig(Builder builder) {
     this.name = builder.name;
     this.maxTotal = builder.maxTotal;
     this.maxIdle = builder.maxIdle;
     this.minIdle = builder.minIdle;
   }
   //...省略getter方法...
 
   //我们将Builder类设计成了ResourcePoolConfig的内部类。
   //我们也可以将Builder类设计成独立的非内部类ResourcePoolConfigBuilder。
   public static class Builder {
     private static final int DEFAULT_MAX_TOTAL = 8;
     private static final int DEFAULT_MAX_IDLE = 8;
     private static final int DEFAULT_MIN_IDLE = 0;
 
     private String name;
     private int maxTotal = DEFAULT_MAX_TOTAL;
     private int maxIdle = DEFAULT_MAX_IDLE;
     private int minIdle = DEFAULT_MIN_IDLE;
 
     public ResourcePoolConfig build() {
       // 校验逻辑放到这里来做，包括必填项校验、依赖关系校验、约束条件校验等
       if (StringUtils.isBlank(name)) {
         throw new IllegalArgumentException("...");
       }
       if (maxIdle > maxTotal) {
         throw new IllegalArgumentException("...");
       }
       if (minIdle > maxTotal || minIdle > maxIdle) {
         throw new IllegalArgumentException("...");
       }
 
       return new ResourcePoolConfig(this);
     }
 
     public Builder setName(String name) {
       if (StringUtils.isBlank(name)) {
         throw new IllegalArgumentException("...");
       }
       this.name = name;
       return this;
     }
 
     public Builder setMaxTotal(int maxTotal) {
       if (maxTotal <= 0) {
         throw new IllegalArgumentException("...");
       }
       this.maxTotal = maxTotal;
       return this;
     }
 
     public Builder setMaxIdle(int maxIdle) {
       if (maxIdle < 0) {
         throw new IllegalArgumentException("...");
       }
       this.maxIdle = maxIdle;
       return this;
     }
 
     public Builder setMinIdle(int minIdle) {
       if (minIdle < 0) {
         throw new IllegalArgumentException("...");
       }
       this.minIdle = minIdle;
       return this;
     }
   }
 }
 
 // 这段代码会抛出IllegalArgumentException，因为minIdle>maxIdle
 ResourcePoolConfig config = new ResourcePoolConfig.Builder()
         .setName("dbconnectionpool")
         .setMaxTotal(16)
         .setMaxIdle(10)
         .setMinIdle(12)
         .build();

为了避免这种无效状态的存在, 我们就需要使用构造函数一次性初始化好所有的成员变量. 如果构造函数参数过多, 我们就需要考虑使用建造者模式, 先设置建造者的变量, 然后再一次性的创建对象, 让对象一直处于有效状态.

设计模式-解释器模式

Mon, 14 Oct 2019 00:00:00 +0000

解释器模式为某个语言定义它的语法表示, 并定义一个解释器用来处理这个语法. 只会在一些特定的领域才会被用到: 比如编译器, 规则引擎, 正则表达式等.

设计模式-门面模式

Mon, 14 Oct 2019 00:00:00 +0000

门面模式主要用在接口设计方面使用.

在实际工作中, 为了保证接口的可复用性(通用性), 会将接口尽量设计的细粒度一点, 职责单一一点.

但是如果接口的粒度过小, 在开发一个业务功能时, 就会导致需要调用n多细粒度的接口才能完成.

相反, 如果接口的粒度太大, 一个接口做了n多件事情, 就会导致接口不够通用, 可复用性不好.

接口模式就是解决这种情况.

门面模式为子系统提供一组统一的接口, 定义一组高层接口让子系统更容易使用.

就是将多个小粒度的接口做一层包装, 做多个接口的整合.

门面模式的应用场景

解决易用性问题
解决性能问题
解决分布式问题

设计模式-命令模式

Mon, 14 Oct 2019 00:00:00 +0000

命令模式将请求(命令)封装成一个对象, 这样可以使用不同的请求参数化其他对象(将不同请求依赖注入到其他对象), 并且能够支持请求(命令)的排队执行, 记录日志, 撤销等(附加控制)功能.

命令模式用的最核心的实现手法, 是将函数封装成对象.

设计模式-模板模式

Mon, 14 Oct 2019 00:00:00 +0000

模版模式主要用来解决复用和扩展两个问题

模版模式在一个方法中定义一个算法骨架, 并将某些步骤推迟到子类中实现. 模版方法模式可以让子类在不改变算法整体结构的情况下, 重新定义算法中的某些步骤.

在Java中, 可以理解为abstract抽象类, 在父类中定义一个方法, 这个方法中的某一步需要子类去实现.

public abstract class AbstractClass {
  public final void templateMethod() {
    //...
    method1();
    //...
    method2();
    //...
  }
  
  protected abstract void method1();
  protected abstract void method2();
}

public class ConcreteClass1 extends AbstractClass {
  @Override
  protected void method1() {
    //...
  }
  
  @Override
  protected void method2() {
    //...
  }
}

public class ConcreteClass2 extends AbstractClass {
  @Override
  protected void method1() {
    //...
  }
  
  @Override
  protected void method2() {
    //...
  }
}

AbstractClass demo = ConcreteClass1();
demo.templateMethod();

设计模式-桥街模式

Mon, 14 Oct 2019 00:00:00 +0000

抽离一套接口, 下面可以有多种实现.

原理解析

桥接模式, 也叫做桥梁模式(Bridge Design Pattern), 将抽象和实现解耦, 让他们可以独立变化.

这里的抽象, 并非指的是"抽象类"或"接口”, 而是被抽象出来的一套“类库”, 它只包含骨架代码, 真正的业务逻辑需要委派给定义中的“实现”来完成. 这里的“实现”, 也并非“接口的实现类”, 而是一套独立的”类库“. ”抽象“和”实现“独立开发, 通过对象之间的组合关系, 组装在一起.

一个例子就是Java中的JDBC与其他数据库的关系.

JDBC定义了一个通用的接口, 其他数据库实现这一套接口. 在执行数据库操作时, JDBC将数据库的操作委托给真正执行的实现类来执行.

举例

使用桥接模式来实现一套告警机制: 根据不同的告警规则, 触发不同类型的告警. 并且告警支持多种通知渠道.

 public interface MsgSender {
   void send(String message);
 }
 
 public class TelephoneMsgSender implements MsgSender {
   private List<String> telephones;
 
   public TelephoneMsgSender(List<String> telephones) {
     this.telephones = telephones;
   }
 
   @Override
   public void send(String message) {
     //...
   }
 
 }
 
 public class EmailMsgSender implements MsgSender {
   // 与TelephoneMsgSender代码结构类似，所以省略...
 }
 
 public class WechatMsgSender implements MsgSender {
   // 与TelephoneMsgSender代码结构类似，所以省略...
 }
 
 public abstract class Notification {
   protected MsgSender msgSender;
 
   public Notification(MsgSender msgSender) {
     this.msgSender = msgSender;
   }
 
   public abstract void notify(String message);
 }
 
 public class SevereNotification extends Notification {
   public SevereNotification(MsgSender msgSender) {
     super(msgSender);
   }
 
   @Override
   public void notify(String message) {
     msgSender.send(message);
   }
 }
 
 public class UrgencyNotification extends Notification {
   // 与SevereNotification代码结构类似，所以省略...
 }
 public class NormalNotification extends Notification {
   // 与SevereNotification代码结构类似，所以省略...
 }
 public class TrivialNotification extends Notification {
   // 与SevereNotification代码结构类似，所以省略...
 }

代理、桥接、装饰器、适配器4种设计模式的区别

设计模式-适配器模式

Mon, 14 Oct 2019 00:00:00 +0000

Adapter Design Pattern, 这个模式用来做适配, 将不兼容的接口转化为可兼容的接口.

适配器模式有两种实现方式:

类适配器, 使用继承关系来实现
对象适配器, 使用组合关系来实现

// 类适配器: 基于继承
public interface ITarget {
  void f1();
  void f2();
  void fc();
}

public class Adaptee {
  public void fa() { //... }
  public void fb() { //... }
  public void fc() { //... }
}

public class Adaptor extends Adaptee implements ITarget {
  public void f1() {
    super.fa();
  }
  
  public void f2() {
    //...重新实现f2()...
  }
  
  // 这里fc()不需要实现，直接继承自Adaptee，这是跟对象适配器最大的不同点
}

// 对象适配器：基于组合
public interface ITarget {
  void f1();
  void f2();
  void fc();
}

public class Adaptee {
  public void fa() { //... }
  public void fb() { //... }
  public void fc() { //... }
}

public class Adaptor implements ITarget {
  private Adaptee adaptee;
  
  public Adaptor(Adaptee adaptee) {
    this.adaptee = adaptee;
  }
  
  public void f1() {
    adaptee.fa(); //委托给Adaptee
  }
  
  public void f2() {
    //...重新实现f2()...
  }
  
  public void fc() {
    adaptee.fc();
  }
}

针对这两种实现方式，在实际的开发中，到底该如何选择使用哪一种呢？判断的标准主要有两个，一个是 Adaptee 接口的个数，另一个是 Adaptee 和 ITarget 的契合程度。

设计模式-享元模式

Mon, 14 Oct 2019 00:00:00 +0000

Flyweight Design Pattern. 复用对象, 节省内存. 前提是享元对象是不可变对象.

例如Java中的Integer缓存池. 或者某些系统中不会改变的值, 可以将其复用.

设计模式-原形模式

Mon, 14 Oct 2019 00:00:00 +0000

原型模式的原理与应用

如果对象的创建成本比较大, 而同一个类的不同对象之间差别不大(大部分字段都相同), 在这种情况下, 我们可以利用对已有对象(原型)进行复制(或者叫拷贝)的方式来创建新对象, 以达到节省创建时间的目的, 这种基于原型来创建对象的方式就叫做原型设计模式.

何为"对象的创建成本比较大"

创建对象包含的申请内存, 变量赋值这一过程, 本身并不会花费太多时间, 对于大部分业务系统来说, 这点时间是可以忽略的.

如果对象中的数据需要复杂的计算才能得到(比如排序, 计算哈希值), 或者需要从RPC, 网络, 数据库, 文件系统等非常慢速的IO中读取, 这种情况下, 我们就可以利用原型模式, 从其他已有对象中直接拷贝得到, 而不用每次在创建新对象时, 都重复执行这些耗时的操作.

原型模式的实现方式: 深拷贝与浅拷贝

深拷贝与浅拷贝的区别在于: 浅拷贝只会复制对象的索引(内存地址), 而不会复制对象本身. 深拷贝不仅会复制索引还好复制对象本身.

浅拷贝得到的对象跟原始对象共享数据, 当值进行修改后, 两边的值都会被修改, 因为他们是一个值.

而深拷贝得到的是一份完完全全独立的对象.

Java中的clone方法执行的就是浅拷贝.

进行深拷贝有两种方法:

递归拷贝对象, 对象的引用对象以及饮用对象的引用对象, 直到要拷贝的对象只包含基本数据类型, 没有饮用对象为止.

 public class Demo {
   private HashMap<String, SearchWord> currentKeywords=new HashMap<>();
   private long lastUpdateTime = -1;
 
   public void refresh() {
     // Deep copy
     HashMap<String, SearchWord> newKeywords = new HashMap<>();
     for (HashMap.Entry<String, SearchWord> e : currentKeywords.entrySet()) {
       SearchWord searchWord = e.getValue();
       SearchWord newSearchWord = new SearchWord(
               searchWord.getKeyword(), searchWord.getCount(), searchWord.getLastUpdateTime());
       newKeywords.put(e.getKey(), newSearchWord);
     }
 
     // 从数据库中取出更新时间>lastUpdateTime的数据，放入到newKeywords中
     List<SearchWord> toBeUpdatedSearchWords = getSearchWords(lastUpdateTime);
     long maxNewUpdatedTime = lastUpdateTime;
     for (SearchWord searchWord : toBeUpdatedSearchWords) {
       if (searchWord.getLastUpdateTime() > maxNewUpdatedTime) {
         maxNewUpdatedTime = searchWord.getLastUpdateTime();
       }
       if (newKeywords.containsKey(searchWord.getKeyword())) {
         SearchWord oldSearchWord = newKeywords.get(searchWord.getKeyword());
         oldSearchWord.setCount(searchWord.getCount());
         oldSearchWord.setLastUpdateTime(searchWord.getLastUpdateTime());
       } else {
         newKeywords.put(searchWord.getKeyword(), searchWord);
       }
     }
 
     lastUpdateTime = maxNewUpdatedTime;
     currentKeywords = newKeywords;
   }
 
   private List<SearchWord> getSearchWords(long lastUpdateTime) {
     // TODO: 从数据库中取出更新时间>lastUpdateTime的数据
     return null;
   }
 
 }

先将对象序列化, 然后再反序列化成新的对象

设计模式-职责链模式

Mon, 14 Oct 2019 00:00:00 +0000

将请求的发送和接收解耦, 让多个接收对象都有机会处理这个请求. 将这些接收对象串成一条链, 并沿着条链传递这个请求, 直到链上的某个接收对象能够处理它为止.

定义一个链表(或数组), 存储多个处理器, 当接收到一个请求时, 遍历这个链表, 每个处理器都对这个请求处理一遍. 或者遍历时选择一个处理器来进行处理.

多个处理器需要实现相同的接口

设计模式-中介模式

Mon, 14 Oct 2019 00:00:00 +0000

中介模式定义来一个单独的(中介)对象, 来封装一组对象之间的交互. 将这组对象之间的交互委派给予中介对象交互, 来避免对象之间的直接交互.

中介模式的设计思想跟中间层很像, 通过引入中介这个中间层, 将一组对象直接的交互关系(或者依赖关系)从多对多(网状关系)转化为一对多(星状关系). 原来一个对象要跟N个对象交互, 现在只需要跟一个中介对象交互, 从而最小化对象之间的交互关系, 降低了代码的复杂度, 提高了代码的可读性和可维护性.

观察者模式和中介模式区别

观察者模式中的交互关系一般都是单向的, 一个参与者只有一个身份, 要么是观察者, 要么是被观察者.

在中介模式中, 参与者之间的关系错综复杂, 既可以是消息的发送者, 也可以是消息的接收者.

设计模式-装饰器模式

Mon, 14 Oct 2019 00:00:00 +0000

不通过继承的方式, 而是组合的方式来对传入的对象进行功能增强.

装饰器模式主要解决即成关系过于复杂的问题, 通过组合来替代继承.

它主要的作用是给原始类添加增强功能.

装饰器模式还有一个特点, 那就是可以对原始类嵌套使用多个装饰器. 为了满足这个应用场景, 在设计的时候, 装饰器类需要跟原始类继承相同的抽象类或者接口

代理、桥接、装饰器、适配器4种设计模式的区别

设计模式-状态模式

Mon, 14 Oct 2019 00:00:00 +0000

状态模式一般用来实现状态机. 状态机的实现方式有多种, 除了状态模式还有分支逻辑法和查表法.

有限状态机

Finite State Machine(FSM), 简称状态机, 状态机有3个组成部分: 状态(State), 事件(Event), 动作(Action). 事件也称为转移条件. 事件触发状态的转移及动作的执行.

状态模式通过将事件触发的状态转移和动作执行, 拆分到不同的状态类中, 来避免分支判断逻辑

public interface IMario {
  State getName();
  void obtainMushRoom(MarioStateMachine stateMachine);
  void obtainCape(MarioStateMachine stateMachine);
  void obtainFireFlower(MarioStateMachine stateMachine);
  void meetMonster(MarioStateMachine stateMachine);
}

public class SmallMario implements IMario {
  private static final SmallMario instance = new SmallMario();
  private SmallMario() {}
  public static SmallMario getInstance() {
    return instance;
  }

  @Override
  public State getName() {
    return State.SMALL;
  }

  @Override
  public void obtainMushRoom(MarioStateMachine stateMachine) {
    stateMachine.setCurrentState(SuperMario.getInstance());
    stateMachine.setScore(stateMachine.getScore() + 100);
  }

  @Override
  public void obtainCape(MarioStateMachine stateMachine) {
    stateMachine.setCurrentState(CapeMario.getInstance());
    stateMachine.setScore(stateMachine.getScore() + 200);
  }

  @Override
  public void obtainFireFlower(MarioStateMachine stateMachine) {
    stateMachine.setCurrentState(FireMario.getInstance());
    stateMachine.setScore(stateMachine.getScore() + 300);
  }

  @Override
  public void meetMonster(MarioStateMachine stateMachine) {
    // do nothing...
  }
}

// 省略SuperMario、CapeMario、FireMario类...

public class MarioStateMachine {
  private int score;
  private IMario currentState;

  public MarioStateMachine() {
    this.score = 0;
    this.currentState = SmallMario.getInstance();
  }

  public void obtainMushRoom() {
    this.currentState.obtainMushRoom(this);
  }

  public void obtainCape() {
    this.currentState.obtainCape(this);
  }

  public void obtainFireFlower() {
    this.currentState.obtainFireFlower(this);
  }

  public void meetMonster() {
    this.currentState.meetMonster(this);
  }

  public int getScore() {
    return this.score;
  }

  public State getCurrentState() {
    return this.currentState.getName();
  }

  public void setScore(int score) {
    this.score = score;
  }

  public void setCurrentState(IMario currentState) {
    this.currentState = currentState;
  }
}

设计模式-组合模式

Mon, 14 Oct 2019 00:00:00 +0000

主要用来处理树形结构数据

组合模式，将一组对象组织成树形结构，将单个对象和组合对象都看做树中的节点，以统一处理逻辑，并且它利用树形结构的特点，递归地处理每个子树，依次简化代码实现。使用组合模式的前提在于，你的业务场景必须能够表示成树形结构。所以，组合模式的应用场景也比较局限，它并不是一种很常用的设计模式。

例如有员工和部门这种关系, 或者文件和文件夹这种关系. 这种可以用树来表示的场景, 可以使用组合模式. 更方便的计算某个文件的大小, 文件的数量等. 部门的薪资等等这种问题

JAVA线程

Sun, 22 Sep 2019 00:00:00 +0000

基础概念

线程的所有状态：

这些状态都在 Thread中的State枚举中定义：

public enum State {
    //表示刚刚创建的线程，这种线程还没开始执行
    NEW,
 	//在 start() 方法调用后，线程开始执行，此时状态处于 RUNABLE
    RUNNABLE,
	//如果线程在执行过程中遇到 synchronized 同步块，就会进入 BLOCKED 阻塞状态，直到获取请求的锁
    BLOCKED,
	//等待状态，WAITING 会无时间限制的等待，TIMED_WAITING 会有时间限制
    WAITING,
    TIMED_WAITING,
	//线程执行完毕，表示结束
    TERMINATED;
}

初始线程

Thread类

Runable接口

Thread类中调用start()方法之后会让线程执行run()方法，而run()方法中又是对Runable实例的调用

 /* What will be run. */
private Runnable target;

@Override
public void run() {
    if (target != null) {
        target.run();
    }
}

MySQL知识整理

Thu, 19 Sep 2019 00:00:00 +0000

推荐看一下极客时间上面的一篇教程，《MySQL实战 45 讲》。

基本架构

引擎层采用插件式。

JAVA知识整理

Tue, 10 Sep 2019 00:00:00 +0000

JAVA基础

类的初始化顺序

静态变量和静态语句块会优先于实例变量和普通语句块

public static String s = "静态变量";

static {
    System.out.println("静态语句块");
}

public String z = "实例变量";

{
    System.out.println("普通语句块");
}

public InitClass(){
    System.out.println("构造函数");
}

父类（静态变量，静态语句块）
子类（静态变量，静态语句块）
父类（实例变量，普通语句块）
父类（构造函数）
子类（实例变量，普通语句块）
子类（构造函数）

实现strStr()—LeetCode28

Fri, 06 Sep 2019 00:00:00 +0000

题目描述

实现 strStr() 函数。

给定一个 haystack 字符串和一个 needle 字符串，在 haystack 字符串中找出 needle 字符串出现的第一个位置 (从0开始)。如果不存在，则返回 -1。

示例 1:

输入: haystack = “hello”, needle = “ll” 输出: 2 示例 2:

输入: haystack = “aaaaa”, needle = “bba” 输出: -1 说明:

当 needle 是空字符串时，我们应当返回什么值呢？这是一个在面试中很好的问题。

对于本题而言，当 needle 是空字符串时我们应当返回 0 。这与C语言的 strstr() 以及 Java的 indexOf() 定义相符。

Spring笔记

Wed, 04 Sep 2019 00:00:00 +0000

最近在阅读《Spring in action》这本书，也以此篇文章记录一下spring框架的相关内容。

那么既然聊spring了，一定会聊到的两个点就是ioc和aop。那就先来聊一下这两个东西。以下都是个人理解，如果有不对的地方，欢迎探讨指正。

ioc 和 aop 是编程思想，di 和 aspect 是他们的具体实现。

IOC

IOC:控制反转，DI：依赖注入。

控制

在传统的 Java SE 程序中，我们在对象内部通过 new 的方法来创建对象实例，在这里是程序主动创建的依赖对象。而在 spring 中，它使用了专门的容器去控制对象。

控制的是对象的创建、初始化、销毁过程

在传统的 Java SE中，我们使用 new 进行创建。在构造器或者 setter 方法中给依赖对象赋值。给对象赋值 null 来销毁对象。

而在spring中一个bean的生命周期如下图所示：

反转

控制反转。我们之前是主动方，主动去控制对象的生命周期。现在变成了由 spring 去进行控制。我们由对象的控制者变成了被动控制者。

依赖注入

ioc 思想落实到代码上的具体实现。

在spring中，我们一般使用注解Component，Service，Repository，Controller，Autowired或Resource来进行注入。这个实例化出来的bean生命周期交给了spring来进行管理。我们将他们放在不同的类上表达不同的含义。

如果不进行主动声明，则默认的bean的名称为类名首字母小写，比如我对一个UserServiceImpl上添加@Service注解，spring则将这个类声明为userServiceImpl的bean。也可以这样进行主动声明@Service("beanName")。

如果我们对一个接口进入注入，这个接口下有多个实现类，这是spring就不知道我们要使用哪个实现类了，启动时会报错。

这时候有两种解决办法：

继续使用@Autowired注解

这个注解下也有两种解决方式：
- 对实现类进行修改，添加@Primary首选项注解
  
  我们对其中一个实现类添加这个注解，那么在注入时会首先注入这个实现类
- 对引入类添加@Qualifier限定符注解
  
  我们在@Autowired下添加这个注解，注解里面的内容为我们要注入实现类bean的id。这时候如果实现类的类名修改了也就是bean的id修改了，就又有问题了。这种情况下可以自定义限定符来实现。
使用@Resource注解

使用这个注解，即可在里面直接加参数，指定要注入实现类bean的id。

AOP

面向切面编程：

在软件开发中，散布于应用中多处的功能被称为横切关注点。通常来讲，这些横切关注点从概念上是与应用的业务逻辑相分离的（但是往往会直接嵌入到应用的业务逻辑之中）。把这些横切关注点与业务逻辑相分离正是面向切面（AOP）所要解决的问题。

比如说我们现在有一个业务系统，有学生，教师，课程几个业务模块，我们现在需要一些功能，比如说日志，事务等功能，这些功能实际上并不是我们的业务模块，但是又需要在系统中添加，这就可以利用面向切面来解决这个问题。

在使用面向切面编程时，我们仍然在一个地方定义通用功能，但是可以通过声明的方式定义这个功能要以何种方式在何处应用，而无需修改受影响的类。横切关注点可以被模块化为特殊的类，这些类被称作切面（aspect）。这样做有两个好处：首先，现在每个关注点都集中于一个地方，而不是分散到多处代码中；其次，服务模块更简洁，因为它们只包含主要关注点（业务功能）的代码，而次要关注点的代码被转移到切面中了。

AOP术语

描述切面的常用术语有通知(advice)，切点(pointcut)和连接点(joinpoint)。

通知（Advice）

通知定义了切面是什么以及何时使用。

spring切面可以应用5种类型的通知

前置通知（Before）：在目标方法被调用之前调用通知功能；
后置通知（After）：在目标方法完成之后调用通知，此时不会关心方法的输出是什么；
返回通知（After-returning）：在目标方法成功执行之后调用通知；
异常通知（After-throwing）：在目标方法抛出异常后调用通知；
环绕通知（Around）：通知包裹了被通知的方法，在被通知的方法调用之前和调用之后执行自定义的行为。

连接点(JoinPoint)

连接点是在应用执行过程中能够插入切面的一个点。（被切入的地方）

JAVA容器

Sat, 31 Aug 2019 00:00:00 +0000

概述

容器主要包括Collection和Map两种，Collection存储对象的集合，而Map存储着键值对。而Collection下又分为List，Set，和Queue三种。

源码分析

HashMap 采用数组+链表+红黑树的数据结构(1.8)，查找的效率由哈希O(1)+链表O(n)，改为了哈希O(1)+O(logN)。当链表长度到达8时转换为红黑树，当红黑树上节点的数量降为6时再转换为链表。遍历时的顺序与插入顺序不一致。它的查找效率高。

LinkedHashMap 它是 hashmap 的子类，在 hashmap 的基础上添加了双向链表。通过链表的方式保证了遍历时顺序与插入时顺序一致。可以在构造函数中设置访问顺序，实现 lru 算法。

TreeMap 采用红黑树的数据结构。所以在遍历时内部是排好序的。但效率最低。

Hashtable 采用数组+链表的数据结构。它在可能多线程访问的方法上添加了synchronized关键字，保证了线程的安全性。与HashMap的思路大体相同。

List

ArrayList 通过数组实现，所以在访问时直接通过下标即可获取，速度快。但插入需要复制数组，速度慢。

LinkedList 通过链表实现，所以在插入时速度快，但访问时需要通过链表逐个访问，速度慢。

Vector 通过数组实现，大体与ArrayList相同。但它是线程安全的，通过在方法上添加synchronized关键字来实现。并且它可以设置一个扩容的长度，每次扩容时数组增加我们设置的长度，当没设置是为双倍扩容。ArrayList是1.5倍扩容并且没有设置扩容长度的变量。

Set
- HashSet
- LinkedHashSet
- TreeSet

set 是 map 的子集，当 map 只存储 key，value 为空时就是 set。

Queue
- LinkedList
- PriorityQueue

队列，先进先出原则。通过链表很容易实现，获取头部节点，新增时插入到尾部。而PriorityQueue通过数组进行的实现，并可以实现优先级。

迭代器

Kubetnetes的一些概念和术语

Fri, 30 Aug 2019 00:00:00 +0000

此篇文章来自《Kubernetes权威指南：从Docker到Kubernetes实践全接触（第4版）》

Master
Node
Pod
Replication Controller
Service

k8s里面的大部分资源都可以被看作一种资源对象，这些对象大部分也都可以通过kubectl工具（或者是API调用）执行增删改查等操作，并将其状态保存在etcd中持久化存储。

在这个调用中，有一个版本的概念：apiVersion。对于一个接口有时候会进行升级，从而会有不同的版本存在，我们调用不同版本的接口从而对应不同版本的实现。在k8s里面也是如此，需要在调用时指明现在调用的版本号。

Master，Node

master，node的概念是对于机器的，可是是一台物理主机，也可以是一台虚拟机，在不同的机器上部署k8s服务，这个服务实例可能是master或者是node。

Master

k8s里面的master指的是集群控制节点，在每个k8s集群里都需要有一个master来负责整个集群的管理和控制，基本上k8s的所有控制命令都发给它，它负责具体的执行过程，

在master上运行着以下关键进程：

kubernetes API Server：提供了HTTP Rest接口的关键服务进程，是k8s里所有资源的增删改查等操作的唯一入口，也是集群控制的入口进程。
kubernetes Controller Manager：kubernetes里所有资源对象的自动化控制中心，可以将其理解为资源对象的“大总管”。
kubernetes Scheduler：负责资源调度（Pod调度）的进程

另外，在master上通常还需要部署etcd服务，因为kubernetes里的所有资源对象的数据都被保存在etcd中。

Node

在k8s集群中，除了master的集群被称为node，node是集群中的工作负载节点，每个node都会被master分配一些工作负载（docker容器），当某个node宕机后，其上的工作负载会被master自动转移到其他节点上。

每个node上都运行着以下关键进程：

kubelet：负载pod对应容器的创建，启停等任务，同时与master密切协作，实现集群管理等基本功能。
kube-proxy：实现kubernetes service的通信与负载均衡的重要组件
docker engine：docker引擎，负责本机的容器创建和管理工作

node可以在运行期间动态增加到k8s集群总，前提是在这个节点上已经正确安装、配置和启动了上述关键进程，在默认情况下kubelet会向master注册自己，这也是k8s推荐的node管理方式。一旦node被纳入集群管理范围，kubelet进程就会定时向master汇报自身的情况，例如操作系统，docker版本，机器的cpu和内存情况，以及当前有哪些pod在运行等。这样master就可以获知每个node的资源使用情况，并实现高效均衡的资源调度策略。

在node超过指定时间不上报信息时，会被master判定为“失联”，node的状态被标记为不可用（not ready），随后master会触发“工作负载大转移”的自动流程。

可以通过执行如下命令查看在集群上有多少个node：

`1`	`kubectl get nodes`

当想查看node的具体信息时，可以通过这个命令：

`1`	`kubectl describe node <node-name>`

这个命令可以展示Node的如下关键信息。

Node的基本信息：名称、标签、创建时间等。
Node当前的运行状态：Node启动后会做一系列的自检工作，比如磁盘空间是否不足（DiskPressure）、内存是否不足（MemoryPressure）、网络是否正常（NetworkUnavailable）、PID资源是否充足（PIDPressure）。在一切正常时设置Node为Ready状态（Ready=True），该状态表示Node处于健康状态，Master将可以在其上调度新的任务了（如启动Pod）。
Node的主机地址与主机名。
Node上的资源数量：描述Node可用的系统资源，包括CPU、内存数量、最大可调度Pod数量等。
Node可分配的资源量：描述Node当前可用于分配的资源量。
主机系统信息：包括主机ID、系统UUID、Linux kernel版本号、操作系统类型与版本、Docker版本号、kubelet与kube-proxy的版本号等。
当前运行的Pod列表概要信息。
已分配的资源使用概要信息，例如资源申请的最低、最大允许使用量占系统总量的百分比。
Node相关的Event信息。

master与node是集群中服务实例的一个描述，它对应的都是一个物理主机或者是虚拟机，是机器级别的一个概念

Pod

Pod是k8s中管理的最小单元, 一个pod中有一个与业务并且不容易死亡的Pause容器, 可以根据Pause容器的状态来判断整个容器组的状态.

对于同一个Pod中的多个container, 它们之间共享Pause容器的IP，共享Pause容器挂载的Volume. k8s为每个Pod都分配来一个唯一的IP地址, 称为Pod IP.

在K8s中, 一个Pod里的容器与另外主机上的Pod容器能够直接通信.

迭代器

Wed, 28 Aug 2019 00:00:00 +0000

迭代器

在java中主要有两种迭代器，Iterator和ListIterator。这两个都是接口。先来看一下这两个接口有什么区别

public interface Iterator<E> {
    
    boolean hasNext();

    E next();
    
    default void remove() {
        throw new UnsupportedOperationException("remove");
    }
    
    default void forEachRemaining(Consumer<? super E> action) {
        Objects.requireNonNull(action);
        while (hasNext())
            action.accept(next());
    }
}

Iterator主要有四个方法。判断有没有下一个元素、获取下一个元素，删除元素和forEachRemaining方法。

再来看一下ListIterator

public interface ListIterator<E> extends Iterator<E> {

    boolean hasNext();

    E next();

    boolean hasPrevious();

    E previous();

    int nextIndex();

    int previousIndex();

    void remove();

    void set(E e);

    void add(E e);
}

我们可以看到他是继承了Iterator。除了上面的两个方法还多了好几个方法。判断是否有上一个元素，获取上一个元素的值，获取上一个元素的索引，获取上一个元素的索引。除了移除还有添加和更新的方法。

他们在不同的类里面都有自己的实现，之前看ArrayList，HashMap的时候把这一块给跳过了，现在来看一下他们是如何实现的。

HashSet源码

Mon, 26 Aug 2019 00:00:00 +0000

变量

1
2
3

private transient HashMap<E,Object> map;
// 传入到HashMap中作为value
private static final Object PRESENT = new Object();

构造函数

public HashSet() {
    map = new HashMap<>();
}

public HashSet(int initialCapacity) {
    map = new HashMap<>(initialCapacity);
}

public HashSet(int initialCapacity, float loadFactor) {
    map = new HashMap<>(initialCapacity, loadFactor);
}

public HashSet(Collection<? extends E> c) {
    map = new HashMap<>(Math.max((int) (c.size()/.75f) + 1, 16));
    addAll(c);
}

我们可以看到他的构造函数都是再次调用了HashMap的构造函数。将map变量初始化为相应的HashMap。

HashMap源码学习

Thu, 22 Aug 2019 00:00:00 +0000

画了一张结构图，欢迎指正。

变量

/**
* The default initial capacity - MUST be a power of two.
* 默认的容量，容量必须是2的幂
*/
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16

/**
* The maximum capacity, used if a higher value is implicitly specified
* by either of the constructors with arguments.
* MUST be a power of two <= 1<<30.
* 最大的容量值 2的30次幂
*/
static final int MAXIMUM_CAPACITY = 1 << 30;

/**
* The load factor used when none specified in constructor.
* 默认的负载系数
*/
static final float DEFAULT_LOAD_FACTOR = 0.75f;

/**
* The bin count threshold for using a tree rather than list for a
* bin.  Bins are converted to trees when adding an element to a
* bin with at least this many nodes. The value must be greater
* than 2 and should be at least 8 to mesh with assumptions in
* tree removal about conversion back to plain bins upon
* shrinkage.
* 链表的长度到达8之后转换为红黑树
*/
static final int TREEIFY_THRESHOLD = 8;

/**
* The bin count threshold for untreeifying a (split) bin during a
* resize operation. Should be less than TREEIFY_THRESHOLD, and at
* most 6 to mesh with shrinkage detection under removal.
*/
static final int UNTREEIFY_THRESHOLD = 6;

/**
* The smallest table capacity for which bins may be treeified.
* (Otherwise the table is resized if too many nodes in a bin.)
* Should be at least 4 * TREEIFY_THRESHOLD to avoid conflicts
* between resizing and treeification thresholds.
* 
*/
static final int MIN_TREEIFY_CAPACITY = 64;

// 存储的容器
transient Node<K,V>[] table;

/**
* Holds cached entrySet(). Note that AbstractMap fields are used
* for keySet() and values().
*/
transient Set<Map.Entry<K,V>> entrySet;

/**
* The number of key-value mappings contained in this map.
*/
transient int size;

/**
* The number of times this HashMap has been structurally modified
* Structural modifications are those that change the number of mappings in
* the HashMap or otherwise modify its internal structure (e.g.,
* rehash).  This field is used to make iterators on Collection-views of
* the HashMap fail-fast.  (See ConcurrentModificationException).
* 结构修改的次数，每次增加和删除都修改这个数值
*/
transient int modCount;

/**
* The next size value at which to resize (capacity * load factor).
*
* @serial
*/
// (The javadoc description is true upon serialization.
// Additionally, if the table array has not been allocated, this
// field holds the initial array capacity, or zero signifying
// DEFAULT_INITIAL_CAPACITY.)
// 扩容的阈值，当键值对的数量超过这个值就会扩容
int threshold;

/**
* The load factor for the hash table.
* 负载系数
*/
final float loadFactor;

LinkedHashMap源码

Thu, 22 Aug 2019 00:00:00 +0000

LinkedHashMap继承了HashMap类，实现了Map接口。

他与HashMap的主要区别就是使用链表存储了每个节点的顺序。这样就能保证有序。

来看一下他的节点情况：

static class Entry<K,V> extends HashMap.Node<K,V> {
    Entry<K,V> before, after;
    Entry(int hash, K key, V value, Node<K,V> next) {
        super(hash, key, value, next);
    }
}

从这里可以看出他使用了两个变量，before，after存储这个节点的前后顺序。

LinkedList源码学习

Wed, 21 Aug 2019 00:00:00 +0000

LinkedList使用了链表实现，相比ArrayList来说，插入更快，查看较慢。

首先看一下使用的链表结构

private static class Node<E> {
	E item;
	Node<E> next;
	Node<E> prev;

	Node(Node<E> prev, E element, Node<E> next) {
		this.item = element;
		this.next = next;
		this.prev = prev;
	}
}

每个Node节点存储一个元素，item表示这个元素的值，prev表示上一个元素，如果已经的第一个了那么为null。同理，next表示的是下一个元素，当插入新元素时会改变上一个元素的next值指向自己，这样就把这个链表串起来了。

变量

// 元素的数量
transient int size = 0;
// 指向第一个元素
transient Node<E> first;
// 指向最后一个元素
transient Node<E> last;

Mysql的ibtmp1文件过大

Wed, 21 Aug 2019 00:00:00 +0000

今天早上接到一个任务，说服务器磁盘容量告警让我去排查一下原因。磁盘容量在一天内突然暴涨了好几十个G。

查看磁盘占用

使用命令

`1`	`du -h --max-depth=1`

查看磁盘占用情况，我是在根目录下执行的命令，后面的max-depth=1指定深入目录的层数，为1就指定1层。然后经过排查后发现了这个文件是Mysql的ibtmp1文件。

ibtmp1是什么

我们使用的Mysql版本是5.7.24。ibtmp1文件是 MySQL5.7的新特性,MySQL5.7使用了独立的临时表空间来存储临时表数据，但不能是压缩表。临时表空间在实例启动的时候进行创建，shutdown的时候进行删除。即为所有非压缩的innodb临时表提供一个独立的表空间，默认的临时表空间文件为ibtmp1。

解决

Mysql创建的这个文件肯定不能在Mysql还运行时就直接删了，否则可能会出问题。重启Mysql会重置这个文件，但是后面如果不加以限制肯定还会让磁盘爆满。所以说要找一个能彻底解决的办法。

修改my.cnf配置文件

这个文件我是在/etc/my.cnf下，有的可能在/etc/mysql/my.cnf下，先找到这个文件然后在后面添加innodb_temp_data_file_path = ibtmp1:12M:autoextend:max:5G这句

限制这个文件最大增加到5G。
设置innodb_fast_shutdown参数

进入mysql命令行，执行SET GLOBAL innodb_fast_shutdown = 0;命令

然后重启Mysql即可。

原因

刚才说的了这个文件是临时表空间。那肯定是使用了临时表。那么什么情况下会使用临时表呢。

GROUP BY 无索引字段或GROUP BY+ ORDER BY 的子句字段不一样时
order by 与distinct 共用，其中distinct与order by里的字段不一致（主键字段除外）
UNION查询（MySQL5.7后union all已不使用临时表）
insert into select …from …

所以在平常写sql时还是要多注意一下。

参考文章

http://mysql.taobao.org/monthly/2019/04/01/

https://cloud.tencent.com/developer/article/1491411

https://zhuanlan.zhihu.com/p/66847189

ArrayList源码学习

Tue, 20 Aug 2019 00:00:00 +0000

变量

private static final int DEFAULT_CAPACITY = 10;
private static final Object[] EMPTY_ELEMENTDATA = {};
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
transient Object[] elementData; 
private int size;

DEFAULT_CAPACITY：默认的容量，当我们不指定容量时默认容量是10
EMPTY_ELEMENTDATA：空的数据集
DEFAULTCAPACITY_EMPTY_ELEMENTDATA：同上面的一样，都是空的数据集
elementData：保存的元素
size：元素长度，实际存储的元素数量

构造方法：

无参的构造方法

1
2
3

public ArrayList() {
        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}

很简单的一句话，将保存元素的变量进行初始化。

两数相加-LeetCode2

Tue, 20 Aug 2019 00:00:00 +0000

题目描述

给出两个非空的链表用来表示两个非负的整数。其中，它们各自的位数是按照逆序的方式存储的，并且它们的每个节点只能存储一位数字。

如果，我们将这两个数相加起来，则会返回一个新的链表来表示它们的和。

您可以假设除了数字 0 之外，这两个数都不会以 0 开头。

示例：

输入：(2 -> 4 -> 3) + (5 -> 6 -> 4) 输出：7 -> 0 -> 8 原因：342 + 465 = 807

树莓派使用笔记

Thu, 08 Aug 2019 00:00:00 +0000

预备条件

树莓派（我的型号的3b+），电源线
内存卡 class10 8g以上
一台有ssh连接的电脑或者显示器、键鼠

最终实现功能

开机自动挂载外接硬盘
Samba（局域网文件共享）
开启ftp连接
Nginx
Mariadb数据库（与MySQL相同）
Docker
内网穿透
Aria2下载机

安装系统

下载镜像

从官网下载自己想要的镜像，一般就下载树莓派的默认Raspbian系统就行了，有桌面版和无桌面版。自行选择所需系统下载即可。

输入内存卡

推荐使用软件balenaEtcher这个软件，这个有windows版本和macos版本，所以还是很方便的。

选择我们下载镜像的安装位置，选择要刷的设备这里就是我们的内存卡，然后点击确认即可。

系统配置

在刷完系统后拔出读卡器，然后再插入电脑，此时可以看到一个boot分区。以下文件都保存在这个分区里面。

设置SSH访问

写一个空白的文件，命名为ssh，大小写无所谓，注意ssh就是文件的全部名称不要有后缀。

设置WIFI

如果有网线，可以先使用网线连接，后面再考虑这一步。

写一个命名为wpa_supplicant.conf的文件，这里面写wifi的配置信息。

主要有以下几个属性：

ssid：WiFi的名称
psk：密码
key_mgmt：WIFI的加密方式
priority：连接的优先级，数字越大优先级越高，不可以是负数
scan_ssid：连接隐藏的wifi时需要将这个指定为1

# WiFi配置
network={
	ssid="WiFi-A"
    psk="12345678"
    key_mgmt=WPA-PSK
    priority=1
}
# 连接隐藏的WiFi
network={
    ssid="WiFi-B"
    psk="12345678"
    key_mgmt=WPA-PSK
    priority=2
    scan_ssid=1
}

# 无密码时候的配置
network={
    ssid="你的无线网络名称（ssid）"
    key_mgmt=NONE
}
# WiFi 使用WEP加密
network={
    ssid="你的无线网络名称（ssid）"
    key_mgmt=NONE
    wep_key0="你的wifi密码"
}
# WiFi 使用WPA/WPA2加密
network={
    ssid="你的无线网络名称（ssid）"
    key_mgmt=WPA-PSK
    psk="你的wifi密码"
}

开机重置密码

如果有屏幕和键鼠就直接连接即可。

重复N次的元素-LeetCode961

Thu, 08 Aug 2019 00:00:00 +0000

题目描述

在大小为 2N 的数组 A 中有 N+1 个不同的元素，其中有一个元素重复了 N 次。

返回重复了 N 次的那个元素。

示例 1：

输入：[1,2,3,3] 输出：3 示例 2：

输入：[2,1,2,5,3,2] 输出：2 示例 3：

输入：[5,1,5,2,5,3,5,4] 输出：5

提示：

4 <= A.length <= 10000 0 <= A[i] < 10000 A.length 为偶数

大小为2N的数字中有个N+1个元素，其中有个元素重复了N次，这也说明了除了这个元素其他元素都没有重复，也可以理解成查找重复的元素

两个数组的交集II-LeetCode350

Wed, 07 Aug 2019 00:00:00 +0000

题目描述

给定两个数组，编写一个函数来计算它们的交集。

示例 1:
输入: nums1 = \[1,2,2,1], nums2 = \[2,2]
输出: \[2,2]
示例 2:
输入: nums1 = \[4,9,5], nums2 = \[9,4,9,8,4]
输出: \[4,9]
说明：

输出结果中每个元素出现的次数，应与元素在两个数组中出现的次数一致。

我们可以不考虑输出结果的顺序。

*进阶:*

如果给定的数组已经排好序呢？你将如何优化你的算法？

如果 nums1 的大小比 nums2 小很多，哪种方法更优？

如果 nums2 的元素存储在磁盘上，磁盘内存是有限的，并且你不能一次加载所有的元素到内存中，你该怎么办？

这个题目的T349的进阶版。

有效的括号—LeetCode20

Wed, 07 Aug 2019 00:00:00 +0000

题目描述

给定两个数组，编写一个函数来计算它们的交集。

示例 1:
输入: nums1 = \[1,2,2,1], nums2 = \[2,2]
输出: \[2]
示例 2:
输入: nums1 = \[4,9,5], nums2 = \[9,4,9,8,4]
输出: \[9,4]
说明:

输出结果中的每个元素一定是唯一的。

我们可以不考虑输出结果的顺序。

有效的括号—LeetCode20

Wed, 07 Aug 2019 00:00:00 +0000

题目描述

给定一个只包括 '('，')'，'{'，'}'，'['，']' 的字符串，判断字符串是否有效。有效字符串需满足：

左括号必须用相同类型的右括号闭合。
左括号必须以正确的顺序闭合。注意空字符串可被认为是有效字符串。 示例 1:

输入: "()"
输出: true

示例 2:

输入: "()[]{}"
输出: true

示例 3:

输入: "(]"
输出: false

示例 4:

 输入: "(\[)]"
 输出: false

示例 5:

输入: "{\[]}"
输出: true

这个题目与我们编译器对括号的识别一样，当我们多了一个括号后编译器会报错提示。

保持城市的天际线-LeetCode807

Tue, 06 Aug 2019 00:00:00 +0000

题目描述

在二维数组grid中，grid[i][j]代表位于某处的建筑物的高度。我们被允许增加任何数量（不同建筑物的数量可能不同）的建筑物的高度。高度 0 也被认为是建筑物。

最后，从新数组的所有四个方向（即顶部，底部，左侧和右侧）观看的“天际线”必须与原始数组的天际线相同。城市的天际线是从远处观看时，由所有建筑物形成的矩形的外部轮廓。请看下面的例子。

建筑物高度可以增加的最大总和是多少？

例子：输入： grid = [[3,0,8,4],[2,4,5,7],[9,2,6,3],[0,3,1,0]] 输出： 35 解释： The grid is: [ [3, 0, 8, 4], [2, 4, 5, 7], [9, 2, 6, 3], [0, 3, 1, 0] ]

从数组竖直方向（即顶部，底部）看“天际线”是：[9, 4, 8, 7] 从水平水平方向（即左侧，右侧）看“天际线”是：[8, 7, 9, 3]

在不影响天际线的情况下对建筑物进行增高后，新数组如下：

gridNew = [ [8, 4, 8, 7], [7, 4, 7, 7], [9, 4, 8, 7], [3, 3, 3, 3] ] 说明:

1 < grid.length = grid[0].length <= 50。 grid[i][j] 的高度范围是： [0, 100]。一座建筑物占据一个grid[i][j]：换言之，它们是 1 x 1 x grid[i][j] 的长方体。

这个问题类似看三视图，然后再根据两个三视图合并出符合条件的最高值。

最后要返回的结果是这个最高值比原有值增长了多少

手写rpc简单实现

Fri, 26 Jul 2019 00:00:00 +0000

背景

当单体项目逐渐扩大后，一个项目编译，发布可能需要很久的时间，如果其中一个文件出现 bug，那么需要对整个项目进行打包发布。微服务就是对项目进行拆分，拆分成多个小项目，由这些小项目组成大项目。并且拆分成小项目后，其他单体项目中需要相同功能的地方就不用再次编写，直接用这个就可以了。有种分治的思想。

那么原来单体项目拆分后，随之而来就会出现一些问题。原来一个项目中直接调用即可，现在请求的类被拆分到其他项目中，如何进行请求，是采用 http 这种请求还是rpc？多个模块如果进行管理等等一系列问题。这里主要写一下 rpc 的理解。

在微服务中rpc又是重要的一环，现在主流的rpc框架有很多，比如阿里的dubbo，微博的Motan,谷歌的gRpc，还有Thrift，现在主流的应该就这几种吧。按照文档学习了一下dubbo如何使用后，发现并没有了解rpc是如何具体实现的。所以这篇文章记录了自己对rpc的一些理解与实战代码。

代码链接

HTTP 与 RPC 的对比

其实就像一些技术一样，没有绝对好的技术，不然大家都去使用它了。都只是在不同场景下有各自的优势。

rpc一般是自带负载均衡策略，而 http 一般是通过 nginx 这种来实现负载均衡
rpc可以使用 tcp 协议也可以使用 http 协议，而 http 就只能使用 http 协议
rpc可以自定义传输信息和序列化方法，减少传输报文大小。

所以RPC主要用于公司内部的服务调用。HTTP主要用于对外的环境，浏览器接口调用，APP接口调用，第三方接口调用等。

RPC的主要实现步骤

利用aop和注解实现redis对数据库的缓存

Wed, 24 Jul 2019 00:00:00 +0000

利用AOP和注解的方式实现redis的数据缓存

代码链接

之前一直没有用到redis，最近想学习一下redis，那么首先想到的就是将数据库的结果添加到缓存中，那么下次访问的时候如果命中缓存了就可以不用访问数据库，节省了时间。

我在网上搜索了几篇文章，发现他们都是在每个业务逻辑里面添加缓存判断，伪代码如下：

public Object method1(Object param1){
	//如果param1的结果在缓存中存在，直接返回
	if(redis has cache){
		return redis result;
	}
	Object dbResult = dao.select();
	redis.add(dbResult);
	return dbResult
}

如果这样写，那么在每个需要缓存的地方都需要添加与本身业务无关的代码，对代码的侵入比较大。所以我利用aop和注解实现了一个方法，在需要缓存的地方添加该注解就可以实现缓存，不会对代码有侵入。最终实现调用的结果如下：

@Override
@EnableRedisCache(Key = "user", Time = 100000)
public ResultBean getUserById(Long id) {
	return ResultUtil.success(userDao.selectById(id));
}

/**
* 同上面的方法一样，这个没有添加 EnableRedisCache，所以每次都会走数据库，
* 上面的方法添加了注解会先走缓存，如果没有再走数据库
*
* @param id
* @return
*/
@Override
public ResultBean getUserNoCache(Long id) {
	return ResultUtil.success(userDao.selectById(id));
}

该实现主要是利用了aop原理，通过对EnableRedisCache注解进行拦截，如果有该注解就进入到拦截方法中。

山脉数组的峰顶索引-LeetCode852

Thu, 18 Jul 2019 00:00:00 +0000

题目描述

我们把符合下列属性的数组 A 称作山脉：

A.length >= 3 存在 0 < i < A.length - 1 使得A[0] < A[1] < … A[i-1] < A[i] > A[i+1] > … > A[A.length - 1] 给定一个确定为山脉的数组，返回任何满足 A[0] < A[1] < … A[i-1] < A[i] > A[i+1] > … > A[A.length - 1] 的 i 的值。

示例 1：

输入：[0,1,0] 输出：1 示例 2：

输入：[0,2,1,0] 输出：1

提示：

3 <= A.length <= 10000 0 <= A[i] <= 10^6 A 是如上定义的山脉

其实这就是一个寻找数组最大值的问题

键盘行-LeetCode500

Mon, 15 Jul 2019 00:00:00 +0000

题目描述

给定一个单词列表，只返回可以使用在键盘同一行的字母打印出来的单词。键盘如下图所示。

示例：

输入: [“Hello”, “Alaska”, “Dad”, “Peace”] 输出: [“Alaska”, “Dad”]

注意：

你可以重复使用键盘上同一字符。你可以假设输入的字符串将只包含字母。

判断给出的字符是否全部在一行中

反转字符串中的单词III-LeetCode557

Fri, 12 Jul 2019 00:00:00 +0000

题目描述

给定一个字符串，你需要反转字符串中每个单词的字符顺序，同时仍保留空格和单词的初始顺序。

示例 1:

输入: “Let’s take LeetCode contest” 输出: “s’teL ekat edoCteeL tsetnoc” 注意：在字符串中，每个单词由单个空格分隔，并且字符串中不会有任何额外的空格。

根据示例可以看出，需要将每个单词反转后再根据原有顺序拼接起来

反转字符串-LeetCode344

Wed, 10 Jul 2019 00:00:00 +0000

题目描述

编写一个函数，其作用是将输入的字符串反转过来。输入字符串以字符数组 char[] 的形式给出。

不要给另外的数组分配额外的空间，你必须原地修改输入数组、使用 O(1) 的额外空间解决这一问题。

你可以假设数组中的所有字符都是 ASCII 码表中的可打印字符。

示例 1：

输入：[“h”,“e”,“l”,“l”,“o”] 输出：[“o”,“l”,“l”,“e”,“h”] 示例 2：

输入：[“H”,“a”,“n”,“n”,“a”,“h”] 输出：[“h”,“a”,“n”,“n”,“a”,“H”]

这个题目的要求是在O(1)的空间复杂度下完成反转

解题思路

不能使用额外的空间，又需要将数组反转，我们可以将第一个与最后一个进行反转，然后第二个与倒数第二个进行反转

代码实现：

public void reverseString(char[] s) {
  int time = s.length / 2;
  for (int i = 0; i < time; i++) {
    char temp = s[i];
    s[i] = s[s.length - 1 - i];
    s[s.length - 1 - i] = temp;
  }
}

Docker使用笔记

Wed, 03 Jul 2019 00:00:00 +0000

Docker是一个使用了Linux Namespace和Cgroups的虚拟化工具

安装

mac

从官网下载安装包进行安装即可
树莓派

使用ssh连接树莓派后执行

curl -sSL https://get.docker.com | sh

就可以安装了，不过这是国外的安装源，速度可能会比较慢一些。

如果在安装过程中提示缺少某些包根据提示进行安装即可。

配置

mac

修改国内源

点击应用图标后打开daemon选项，在registry mirrors中可以看到我们的镜像下载源，我们可以搜索一些国内源进行替换。

比如阿里云：
1. 进入阿里的容器镜像服务：https://cr.console.aliyun.com/cn-hangzhou/instances/repositories
2. 进入镜像加速器，创建加速器
3. 复制加速器地址进行替换
树莓派

将docker设置为开机自启动

sudo systemctl enable docker

然后我们启动 Docker 守护程序，或者重启树莓派来完成启动docker

sudo systemctl start docker

将当前用户添加到docker用户组

现在安装完成后的docker还只能由root用户或者docker组的用户使用，所以如果你不是使用的root用户，例如跟我一样使用的pi用户、或者其他用户。还需要将用户加到docker组中，下面这个命令就是将当前用户加到docker组中

sudo usermod -aG docker $USER

完成此操作后，当前用户还是不能操作docker，需要注销后重新连接即可。

重新连接后运行docker run hello-world就可以运行hello-world的镜像了。

常用命令

查找镜像 docker search [OPTIONS] TERM 比如我们需要查找一个MySQL镜像，我们可以docker search mysql
获取镜像 docker pull [选项] [Docker Registry 地址[:端口号]/]仓库名[:标签] 当我们对地址和标签缺省时，默认为当前仓库最新的镜像
列出本地镜像 docker image 将列出下载到本地的所有镜像
列出本地历史运行镜像 docker ps -a

利用github和picgo创建图床

Fri, 28 Jun 2019 00:00:00 +0000

在写博客的时候需要存储一些图片，网上有一些图床工具，有免费的也有收费的。免费的肯定没有保障，我就看到很多人使用一些免费的图床，然后提供方不再提供后图床就挂了。所以我准备使用github作为图床存储，有一定的网络延迟，但也可以接受。

前期准备：

下载并安装picgo，选择自己系统对应的版本下载安装即可。

注册github

创建存储图片的项目

这里要注意的是把项目设置成公开的，不用设置私有，不然我们图片是无法访问的。

这里的图片其他人都是可以查看的，注意不要放一些与自己隐私相关的东西哦。。。

生成github的token

打开github->setting->developer settings->personal access tokens

点击生成新的token

这里我们填写我们这个token的名称和权限，权限就只选repo就可以。

点击生成token，这时候会显示一串字符，这个信息只出现一次以后是看不到的，所以我们要把它保存下来。

picgo设置

然后就是设置picgo了。

仓库名称添加自己创建的仓库名称即可，分支就默认写master，token是我们上一步获取到的token

最后就是自定义域名了，一般的规律是https://raw.githubusercontent.com/你的github名称/仓库名称/分支名称(默认就是master)

也可以先预上传一张图片，然后新标签页打卡，查看图片地址，去掉图片名即可。

然后将github设置成默认图床就可以了

dubbo笔记

Sun, 23 Jun 2019 00:00:00 +0000

建立基础项目

建立一个maven项目，然后建立一个api模块，作为这个项目的总的调用接口

learn-dubbo-demo/
├── simple-api

https://github.com/liunaijie/learn-demo/tree/master/learn-dubbo-demo

https://github.com/liunaijie/learn-demo/tree/master/learn-dubbo-demo/sample-api

然后在api项目中创建接口，提供给生产者和消费者调用。

我这里定义一个了sayhello()方法

删除最外层的括号—LeetCode1021

Sat, 22 Jun 2019 00:00:00 +0000

题目描述：

有效括号字符串为空 ("")、"(" + A + “)” 或 A + B，其中 A 和 B 都是有效的括号字符串，+ 代表字符串的连接。例如，""，"()"，"(())()" 和 “(()(()))” 都是有效的括号字符串。如果有效字符串 S 非空，且不存在将其拆分为 S = A+B 的方法，我们称其为原语（primitive），其中 A 和 B 都是非空有效括号字符串。给出一个非空有效字符串 S，考虑将其进行原语化分解，使得：S = P_1 + P_2 + … + P_k，其中 P_i 是有效括号字符串原语。对 S 进行原语化分解，删除分解中每个原语字符串的最外层括号，返回 S 。示例 1：输入："(()())(())" 输出："()()()" 解释：输入字符串为 “(()())(())"，原语化分解得到 “(()())” + “(())"，删除每个部分中的最外层括号后得到 “()()” + “()” = “()()()"。示例 2：输入：”(()())(())(()(()))” 输出：”()()()()(())" 解释：输入字符串为 “(()())(())(()(()))"，原语化分解得到 “(()())” + “(())” + “(()(()))"，删除每隔部分中的最外层括号后得到 “()()” + “()” + “()(())” = “()()()()(())"。示例 3：输入：”()()” 输出：”" 解释：输入字符串为 “()()"，原语化分解得到 “()” + “()"，删除每个部分中的最外层括号后得到 "” + "” = “"。提示： S.length <= 10000 S[i] 为 “(” 或 “)” S 是一个有效括号字符串

解题思路：

字符串S是一个有效括号字符串，那么我们可以先进行原语化分解，然后再对每个原语进行去除最外层括号。

进行原语分解的时候我们可以定义一个值和一个字符串，遇到左括号这个值加一并将左括号添加到这个字符串上，遇到右括号这个值减一并且将右括号添加到字符串上，当这个值变成0并且字符串的长度为2的倍数时就可以认为这个字符串是一个原语。

增减字符串匹配—LeetCode942

Thu, 20 Jun 2019 00:00:00 +0000

题目描述：

给定只含 “I”（增大）或 “D”（减小）的字符串 S ，令 N = S.length。

返回 [0, 1, …, N] 的任意排列 A 使得对于所有 i = 0, …, N-1，都有：

如果 S[i] == “I”，那么 A[i] < A[i+1]

如果 S[i] == “D”，那么 A[i] > A[i+1]

示例 1：

输出：“IDID”

输出：[0,4,1,3,2]

示例 2：

输出：“III”

输出：[0,1,2,3]

示例 3：

输出：“DDI”

输出：[3,2,0,1]

提示：

1 <= S.length <= 1000

S 只包含字符 “I” 或 “D”。

解题思路：

给定只包含I和D的字符串，让我们求符合规则的数组。首先确认的是数组内的数值为0到字符串的长度，如果字符串长度为2，那数组内的数值就是0，1，2。

然后遇到I表示增大，遇到D表示减少，那么可以利用双指针，如果遇到I则从最小值0开始放然后加一，遇到D则从最大值开始放然后减一。

代码实现：

public int[] diStringMatch(String S) {
  int length = S.length();
  int[] result = new int[length+1];
  char[] chars = S.toCharArray();
  int max = length;
  int min = 0;
  for (int i = 0; i < chars.length; i++) {
    char c = chars[i];
    switch (c) {
      case 'I':
        result[i] = min;
        min++;
        break;
      case 'D':
        result[i] = max;
        max--;
        break;
      default:
        break;
    }
  }
  result[length]=max;
  return result;
}

高度检查器—LeetCode1051

Tue, 18 Jun 2019 00:00:00 +0000

题目描述：

学校在拍年度纪念照时，一般要求学生按照非递减的高度顺序排列。请你返回至少有多少个学生没有站在正确位置数量。该人数指的是：能让所有学生以非递减高度排列的必要移动人数。示例：输入：[1,1,4,2,1,3] 输出：3 解释：高度为 4、3 和最后一个 1 的学生，没有站在正确的位置。提示： 1 <= heights.length <= 100 1 <= heights[i] <= 100

三角形最小路径和—LeetCode120

Sun, 16 Jun 2019 00:00:00 +0000

题目描述

给定一个三角形，找出自顶向下的最小路径和。每一步只能移动到下一行中相邻的结点上。

例如，给定三角形：

[ [2], [3,4], [6,5,7], [4,1,8,3] ] 自顶向下的最小路径和为 11（即，2 + 3 + 5 + 1 = 11）。

说明：

如果你可以只使用 O(n) 的额外空间（n 为三角形的总行数）来解决这个问题，那么你的算法会很加分。

题目中有一句话，每一步只能移动到下一行中相邻的结点中，所以在m行n列时，下一步的落地只能在m+1行n列或者m+1行n+1列中。

电话号码的字母组合—LeetCode17

Sat, 15 Jun 2019 00:00:00 +0000

题目描述：

给定一个仅包含数字 2-9 的字符串，返回所有它能表示的字母组合。给出数字到字母的映射如下（与电话按键相同）。注意 1 不对应任何字母。示例: 输入：“23” 输出：[“ad”, “ae”, “af”, “bd”, “be”, “bf”, “cd”, “ce”, “cf”]. 说明: 尽管上面的答案是按字典序排列的，但是你可以任意选择答案输出的顺序。

题目解读：

这个问题的场景就是我们的手机9宫格按键，当我们按下按键时计算出所有的字母组合，当我们按下第一个按键时，现在的组合次数为该按键对应的字母个数(m)。当我们再一次按下一个按键时，现在的次数变成了这一次按键对应的字母个数与上一次的次数相乘(m*n)

反转图像—LeetCode832

Mon, 10 Jun 2019 00:00:00 +0000

题目描述：

给定一个二进制矩阵 A，我们想先水平翻转图像，然后反转图像并返回结果。水平翻转图片就是将图片的每一行都进行翻转，即逆序。例如，水平翻转 [1, 1, 0] 的结果是 [0, 1, 1]。反转图片的意思是图片中的 0 全部被 1 替换， 1 全部被 0 替换。例如，反转 [0, 1, 1] 的结果是 [1, 0, 0]。示例 1: 输入: [[1,1,0],[1,0,1],[0,0,0]] 输出:[[1,0,0],[0,1,0],[1,1,1]] 解释: 首先翻转每一行: [[0,1,1],[1,0,1],[0,0,0]]；然后反转图片: [[1,0,0],[0,1,0],[1,1,1]] 示例 2: 输入: [[1,1,0,0],[1,0,0,1],[0,1,1,1],[1,0,1,0]] 输出: [[1,1,0,0],[0,1,1,0],[0,0,0,1],[1,0,1,0]] 说明: 1 <= A.length = A[0].length <= 20 0 <= A[i][j] <= 1

解题思路：

将每一行进行翻转就是顺序转换，然后再进行反转图片就是将0转换为1，1转换为0，我们可以用 x=1-x来实现

自除数—LeetCode728

Tue, 04 Jun 2019 00:00:00 +0000

题目描述：

自除数是指可以被它包含的每一位数除尽的数。例如，128 是一个自除数，因为 128 % 1 == 0，128 % 2 == 0，128 % 8 == 0。还有，自除数不允许包含 0 。给定上边界和下边界数字，输出一个列表，列表的元素是边界（含边界）内所有的自除数。示例 1：输入：上边界left = 1, 下边界right = 22 输出： [1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 12, 15, 22] 注意：每个输入参数的边界满足 1 <= left <= right <= 10000。

解读：

判断一个数能不能被他的每一位除尽，那就要取出每一位数，进行计算，并且自除数不允许包含0，所以如果有0则直接判断不是自除数

机器人能否返回终点—LeetCode657

Mon, 03 Jun 2019 00:00:00 +0000

题目描述：

在二维平面上，有一个机器人从原点 (0, 0) 开始。给出它的移动顺序，判断这个机器人在完成移动后是否在 (0, 0) 处结束。移动顺序由字符串表示。字符 move[i] 表示其第 i 次移动。机器人的有效动作有 R（右），L（左），U（上）和 D（下）。如果机器人在完成所有动作后返回原点，则返回 true。否则，返回 false。注意：机器人“面朝”的方向无关紧要。 “R” 将始终使机器人向右移动一次，“L” 将始终向左移动等。此外，假设每次移动机器人的移动幅度相同。示例 1: 输入: “UD” 输出: true 解释：机器人向上移动一次，然后向下移动一次。所有动作都具有相同的幅度，因此它最终回到它开始的原点。因此，我们返回 true。示例 2: 输入: “LL” 输出: false 解释：机器人向左移动两次。它最终位于原点的左侧，距原点有两次 “移动” 的距离。我们返回 false，因为它在移动结束时没有返回原点。

唯一摩尔斯密码词—LeetCode804

Sun, 02 Jun 2019 00:00:00 +0000

题目描述：

国际摩尔斯密码定义一种标准编码方式，将每个字母对应于一个由一系列点和短线组成的字符串，比如: “a” 对应 “.-”, “b” 对应 “-…”, “c” 对应 “-.-.”, 等等。为了方便，所有26个英文字母对应摩尔斯密码表如下： [".-","-…","-.-.","-..",".","..-.","–.","….","..",".—","-.-",".-..","–","-.","—",".–.","–.-",".-.","…","-","..-","…-",".–","-..-","-.–","–.."] 给定一个单词列表，每个单词可以写成每个字母对应摩尔斯密码的组合。例如，“cab” 可以写成 “-.-..–…"，(即 “-.-.” + “-…” + “.-“字符串的结合)。我们将这样一个连接过程称作单词翻译。返回我们可以获得所有词不同单词翻译的数量。例如: 输入: words = [“gin”, “zen”, “gig”, “msg”] 输出: 2 解释: 各单词翻译如下: “gin” -> “–…-.” “zen” -> “–…-.” “gig” -> “–…–.” “msg” -> “–…–.” 共有 2 种不同翻译, “–…-.” 和 “–…–.”. 注意: 单词列表words 的长度不会超过 100。每个单词 words[i]的长度范围为 [1, 12]。每个单词 words[i]只包含小写字母。

解题思路：

我们首先要根据给出的单词转换成摩尔斯密码

利用一个数组按照字母顺序存储对应的密码值

将一个单词的每一个字母根据对应位数的摩尔斯密码进行转换然后拼接

这里利用set的不重复特性，将密码放入set集合中，如果有相同的密码则不会加入，最后获取set的长度即可。

Nim游戏—LeetCode292

Sat, 01 Jun 2019 00:00:00 +0000

题目描述：

你和你的朋友，两个人一起玩 Nim 游戏：桌子上有一堆石头，每次你们轮流拿掉 1 - 3 块石头。 拿掉最后一块石头的人就是获胜者。你作为先手。
你们是聪明人，每一步都是最优解。 编写一个函数，来判断你是否可以在给定石头数量的情况下赢得游戏。
示例:
输入: 4
输出: false
解释: 如果堆中有 4 块石头，那么你永远不会赢得比赛；
因为无论你拿走 1 块、2 块 还是 3 块石头，最后一块石头总是会被你的朋友拿走。

思路：

先考虑一下什么情况会输呢，就是最后的石头被对手拿走，那么只要保证最后剩余1-3块石头我们即可获胜。如何能确保最后一定剩余1-3块呢，就要我们在每一步的时候跟对手拿的块数总和等于4。所以我们这道题就可以判断总块数是不是4的倍数，如果不是我们就可以赢。

git使用笔记

Wed, 29 May 2019 00:00:00 +0000

安装

mac

通过`brew`安装

`1`	`brew install git`

通过安装包安装

去官网下载mac系统的安装包，下载完成后安装即可

windows

去官网下载Windows系统的安装包，除了选择安装目录时修改为自己想要的目录，其他一直点击next即可

配置

安装完git后我们需要配置个人信息，姓名和邮箱，这些信息在以后提交时都会显示在提交信息中

# 全局配置 整体有效
git config --global user.name "提交时显示的名字"
git config --global user.email "提交时显示的邮箱"
# 局部配置 对单个项目有效，如果进行了局部配置，会覆盖全局配置
git config --local user.name "提交时显示的名字"
git config --local user.email "提交时显示的邮箱"

配置完成后我们可以通过命令来查看我们的配置信息，例如下面这就会显示我们配置的名称

`1`	`git config user.name`

常用命令

初始化

`1`	`git init`

添加文件

`1`	`git add test.md`

提交注释

`1`	`git commit -m '注释内容'`

关联远程仓库

`1`	`git remote add [shortname] [url]`

查看当前的远程库

git remote
origin
# 也可添加 -v 选项 显示对应的克隆地址
git remote -v

origin  git://github.com/schacon/ticgit.git (fetch)
origin  git://github.com/schacon/ticgit.git (push)

推送到远程仓库

1
2

# remote-name默认为origin ，branch-name默认为master
git push [remote-name] [branch-name]

从远程仓库拉取代码

git pull

Java Socket基础

Thu, 09 May 2019 00:00:00 +0000

socket简介

https://blog.csdn.net/httpdrestart/article/details/80670388

简单socket连接

基于TCP的socket连接

服务端

服务端的实现主要分为以下几步：

第一步：创建socket服务，指定端口

第二步：调用accep()方法开始监听，等待客户端的连接

第三步：获取客户端的输入流

第四步：响应客户端信息，获取输出流

第五步：关闭资源

import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;

/**
 * tcp socket 服务端
 *
 * @author LiuNaiJie
 * on 2019-05-08
 */
public class TcpSocketServer {

	public static void main(String[] args) {
		try {
			// 1.连接socket连接，指定端口9090
			ServerSocket serverSocket = new ServerSocket(9090);
			System.out.println("服务端已启动，等待客户端连接");
			// 2.等待客户端连接，此时处于阻塞状态
			Socket socket = serverSocket.accept();

			// 3.获取客户端的信息
			// 字节流
			InputStream inputStream = socket.getInputStream();
			// 转换为字符流
			InputStreamReader inputStreamReader = new InputStreamReader(inputStream);
			// 建立缓存
			BufferedReader bufferedReader = new BufferedReader(inputStreamReader);
			String receiveLine;
			StringBuilder stringBuilder = new StringBuilder();
			while ((receiveLine = bufferedReader.readLine()) != null) {
				System.out.println("客户端的一行信息为：" + receiveLine);
				stringBuilder.append(receiveLine);
			}
			String receiveMsg = stringBuilder.toString();
			System.out.println("客户端的全部信息为：" + receiveMsg);

			// 4.返回信息
			String returnMsg = "你好，socket";
			OutputStream outputStream = socket.getOutputStream();
			OutputStreamWriter outputStreamWriter = new OutputStreamWriter(outputStream);
			BufferedWriter bufferedWriter = new BufferedWriter(outputStreamWriter);
			bufferedWriter.write(returnMsg);
			bufferedWriter.flush();

			// 5.关闭信息流
			bufferedWriter.close();
			outputStreamWriter.close();
			outputStream.close();

			bufferedReader.close();
			inputStreamReader.close();
			inputStream.close();

		} catch (IOException e) {
			System.out.println("服务端建立socket失败。。。。");
			e.printStackTrace();
		}
	}

}

客户端

客户端的实现主要为以下几步：

杨辉三角—LeetCode118

Sun, 05 May 2019 00:00:00 +0000

题目描述

给定一个非负整数 numRows，生成杨辉三角的前 numRows 行。

在杨辉三角中，每个数是它左上方和右上方的数的和。

示例:

输入: 5 输出: [ [1], [1,1], [1,2,1], [1,3,3,1], [1,4,6,4,1] ]

nginx源码编译安装

Thu, 11 Apr 2019 00:00:00 +0000

在一些平台上我们可以轻松的使用命令安装nginx，但是安装完成的软件在某些时候可能并不能满足我们的需求，这时候可能就需要从源码来进行编译安装了。

提前需要安装的软件

Ubuntu

1
2

sudo apt-get install gcc automake autoconf make libpcre3 libpcre3-dev
sudo apt-get install openssl # 开启ssl、https时需要

centos

1
2

yum -y install gcc gcc-c++ zlib zlib-devel openssl openssl-devel pcre pcre-devel unzip zip
yum -y install openssl-devel # 开启ssl、https时需要

树莓派

`1`	`sudo apt-get install -y make gcc libpcre3 libpcre3-dev libperl-dev libssl-dev libcurl4-openssl-dev`

下载、解压

去官网找到最近的稳定版本，右键复制下载链接

1
2

wget 下载链接
tar -zxvf 下载的压缩包

编译

进入解压完成的文件夹，执行编译命令

只出现一次的数字—LeetCode136

Thu, 11 Apr 2019 00:00:00 +0000

题目描述：

给定一个非空整数数组，除了某个元素只出现一次以外，其余每个元素均出现两次。找出那个只出现了一次的元素。

示例1：

输入：[2,2,1]
输出：1

示例2：

输入：[4,1,2,1,2]
输出：4

解题思路：

刚开始是这样想的，先进行排序，然后我们两个一组，如果这两个数字一样，则开始下一组。如果不一样，那么第一个就是我们要找的元素。我们这组元素是奇数个，所以如果前面的都是相同的，那最后剩下的这个元素就是我们要找的元素。

代码：

public int singleNumber(int[] nums) {
       //排序
		Arrays.sort(nums);
    	// 默认第一个元素
		int result = nums[0];
		int count = nums.length;
    	// 两个一组
		for (int i = 0; i < count; i += 2) {
			int first = nums[i];
            //如果是最后一个，那么直接返回
			if (i == count - 1) {
				return first;
			}
			int second = nums[i + 1];
            // 如果两个数字不一样，返回第一个数字
			if (first != second) {
				return first;
			}
		}
		return result;
	}

提交后发现我这个代码运行需要9ms，然后看了前面的代码，发现了一个很好的点：利用异或操作。(两个数字异或，相同得0，不同得1)。

删除链表中的节点—LeetCode237

Sun, 07 Apr 2019 00:00:00 +0000

题目描述

请编写一个函数，使其可以删除某个链表中给定的（非末尾）节点，你将只被给定要求被删除的节点。

示例 1:

输入: head = [4,5,1,9], node = 5 输出: [4,1,9] 解释: 给定你链表中值为 5 的第二个节点，那么在调用了你的函数之后，该链表应变为 4 -> 1 -> 9. 示例 2:

输入: head = [4,5,1,9], node = 1 输出: [4,5,9] 解释: 给定你链表中值为 1 的第三个节点，那么在调用了你的函数之后，该链表应变为 4 -> 5 -> 9.

说明:

链表至少包含两个节点。链表中所有节点的值都是唯一的。给定的节点为非末尾节点并且一定是链表中的一个有效节点。不要从你的函数中返回任何结果。

微信、支付宝小程序二码合一

Sun, 07 Apr 2019 00:00:00 +0000

背景

随着现在小程序的流行，许多软件也将web页面转移到小程序之中。让用户更方便的使用。当我们做了微信和支付宝两个的小程序后，意味着我们要将两个二维码展示给用户扫码。所以当需要将微信、支付宝小程序二维码合一，或者对其做一些自定义操作时，就不能再使用官方提供的二维码生成接口。

微信、支付宝官方也提供了自定义二维码的文档：

微信：https://developers.weixin.qq.com/miniprogram/introduction/qrcode.html

支付宝：https://docs.alipay.com/mini/introduce/vzd5v0

所以通过上面的设置就可以实现二维码合一的操作。

原理解析

二维码存储的是一串信息，微信官网二维码里面可能存储的为：https://weixin.com?appid=123。支付宝二维码存储的可能是：https://alipay.com?appid=abc。这种有一定规则的信息。
我们通过两个的自定义设置，将访问两者小程序的二维码信息进行合一。比如，定义：https://www.abc.com，让微信和支付宝扫描到这个信息后都跳转到我们的小程序中。那就可以实现二维码合一。

frp内网穿透并绑定自已的域名

Wed, 20 Mar 2019 00:00:00 +0000

环境需求

一台有公网ip的机器，一台内网的机器(以树莓派为例)
使用软件：nginx、frp

frp软件地址：https://github.com/fatedier/frp

申请自己的域名，并将域名解析到公网ip(可以为三级或四级域名)(可选)

frp配置

我们首先需要根据自己的机型下载适合的版本，要注意的是服务器与客户端都要使用同一个frp版本

下载地址：https://github.com/fatedier/frp/releases

比如我使用的树莓派是arm系统的，就选择了最新版本的linux_arm版本，下载完成后解压，进入

服务器：

服务器修改的是frps.ini配置文件

 [common]
 bind_port = 7000  # 绑定本机的端口
 vhost_http_port = 7001  #http访问的端口
 subdomail_host = pi.liunaijie.top # 自己的域名

然后后台启动即可：nohup ./frps -c ./frps.ini &

默认日志为nohup.out，可以查看这个文件查看frp是否正常启动

树莓派(或其他内网机器)

客户端修改frpc.ini配置文件

[common]
server_addr = x.x.x.x #公网的ip地址
server_port = 7000 # 服务器开启的端口

[ssh]  # 开启ssh
type = tcp
local_ip = 127.0.0.1
local_port = 22
remote_port = 6000 # 远程ssh端口

[web] # web服务
type = http 
local_port = 80 
custom_domains = pi.liunaijie.top  # 我们自己的域名，可以通过这个域名访问这个机器

然后后台启动服务nohup ./frpc -c ./frpc.ini &。要注意的是我们要先开启服务器的服务，不然本地是无法开启的。

买卖股票的最佳时机II-LeetCode122

Mon, 18 Mar 2019 00:00:00 +0000

题目描述

给定一个数组，它的第 i 个元素是一支给定股票第 i 天的价格。

设计一个算法来计算你所能获取的最大利润。你可以尽可能地完成更多的交易（多次买卖一支股票）。

注意：你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。

示例 1:

输入: [7,1,5,3,6,4] 输出: 7 解释: 在第 2 天（股票价格 = 1）的时候买入，在第 3 天（股票价格 = 5）的时候卖出, 这笔交易所能获得利润 = 5-1 = 4 。随后，在第 4 天（股票价格 = 3）的时候买入，在第 5 天（股票价格 = 6）的时候卖出, 这笔交易所能获得利润 = 6-3 = 3 。示例 2:

输入: [1,2,3,4,5] 输出: 4 解释: 在第 1 天（股票价格 = 1）的时候买入，在第 5 天（股票价格 = 5）的时候卖出, 这笔交易所能获得利润 = 5-1 = 4 。注意你不能在第 1 天和第 2 天接连购买股票，之后再将它们卖出。因为这样属于同时参与了多笔交易，你必须在再次购买前出售掉之前的股票。示例 3:

输入: [7,6,4,3,1] 输出: 0 解释: 在这种情况下, 没有交易完成, 所以最大利润为 0

题目中给出数组，第i个元素表示第i天的价格，我们要做的是求出能获取的最大利润，并且没有限制购买次数，我们可以第一天买入，最后一天卖出。也可以当天买入，第二天就卖出，然后再买入，再卖出。但是我们只能同时有一笔交易。

爬楼梯-LeetCode70

Sat, 16 Mar 2019 00:00:00 +0000

题目描述

链接: https://leetcode-cn.com/problems/climbing-stairs/

假设你正在爬楼梯。需要 n 阶你才能到达楼顶。

每次你可以爬 1 或 2 个台阶。问你有多少种不同的方法可以爬到楼顶？

示例 1：

输入： 2 输出： 2 有两种方法可以爬到楼顶。

第一种: 1 阶 + 1 阶

第二种: 2 阶

示例 2：

输入： 3

输出： 3

有三种方法可以爬到楼顶。

1 阶 + 1 阶 + 1 阶

1 阶 + 2 阶

2 阶 + 1 阶

微信小程序支付

Fri, 15 Mar 2019 00:00:00 +0000

微信小程序支付流程：

根据流程图，我们支付的流程应该是：

用户在微信小程序点击下单，小程序请求我们自己的后台程序
后台在接收到下单请求后，先进行自己的业务逻辑，生成预订单，然后请求微信的下单接口。微信接口对我们请求进行校验，通过后返回 prepay_id(预付款 id)。
- 在这里要获取小程序用户的 openid。一般在下单前就获取到了，或者在这里再进行访问微信接口进行获取
- 发送请求时需要经过签名等操作
- 在向微信请求时，参数中有一个通知地址，支付成功后微信会向这个地址发送通知。
- 拿到 prepay_id 后，需要再次签名。然后将数据返回给小程序
微信小程序获取到请求响应，响应数据里面有预付款 id，然后通过微信提供的支付方法进行付款。
付款成功后，微信会向下单时提供的通知地址发送通知。通知数据里面有实际付款金额等信息。

无重复字符的最长子串-LeetCode3

Tue, 12 Mar 2019 00:00:00 +0000

题目描述

给定一个字符串，请你找出其中不含有重复字符的最长子串的长度。

示例 1:

输入: “abcabcbb” 输出: 3 解释: 因为无重复字符的最长子串是 “abc”，所以其长度为 3。示例 2:

输入: “bbbbb” 输出: 1 解释: 因为无重复字符的最长子串是 “b”，所以其长度为 1。示例 3:

输入: “pwwkew” 输出: 3 解释: 因为无重复字符的最长子串是 “wke”，所以其长度为 3。请注意，你的答案必须是子串的长度，“pwke” 是一个子序列，不是子串。

要注意这个题目最后要求返回的是长度，并不是最长的子串内容是什么

存在重复元素-LeetCode217

Sun, 10 Mar 2019 00:00:00 +0000

题目描述

给定一个整数数组，判断是否存在重复元素。

如果任何值在数组中出现至少两次，函数返回 true。如果数组中每个元素都不相同，则返回 false。

示例 1:

输入: [1,2,3,1] 输出: true 示例 2:

输入: [1,2,3,4] 输出: false 示例 3:

输入: [1,1,1,3,3,4,3,2,4,2] 输出: true

判断数组中是否有元素存在重复值。

搜索插入位置-LeetCode35

Wed, 06 Mar 2019 00:00:00 +0000

题目描述

给定一个排序数组和一个目标值，在数组中找到目标值，并返回其索引。如果目标值不存在于数组中，返回它将会被按顺序插入的位置。

你可以假设数组中无重复元素。

示例 1:

输入: [1,3,5,6], 5 输出: 2 示例 2:

输入: [1,3,5,6], 2 输出: 1 示例 3:

输入: [1,3,5,6], 7 输出: 4 示例 4:

输入: [1,3,5,6], 0 输出: 0

对称二叉树—LeetCode101

Mon, 25 Feb 2019 00:00:00 +0000

题目描述

给定一个二叉树，检查它是否是镜像对称的。

例如，二叉树 [1,2,2,3,4,4,3] 是对称的。
    1
   / \
  2   2
 / \ / \
3  4 4  3
但是下面这个 [1,2,2,null,3,null,3] 则不是镜像对称的:
    1
   / \
  2   2
   \   \
   3    3
说明:

如果你可以运用递归和迭代两种方法解决这个问题，会很加分。

打印从1到最大的n位数—LeetCodeM17

Thu, 21 Feb 2019 00:00:00 +0000

题目描述

输入数字 n，按顺序打印出从 1 到最大的 n 位十进制数。比如输入 3，则打印出 1、2、3 一直到最大的 3 位数 999。

示例 1:
输入: n = 1
输出: \[1,2,3,4,5,6,7,8,9] 
说明：

用返回一个整数列表来代替打印

n 为正整数

首先要获取最大值，然后遍历添加到数组中，而通过位数获取最大值可以通过10^n^来获取。

二进制链表转整数-LeetCode1290

Thu, 21 Feb 2019 00:00:00 +0000

题目描述

给你一个单链表的引用结点 head。链表中每个结点的值不是 0 就是 1。已知此链表是一个整数数字的二进制表示形式。

请你返回该链表所表示数字的 十进制值 。

示例 1：
输入：head = \[1,0,1]
输出：5
解释：二进制数 (101) 转化为十进制数 (5)
示例 2：
输入：head = \[0]
输出：0
示例 3：
输入：head = \[1]
输出：1
示例 4：
输入：head = \[1,0,0,1,0,0,1,1,1,0,0,0,0,0,0]
输出：18880
示例 5：
输入：head = \[0,0]
输出：0
提示：

链表不为空。

链表的结点总数不超过 30。

每个结点的值不是 0 就是 1。

Ubuntu16编译openwrt

Tue, 22 Jan 2019 00:00:00 +0000

Ubuntu16编译openwrt

新安装的Ubuntu首先更新软件源

sudo apt update

更新系统软件

sudo apt dist-upgrade

安装系统openwrt需要的环境

sudo apt-get install build-essential subversion libncurses5-dev zlib1g-dev gawk gcc-multilib flex git-core gettext libssl-dev unzip

下载openwrt

git clone https://github.com/openwrt/openwrt.git

更新feeds

1
2
3

cd openwrt
./scripts/feeds update -a
./scripts/feeds install -a

使用默认配置

make defconfig

使用界面编译

make menuconfig

开始编译

make V=s

编译完成后会在bin/target目录下生成固件

刷机

使用breed uboot

开启sftp服务

opkg update 
opkg install vsftpd
/etc/init.d/vsftpd enable
/etc/init.d/vsftpd start

安装nginx

Hexo使用

Thu, 17 Jan 2019 00:00:00 +0000

其实根据官网文档就很容易进行安装了，官网文档链接，所以也不写安装和启动的流程了。

安装主题

修改配置

项目配置
主题配置

部署、发布

修改_config.yml配置文件，支持多个配置信息，如果多个需要如下填写

# 单个配置
deploy:
  type: git
  repo:
# 多个配置
deploy:
- type: git
  repo:
- type: sftp
  repo:

发布到github

先进行安装npm install hexo-deployer-git --save

deploy:
  type: git
  repo: # 仓库地址，最好使用http的协议，使用ssh协议时有可能会报错
  branch: #发布的分支，默认是 master
  message: # 提交的信息

发布到个人服务器（sftp）

有序数组的平方—LeetCode977

Wed, 09 Jan 2019 00:00:00 +0000

题目描述

给定一个按非递减顺序排序的整数数组 A，返回每个数字的平方组成的新数组，要求也按非递减顺序排序。

示例 1：

输入：[-4,-1,0,3,10] 输出：[0,1,9,16,100] 示例 2：

输入：[-7,-3,2,3,11] 输出：[4,9,9,49,121]

提示：

1 <= A.length <= 10000 -10000 <= A[i] <= 10000 A 已按非递减顺序排序。

最大二叉树—LeetCode654

Tue, 08 Jan 2019 00:00:00 +0000

题目描述

给定一个不含重复元素的整数数组。一个以此数组构建的最大二叉树定义如下：

二叉树的根是数组中的最大元素。左子树是通过数组中最大值左边部分构造出的最大二叉树。右子树是通过数组中最大值右边部分构造出的最大二叉树。通过给定的数组构建最大二叉树，并且输出这个树的根节点。

示例：

输入：[3,2,1,6,0,5] 输出：返回下面这棵树的根节点：
  		6
    /   \
   3     5
    \    / 
     2  0   
       \
        1
提示：

给定的数组的大小在 [1, 1000] 之间。

x的平方根—LeetCode69

Sat, 05 Jan 2019 00:00:00 +0000

题目描述

实现 int sqrt(int x) 函数。

计算并返回 x 的平方根，其中 x 是非负整数。

由于返回类型是整数，结果只保留整数的部分，小数部分将被舍去。

示例 1:

输入: 4 输出: 2 示例 2:

输入: 8 输出: 2 说明: 8 的平方根是 2.82842…, 由于返回类型是整数，小数部分将被舍去。

按递增顺序显示卡牌—LeetCode950

Sat, 05 Jan 2019 00:00:00 +0000

题目描述

牌组中的每张卡牌都对应有一个唯一的整数。你可以按你想要的顺序对这套卡片进行排序。

最初，这些卡牌在牌组里是正面朝下的（即，未显示状态）。

现在，重复执行以下步骤，直到显示所有卡牌为止：

从牌组顶部抽一张牌，显示它，然后将其从牌组中移出。如果牌组中仍有牌，则将下一张处于牌组顶部的牌放在牌组的底部。如果仍有未显示的牌，那么返回步骤 1。否则，停止行动。返回能以递增顺序显示卡牌的牌组顺序。

答案中的第一张牌被认为处于牌堆顶部。

示例：

输入：[17,13,11,2,3,5,7] 输出：[2,13,3,11,5,17,7] 解释：我们得到的牌组顺序为 [17,13,11,2,3,5,7]（这个顺序不重要），然后将其重新排序。重新排序后，牌组以 [2,13,3,11,5,17,7] 开始，其中 2 位于牌组的顶部。我们显示 2，然后将 13 移到底部。牌组现在是 [3,11,5,17,7,13]。我们显示 3，并将 11 移到底部。牌组现在是 [5,17,7,13,11]。我们显示 5，然后将 17 移到底部。牌组现在是 [7,13,11,17]。我们显示 7，并将 13 移到底部。牌组现在是 [11,17,13]。我们显示 11，然后将 17 移到底部。牌组现在是 [13,17]。我们展示 13，然后将 17 移到底部。牌组现在是 [17]。我们显示 17。由于所有卡片都是按递增顺序排列显示的，所以答案是正确的。

提示：

1 <= A.length <= 1000 1 <= A[i] <= 10^6 对于所有的 i != j，A[i] != A[j]

转换为小写字母—LeetCode709

Thu, 03 Jan 2019 00:00:00 +0000

题目描述

实现函数 ToLowerCase()，该函数接收一个字符串参数 str，并将该字符串中的大写字母转换成小写字母，之后返回新的字符串。

示例 1：

输入: “Hello” 输出: “hello” 示例 2：

输入: “here” 输出: “here” 示例 3：

输入: “LOVELY” 输出: “lovely”

按奇偶排序数组-LeetCode905

Wed, 02 Jan 2019 00:00:00 +0000

题目描述

给定一个非负整数数组 A，返回一个数组，在该数组中， A 的所有偶数元素之后跟着所有奇数元素。

你可以返回满足此条件的任何数组作为答案。

示例：

输入：[3,1,2,4] 输出：[2,4,3,1] 输出 [4,2,3,1]，[2,4,1,3] 和 [4,2,1,3] 也会被接受。

提示：

1 <= A.length <= 5000 0 <= A[i] <= 5000

独特的电子邮件地址-LeetCode929

Fri, 21 Dec 2018 00:00:00 +0000

题目描述

每封电子邮件都由一个本地名称和一个域名组成，以 @ 符号分隔。

例如，在 alice@leetcode.com中， alice 是本地名称，而 leetcode.com 是域名。

除了小写字母，这些电子邮件还可能包含 ‘.’ 或 ‘+’。

如果在电子邮件地址的本地名称部分中的某些字符之间添加句点（’.’），则发往那里的邮件将会转发到本地名称中没有点的同一地址。例如，“alice.z@leetcode.com” 和 “alicez@leetcode.com” 会转发到同一电子邮件地址。（请注意，此规则不适用于域名。）

如果在本地名称中添加加号（’+’），则会忽略第一个加号后面的所有内容。这允许过滤某些电子邮件，例如 m.y+name@email.com 将转发到 my@email.com。（同样，此规则不适用于域名。）

可以同时使用这两个规则。

给定电子邮件列表 emails，我们会向列表中的每个地址发送一封电子邮件。实际收到邮件的不同地址有多少？

示例：

输入：[“test.email+alex@leetcode.com”,“test.e.mail+bob.cathy@leetcode.com”,“testemail+david@lee.tcode.com”] 输出：2 解释：实际收到邮件的是 “testemail@leetcode.com” 和 “testemail@lee.tcode.com”。

提示：

1 <= emails[i].length <= 100 1 <= emails.length <= 100 每封 emails[i] 都包含有且仅有一个 ‘@’ 字符。

最后一个单词的长度-LeetCode58

Thu, 20 Dec 2018 00:00:00 +0000

题目描述

给定一个仅包含大小写字母和空格 ’ ’ 的字符串 s，返回其最后一个单词的长度。如果字符串从左向右滚动显示，那么最后一个单词就是最后出现的单词。

如果不存在最后一个单词，请返回 0 。

说明：一个单词是指仅由字母组成、不包含任何空格字符的最大子字符串。

示例:

输入: “Hello World” 输出: 5

宝石与石头-LeetCode771

Wed, 19 Dec 2018 00:00:00 +0000

题目描述

给定字符串J 代表石头中宝石的类型，和字符串 S代表你拥有的石头。 S 中每个字符代表了一种你拥有的石头的类型，你想知道你拥有的石头中有多少是宝石。

J 中的字母不重复，J 和 S中的所有字符都是字母。字母区分大小写，因此"a"和"A"是不同类型的石头。

示例 1:

输入: J = “aA”, S = “aAAbbbb” 输出: 3 示例 2:

输入: J = “z”, S = “ZZ” 输出: 0 注意:

S 和 J 最多含有50个字母。 J 中的字符不重复。

利用goaccess实时监控nginx的访问日志

Sat, 15 Dec 2018 00:00:00 +0000

这篇文章主要写一下我在利用goaccess查看nginx生成的访问日志时的经历。

最终会生成一个下面类似的网页：

最长公共前缀-LeetCode14

Wed, 12 Dec 2018 00:00:00 +0000

题目描述

编写一个函数来查找字符串数组中的最长公共前缀。

如果不存在公共前缀，返回空字符串 ""。

示例 1:
输入: \["flower","flow","flight"]
输出: "fl"
示例 2:
输入: \["dog","racecar","car"]
输出: ""
解释: 输入不存在公共前缀。
说明:

所有输入只包含小写字母 a-z 。

罗马数字转整数-LeetCode13

Mon, 10 Dec 2018 00:00:00 +0000

题目描述

罗马数字包含以下七种字符: I， V， X， L，C，D 和 M。

字符数值 I 1 V 5 X 10 L 50 C 100 D 500 M 1000 例如，罗马数字 2 写做 II ，即为两个并列的 1。12 写做 XII ，即为 X + II 。 27 写做 XXVII, 即为 XX + V + II 。

通常情况下，罗马数字中小的数字在大的数字的右边。但也存在特例，例如 4 不写做 IIII，而是 IV。数字 1 在数字 5 的左边，所表示的数等于大数 5 减小数 1 得到的数值 4 。同样地，数字 9 表示为 IX。这个特殊的规则只适用于以下六种情况：

I 可以放在 V (5) 和 X (10) 的左边，来表示 4 和 9。 X 可以放在 L (50) 和 C (100) 的左边，来表示 40 和 90。 C 可以放在 D (500) 和 M (1000) 的左边，来表示 400 和 900。给定一个罗马数字，将其转换成整数。输入确保在 1 到 3999 的范围内。

示例 1:

输入: “III” 输出: 3 示例 2:

输入: “IV” 输出: 4 示例 3:

输入: “IX” 输出: 9 示例 4:

输入: “LVIII” 输出: 58 解释: L = 50, V= 5, III = 3. 示例 5:

输入: “MCMXCIV” 输出: 1994 解释: M = 1000, CM = 900, XC = 90, IV = 4.

删除排序数组中的重复项—LeetCode26

Mon, 10 Sep 2018 00:00:00 +0000

题目描述

给定一个排序数组，你需要在原地删除重复出现的元素，使得每个元素只出现一次，返回移除后数组的新长度。

不要使用额外的数组空间，你必须在原地修改输入数组并在使用 O(1) 额外空间的条件下完成。

示例 1:

给定数组 nums = [1,1,2],

函数应该返回新的长度 2, 并且原数组 nums 的前两个元素被修改为 1, 2。

你不需要考虑数组中超出新长度后面的元素。示例 2:

给定 nums = [0,0,1,1,1,2,2,3,3,4],

函数应该返回新的长度 5, 并且原数组 nums 的前五个元素被修改为 0, 1, 2, 3, 4。

你不需要考虑数组中超出新长度后面的元素。

说明:

为什么返回数值是整数，但输出的答案是数组呢?

请注意，输入数组是以「引用」方式传递的，这意味着在函数里修改输入数组对于调用者是可见的。

你可以想象内部操作如下:

// nums 是以“引用”方式传递的。也就是说，不对实参做任何拷贝 int len = removeDuplicates(nums);

// 在函数里修改输入数组对于调用者是可见的。 // 根据你的函数返回的长度, 它会打印出数组中该长度范围内的所有元素。 for (int i = 0; i < len; i++) { print(nums[i]); }

这个题目有几个要求，原地算法，即不能使用额外的空间，空间复杂度要求O(1)。

同时我们不需要考虑数组中超出新长度后面的元素，实例1，我们最后给出的结果是[1,2,*]。第三个元素肯定是有的，不用对它进行重置等操作。

同时这个题，要求的返回结果是新的长度，即没有重复元素的个数。

旋转数组—LeetCode189

Wed, 29 Aug 2018 00:00:00 +0000

题目描述

给定一个数组，将数组中的元素向右移动 k 个位置，其中 k 是非负数。

示例 1:

输入: [1,2,3,4,5,6,7] 和 k = 3 输出: [5,6,7,1,2,3,4] 解释: 向右旋转 1 步: [7,1,2,3,4,5,6] 向右旋转 2 步: [6,7,1,2,3,4,5] 向右旋转 3 步: [5,6,7,1,2,3,4] 示例 2:

输入: [-1,-100,3,99] 和 k = 2 输出: [3,99,-1,-100] 解释: 向右旋转 1 步: [99,-1,-100,3] 向右旋转 2 步: [3,99,-1,-100] 说明:

尽可能想出更多的解决方案，至少有三种不同的方法可以解决这个问题。要求使用空间复杂度为 O(1) 的原地算法。

首先我们要明确一个问题，当k超过数组长度时，我们要将k对数组长度取余。当k等于数组长度时，不用进行操作直接返回。

解题思路

暴力

从上面的步骤可以看到我们可以移动k次，每一次向右移动一次。

public void rotate(int[] nums, int k) {
  int length = nums.length;
  //对k的处理
  if(k==length){
    return;
  }else if(k>length){
    k %= length;
  }
  //移动k次，
  for (int i = 0; i <k ; i++) {
    //将最后一个元素暂时存储，然后将数组从头开始向后挪动一位，移动元素长度-1个。然后再将第一个置为临时元素。
    int temp = nums[length-1];
    System.arraycopy(nums,0,nums,1,nums.length-1);
    nums[0]=temp;
  }
}

复杂度分析：

加一—LeetCode66

Mon, 27 Aug 2018 00:00:00 +0000

题目描述

给定一个由整数组成的非空数组所表示的非负整数，在该数的基础上加一。

最高位数字存放在数组的首位，数组中每个元素只存储单个数字。

你可以假设除了整数 0 之外，这个整数不会以零开头。

示例 1:

输入: [1,2,3] 输出: [1,2,4] 解释: 输入数组表示数字 123。示例 2:

输入: [4,3,2,1] 输出: [4,3,2,2] 解释: 输入数组表示数字 4321。

一个数组，每一位表示一个数字，高位在前面，然后需要将这个值加一，并且按照数组的形式返回。

两数之和—LeetCode1

Sat, 25 Aug 2018 00:00:00 +0000

题目描述

给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那两个整数，并返回他们的数组下标。

你可以假设每种输入只会对应一个答案。但是，你不能重复利用这个数组中同样的元素。

示例:

给定 nums = [2, 7, 11, 15], target = 9

因为 nums[0] + nums[1] = 2 + 7 = 9 所以返回 [0, 1]

网络租车系统

Sun, 10 Jun 2018 00:00:00 +0000

毕业设计-基于SSM架构的网络租车系统

项目来源：

之前就做了一个简易的租车都不能说是项目的项目，就是将数据库中的信息在页面以表格形式展示，输入租车天数，租赁数量确定租车信息。所以毕业设计以此为思路做一个项目。

这个项目也是之前做的，也没有进行优化，如果需要代码可以给我发送邮件：liunaijie1996@163.com 。并且希望你能进行一些改进，这才是开源项目的目的，而不是让大家做伸手党。

– 项目代码已经找不到了。。。 -2019-11-11

项目说明：

项目定位是一个租车平台，即将线下租车公司的资源进行整合。让线下租车公司进驻平台，推广平台，获取用户。

架构： SSM(spring+springmvc+mybatis) 使用该框架主要是实习期间接触了这个框架（第一次使用框架），觉得这个框架整体较之前写的简单，例如在controller类文件中加注解等方式就可以配置控制层。 maven：使用maven方式构建项目，整体项目小，不在有lib文件夹，调整jar包只需修改pom文件。

Java实现经典问题算法

Mon, 27 Nov 2017 00:00:00 +0000

反转排序

以相反的顺序把原有数组的内容重新排序

/**
*基本思想：将数组的最后一个元素与第一个元素替换，倒数第二个元素与第二个元素替换
*/
public void ReverseSort(int[] array){
    for(int i=0;i<array.length/2;i++){
        int temp=array[i];
        array[i]=array[array.length-1-i];
        array[array.length-1-i]=temp;
    }
}

费氏数列

题目：古典问题：有一对兔子，从出生后第3个月起每个月都生一对兔子，小兔子长到第四个月后每个月又生一对兔子，假如兔子都不死，问第n个月的兔子数量为多少？分析：兔子的数量规律为：1,1,2,3,5,8,13,21…. 当n>=3时，fn=f(n-1)+f(n-2); n为下标

java实现：

public int getCount(int N){
    if(N==1||N==2){
        return 1;
    }else {
        return getCount(N-1)+getCount(N-2);
    }
}

判断素数个数并输出

素数：除了1和它本身以外不再有其他因数判断N到M直接素数的个数，并输出（N < M）

/**
* 两次循环
*第一次循环是n到m，取每个数
*第二个循环是判断这个数是不是素数
*/
public void judgePrimeNumber(int N;int M){
    int count=0;
    for(int i=N;i<=M;i++){
        boolean flag=true;
        //从2到自身-1，如果有因数，则退出判断
        for(int j=2;j<i;j++){
            if(i%j==0){
                flag=flase;
                break;
            }
        }
        //判断这个数是不是素数，如果是则数量加1并打印
        if(flag==true){
            count+=1;
            System.out.print(i+" ");
        }
    }
    System.out.println("从"+N+"到"+M+"有"+count+"个素数");
}

打印图形类

菱形：

cassandra的安装与集群部署

Wed, 22 Nov 2017 00:00:00 +0000

前提

安装jdk1.8以上，python2.7

安装Cassandra

Cassandra的下载地址：http://cassandra.apache.org/download/ 下载后将文件解压到某目录下，然后配置环境变量 CASSANDRA_HOME为你解压的目录， path为%CASSANDRA_HOME%\bin 然后用管理员身份运行cmd（不然可能提示权限不够）进入Cassandra目录下的bin，执行cassandra 然后如果成功会出一大堆东西，并且不能再输入命令；

查询状态

再打开一个cmd窗口，原来的不要关闭进入bin文件夹执行nodetool status 这是成功状态，然后输入cqlsh进入编写sql

如果执行cqlsh时出现Can't detect python version需要到pylib目录下执行python setup.py install

出现cqlsh>开头就表示你现在正在编写sql；

查询命令

查看表空间 describe keyspaces；查看已有表：describe tables; 查看表结构：describe table table_name;

多节点部署

以上是单个几点的安装，下面是多个节点的集群部署： 修改配置文件：cassandra.yaml cluster_name：集群名称。如果启动过数据库再修改集群名称需要先执行命令: 进入cqlsh执行 UPDATE system.local SET cluster_name = '你修改后的名称' where key='local'; 退出cqlsh状态，执行nodetool flush system seeds节点，将每个节点的ip加进去，"x.x.x.x,xx.xx.xx.xx"不用加尖括号！ listen_address改为自己的ip地址 rpc_address改为自己的ip地址重启数据库。再次执行cqlsh命令，后面需要加自己的ip

About Me

Sun, 15 Oct 2017 00:00:00 +0000

Hi, I’m Jarvis. Nice to meet you here.

知识就像一个圆，你知道的越多，你就会发现你不知道的越多。保持谦虚，保持学习。 Knowledge is like a circle; the more you know, the more you realize how much you don’t know. Stay humble and keep learning.

list循环添加相同的map

Mon, 25 Sep 2017 00:00:00 +0000

list里面嵌套map，如果map相同，后面的map信息会替代前面的map信息，所以要将map的new放在循环里

如果将map放在循环外，list的信息将全为最后一个map的信息

Map map=new HashMap();
List list=new ArrayList();
for (int i=0;i<10;i++){
   map.put("first",i);
   map.put("second",i+1);
   list.add(map);
}
System.out.println(list);

结果为[{first=9,second=10}]

List list=new ArrayList();
for (int i=0;i<10;i++){
  Map map=new HashMap();
  map.put("first",i);
  map.put("second",i+1);
  list.add(map);
}
System.out.println(list);

结果为[{first=0,second=1},…..,{first=9,second=10}]

因为map添加相同的键，后面的值会覆盖前面的值，所以我们在循环的时候需要重新new这个map

Mon, 01 Jan 0001 00:00:00 +0000