飞乐

github创建action部署用户

Thu, 01 Oct 2026 22:29:53 +0800

账户准备

# 1. 创建 git 用户（禁用密码登录，更安全）
sudo adduser git --disabled-password --gecos ""
# 2. 一键创建 .ssh 目录并生成 Ed25519 密钥对
# (利用 -u git 确保生成的文件直接属于 git 用户，无需后续 chown)
sudo -u git mkdir -p /home/git/.ssh
sudo chmod 700 /home/git/.ssh
sudo -u git ssh-keygen -t ed25519 -C "github-actions-deploy-key" -f /home/git/.ssh/github_actions -N ""
# 3. 将公钥加入授权列表
sudo -u git sh -c 'cat /home/git/.ssh/github_actions.pub >> /home/git/.ssh/authorized_keys'
# 4. 严格设置规范的权限
sudo chmod 600 /home/git/.ssh/authorized_keys
sudo chmod 644 /home/git/.ssh/github_actions.pub

目录赋权

用acl权限控制

腾讯COS对象存储申请API访问

Mon, 14 Oct 2024 23:00:02 +0800

创建子账号

https://console.cloud.tencent.com/cam/user/create?systemType=FastCreateV2

点击权限

输入对象存储，搜索并选择策略

创建API

点击API创建，保存下key和secret

创建COS桶

后续便可以通过API访问COS桶了

宝塔面板使用腾讯云COS自动备份

Sun, 06 Oct 2024 22:04:54 +0800

腾讯云COS自动备份

软件仓库搜索腾讯云COS并安装

配置访问存储桶的相关API信息

具体配置关联腾讯COS对象存储申请API访问

配置计划任务

centos7编译安装python3.11

Sun, 06 Oct 2024 22:00:46 +0800

sudo yum install gcc openssl-devel bzip2-devel libffi-devel wget

wget https://www.python.org/ftp/python/3.11.4/Python-3.11.4.tgz
tar -xvf Python-3.11.4.tgz

# 安装源码编译需要的编译环境
yum -y install gcc zlib zlib-devel libffi libffi-devel readline-devel
# 安装openssl11，后期的pip3安装网络相关模块需要用到ssl模块
yum install openssl-devel openssl11 openssl11-devel
# 设置编译FLAG，以便使用最新的openssl库
export CFLAGS=$(pkg-config --cflags openssl11)
export LDFLAGS=$(pkg-config --libs openssl11)
# 进入刚解压缩的目录
cd /home/hadoop/opt/Python-3.11.4
#指定python3的安装目录为 /usr/python 并使用ssl模块，指定目录好处是后期删除此文件夹就可以完全删除软件了。
./configure --prefix=/usr/local/python3.11.4/python3.11.4 --with-ssl # 源码编译并安装,时间会持续几分钟
make && make install

sudo ln -s /usr/local/python3.11.4/bin/python3.11 /usr/bin/python3.11

# 以下可选
# 可以删除，也可备份，按需操作即可
sudo rm -f /usr/bin/python
sudo rm -f /usr/bin/pip
sudo ln -s /home/hadoop/opt/python3.11.4/bin/pip3 /usr/bin/pip3
sudo ln -s /home/hadoop/opt/python3.11.4/bin/python3 /usr/bin/python
sudo ln -s /home/hadoop/opt/python3.11.4/bin/pip3 /usr/bin/pip

Rust工具链安装

Tue, 01 Oct 2024 13:46:53 +0800

Windows

安装MSYS2

https://www.msys2.org/

安装工具链

pacman -S mingw-w64-ucrt-x86_64-gcc

查看gcc版本

gcc --version

安装Rust

配置windows环境变量

将下面述地址配置到windows系统环境变量

C:\msys64\ucrt64\bin

执行安装Rust

MSYS2终端内执行

curl https://sh.rustup.rs -sSf | sh

一些选择

Current installation options:
default host triple: x86_64-pc-windows-msvc
default toolchain: stable (default)
profile: default
modify PATH variable: yes
1) Proceed with standard installation (default - just press enter)
2) Customize installation
3) Cancel installation
>2
I'm going to ask you the value of each of these installation options.
You may simply press the Enter key to leave unchanged.
Default host triple? [x86_64-pc-windows-msvc]
# 手动填写
x86_64-pc-windows-gnu
Default toolchain? (stable/beta/nightly/none) [stable]
Profile (which tools and data to install)? (minimal/default/complete) [default]
Modify PATH variable? (Y/n)
y
Current installation options:
default host triple: x86_64-pc-windows-gnu
default toolchain: stable
profile: default
modify PATH variable: yes
1) Proceed with selected options (default - just press enter)
2) Customize installation
3) Cancel installation
>1

检验安装结果

windows终端执行

openwrt通过frp代理后外网无法访问

Tue, 01 Oct 2024 13:40:29 +0800

外网（frp）访问openwrt，报错request entity too large

错误原因：通常是指请求的数量超过服务器的限制

解决方法：修改配置文件，登录到opnwrt的ssh页面输入

vi /etc/config/uhttpd

修改 option max_requests '50'改成500

option max_requests '50'的意思是设置最大请求数为500。

重启

切换浏览器

IDEA搭建Scala项目-helloworld

Fri, 27 Sep 2024 19:10:53 +0800

安装Scala插件

打开idea的settings
进入plugins，搜索Scala
安装

安装Scala sdk

官网

https://www.scala-lang.org/download/scala2.html

根据环境自由选择

IDEA自动下载

项目模块上右键，选择 add framework support，选择Scala，然后下载适当的SDK

Hello word

新建Scala源码目录，新建Scala class，类型选Object

编写代码

object Demo {

 def main(args: Array[String]): Unit = {
 println("hello world")
 }

}

hello world

JVM参数该如何配置

Fri, 27 Sep 2024 19:10:53 +0800

背景

面试官经常会问：JVM参数该如何设置？

虽然线上项目的JVM参数在我加入团队后就没有动过了，但我们还是得学习下不是，万一后面需要了呢？

JVM内存模型参数

从图中可以很清晰的看出JVM运行时内存的分布及每一个部分对应的参数

Xmx表示最大堆内存
Xms表示最小堆内存
MaxNewSize表示最大新生代大小
NewSize表示最小新生代大小
Xmn 可同时对MaxNewSize和NewSize两个参数进行配置（1.4后才有，不过现在企业一般都采用1.8以上的版本了）
Xss表示线程栈大小，可以控制JVM可以生成的最大线程数
MaxPermSize表示最大永生代大小
PermSize表示最小永生代大小

我们可以看到，没有直接设置老年代的参数，但是可以通过新生代参数和堆空间大小来控制

再来张简化版的图片。

可以看到JVM大体分为heap区和非heap区，其中heap区包括新生代、老年代；非heap区包括永生代、虚拟机栈和本地方法栈等

为什么要将一块堆内存分为新生代和老年代？

将内存区域划分为新生代和老年代，是为了使用不同垃圾回收算法，提高整个系统的垃圾回收效率。

JVM在运行过程中，产生对象的生命周期时不同的，有些对象的存活时间长，有些对象的存货时间短，如果每次垃圾回收，都把所有对象都扫描一遍，势必会造成不必要的性能开销。而将堆内存分为新生代和老年代，可针对不同的区域采用不同的垃圾回收算法，比如新生代中的对象存活时间短，可以采用复制算法完成垃圾收集，而老年代中对象存活时间长，对象数量比较多，适合采用标记清楚和标记整理算法。

而复制算法需要一块对象的暂存区域，所以将新生代分为Eden和2个Survivor区，每一次垃圾收集使用Eden和一个Survivor区。

Eden和Survivor区的大小可以通过XXSurvivorRatio参数来进行设置，其表示Eden大小和survivor区大小的比例

比如有参数-Xmx1024m -Xms1024m -Xmn128m -XXSurvivorRatio=2

我可以分析得到，新生代为128M，Eden和Survivor比例为2，那么可以计算得出Eden大小为64M，两个Survivor区均是32M

JVM参数设置

堆大小配置

堆大小一般与操作系统、物理内存、虚拟内存的大小有关

Xmx 一般不得大于物理内存
Xms 初始内存，如果想要增大程序的启动性能，可以增大此参数，一般可以设置为和Xmx持平，防止垃圾收集后重新分配内存
Xmn 年轻代大小，这个参数控制年轻代和老年代的大小，对性能的影响比较大，sun推荐新生代和老年代的比例为3:5
Xss 线程堆栈大小，一般默认1M，这个参数设置的越小，JVM就能生成更多的线程（不能超过操作系统的限制）
NewRatio 老年代和新生代的比值
SurvivorRatio Eden大小和survivor区大小的比例
MaxTenuringThreshold 设置对象的年龄，可以控制对象在新生代中的存活次数

垃圾回收器的选择及其参数配置

UseSerialGC 使用串行收集器
UseParallelGC 使用并行收集器
UseParalledlOldGC 使用并行年老代收集器
UseConcMarkSweepGC 使用并发收集器

其他配置

此外，JVM提供了不少辅助信息获取到的配置

PrintGC
PrintGCDetails
PrintGCApplicationStoppedTime 垃圾收集期间程序暂停运行的时间
PrintGCApplicationConcurrentTime 垃圾收集期间，应用程序未中断执行的时间
PrintHeapAtGC 打印出垃圾收集前后的堆栈信息
PrintGCTimeStamps 垃圾收集发生时的时间戳
Xloggc:filename 将日志信息记录到文件中，便于后续分析

上述参数可以组合使用，输出易于分析的信息

LRU算法

Fri, 27 Sep 2024 19:10:53 +0800

LRU算法

简述

LRU是Least Recently Used的缩写，即最近最少使用，是一种常用的页面置换算法，选择最近最久未使用的页面予以淘汰。该算法赋予每个页面一个访问字段，用来记录一个页面自上次被访问以来所经历的时间t，当须淘汰一个页面时，选择现有页面中其t 值最大的，即最近最少使用的页面予以淘汰。

需求

实现一个缓存功能，使得插入、删除、修改的操作都是O(1)的，并且当需要清除缓存时，需要从最少使用的开始清除。

实现

思考：

一般的，要实现O(1)的时间复杂度，考虑使用hash来实现
需要从最少的元素开始删起，一种朴素的想法就是将每个元素使用时间记录下来，按时间顺序排好序，然后需要删除时，从最久未使用的元素开始删除
进而可以想到，使用链表将哈希表串联起来，头部表示使用最近使用的，尾部表示最久未使用的

如图所示：

最左边为Head，表示最近使用的；最右边未Tail，表示最久未使用的

当对节点进行操作：

删除：将节点从链表中移除

增加：将节点移动到head处

修改：将节点移动到head处

查询：将节点移动到head处

MySQL的MVVC是个什么东东

Fri, 27 Sep 2024 19:10:53 +0800

MVVC是什么

MVVC，全称Multi-Version Concurrency Control

多版本的并发控制，Multi-Version Concurrency Control，是一个可以提升数据库并发读写性能的技术。

一般的，如果对数据的库表的一行记录进行读写操作，为了保证数据的一致性，往往需要对这一行记录进行加锁操作。而加锁带来的问题就是开销变大，性能降低。而MVVC便是对这一问题提出的一种改进策略。

快照读和当前读

首先，我们先了解一下两个概念——快照读和当前读。

当前读

当前读可以理解为，所有的当前读操作都是针对的数据库最新版本的数据，在操作的时候会对资源加悲观锁，防止其他事务对数据进行修改。

如delete、update、insert、select for update、select lock in share mode等操作均是当前读

需要注意的时，在串行化的事务隔离级别下，所有的操作均是当前读

快照读

快照读的实现是基于MVVC的，读取的可能是某个版本的快照数据。

MVCC

数据库中有哪些并发场景？

读-读读操作不会造成数据一致性问题，也没有并发控制的需要
读-写可能造成数据不一致，需要对线程安全进行控制，否则会造成脏读、幻读、不可重复读的错误
写-写多线程存在问题，可能会造成数据丢失

MVCC能解决什么场景下的问题？

解决读-写场景下的并发问题，可以实现读写均不会阻塞，解决脏读、幻读、不可重复读的问题
不可解决写-写场景下的并发控制问题，一般可结合乐观锁或者悲观锁来实现

MVCC如何实现并发控制的？

其实现主要依靠undo日志，版本链，Read View三个技术手段。

undo日志

undo可以理解为每次针对记录行修改时，原数据的备份。每一次针对原纪录的修改都会生成一个undo日志，将原数据拷贝到日志中记录起来

用于事务回滚
是的每个事务均有自己特有的日志记录集合

undo日志一般分为插入日志和更新日志。插入日志是执行insert操作生成的日志，在事务回滚时需要使用，在事务提交后可以丢弃掉；更新日志不仅在事务回滚的时候需要，在快照读的时候也需要，不能随便删除

版本链

数据表记录的每一行均有3个隐藏列

db_trx_id 事务id
db_roll_pointer 回滚指针，指向上一个版本
db_row_id 隐藏的自增主键

这是一个简单的示例图。

很容易理解，每次修改都会undo日志，通过版本指针将这些日志串联起来，形成版本链。

Read View

读视图可以理解为快照读是生成的整个数据库系统的一个快照。其可以用来做可见性判断。因为每一个事务均有唯一的id，可以用此id来控制此事务可以看到的数据，可以是最新版本的，也可以是历史版本的。

其有如下几个参数：

trx_ids 目前系统中未提交的事务id集合
low_limit_id 最大事务版本号加1
up_limit_id 处于活跃状态中的最好事务版本号
creator_trx_id 创建read view的事务版本号

可见性判断代码

MVCC和事务隔离级别的关系

MVCC如何实现RR和RC的隔离级别

在RC的隔离级别下，只要提交了都可以被其他事务读取到，每一个快照读均会生成一个最新的read view

picgo插件代码示例

Fri, 27 Sep 2024 19:10:53 +0800

import picgo from 'picgo'
// @ts-ignore
import { PluginConfig } from 'picgo/dist/utils/interfaces'


const config = (ctx: picgo): PluginConfig[] => {
 let userConfig = ctx.getConfig('picBed.imgYun')
 if (!userConfig) {
 userConfig = {}
 }
 return [
 {
 name: 'serverHost',
 type: 'input',
 default: userConfig.serverHost || '',
 message: 'serverHost 不能为空',
 required: true
 },
 {
 name: 'apiToken',
 type: 'password',
 default: userConfig.apiToken || '',
 message: 'apiToken 不能为空',
 required: true
 }
 ]
}

const postOptions = (fileName:string, options: any, image: Buffer): any => {
 return {
 method: 'POST',
 url: options.serverHost+'/api/img/upload',
 headers: {
 contentType: 'multipart/form-data',
 'User-Agent': 'PicGo',
 'token': options.apiToken
 },
 formData: {
 file: {
 value: image,
 options: {
 filename: fileName
 }
 }
 }
 }
}

const handle = async (ctx: picgo): Promise<picgo> => {
 const imgYunOptions = ctx.getConfig('picBed.imgYun')
 if (!imgYunOptions) {
 throw new Error('imgYun 图床配置文件')
 }
 try {
 const imgList = ctx.output
 for (const img of imgList) {
 let image = img.buffer
 if (!image && img.base64Image) {
 image = Buffer.from(img.base64Image, 'base64')
 }
 const options = postOptions(img.fileName,imgYunOptions,image);
 let body = await ctx.Request.request(options)
 body = JSON.parse(body)
 if (body.success) {
 delete img.base64Image
 delete img.buffer
 img.imgUrl = body.obj
 } else {
 ctx.log.error(body)
 throw new Error('Server error, please try again')
 }

 }
 return ctx
 } catch (err) {
 throw err
 }
}

export = (ctx: picgo) => {
 const register = () => {
 ctx.helper.uploader.register('imgYun', {
 handle,
 name: 'imgYun',
 config: config
 })
 }
 return {
 uploader: 'imgYun',
 register
 }

}

Scala基础--关键字，数据类型，函数

Fri, 27 Sep 2024 19:10:53 +0800

基础语法

注意点

Scala 区分大小写
类名类似于Java
方法名命名类似于Java

老规矩，先上Hello World

object Demo {

 def main(args: Array[String]): Unit = {
 println("hello world")
 }

}

关键字

abstract	case	catch	class
def	do	else	extends
false	final	finally	for
forSome	if	implicit	import
lazy	match	new	null
object	override	package	private
protected	return	sealed	super
this	throw	trait	try
true	type	val	var
while	with	yield
-	:	=	=>
<-	<:	<%	>:
#	@

注释

注释也和Java类似

shell学习笔记

Fri, 27 Sep 2024 19:10:53 +0800

变量

使用和创建变量

your_name="qinjx"
echo $your_name
echo ${your_name}

删除变量

#!/bin/sh
myStr="deleted string"
unset myStr
echo $myStr

字符串

单引号和双引号的区别
- 单引号内的字符串会原样输出
- 双引号中的变量会进行替换

计算字符串长度

string="abcd"
echo ${#string} #输出 4

截断字符串

string="runoob is a great site"
echo ${string:1:4} # 输出 unoo

数组

数组名=(值1 值2 ... 值n)

#!/bin/bash
array=(1 2 3 4)
echo ${array[1]}

获取数组长度

echo ${array_name[@]}
# 或者
length=${#array_name[*]}

获取数组单个元素的长度

# 取得数组单个元素的长度
lengthn=${#array_name[n]}

注释

单行

# 注释内容

多行

:<<EOF
注释内容...
注释内容...
注释内容...
EOF

:<<'
注释内容...
注释内容...
注释内容...
'

:<<!
注释内容...
注释内容...
注释内容...
!

参数接收

#!/bin/bash
echo "Shell 传递参数实例！";
echo "执行的文件名：$0";
echo "第一个参数为：$1";
echo "第二个参数为：$2";
echo "第三个参数为：$3";

./demo.sh 1 2 3

参数处理	说明
$#	传递到脚本的参数个数
$*	以一个单字符串显示所有向脚本传递的参数。如"$*“用「"」括起来的情况、以”$1 $2 … $n"的形式输出所有参数。
$$	脚本运行的当前进程ID号
$!	后台运行的最后一个进程的ID号
$@	与$*相同，但是使用时加引号，并在引号中返回每个参数。如"$@“用「"」括起来的情况、以”$1" “$2” … “$n” 的形式输出所有参数。
$-	显示Shell使用的当前选项，与set命令功能相同。
$?	显示最后命令的退出状态。0表示没有错误，其他任何值表明有错误。

运算符

算数运算符

运算符	说明	举例
+	加法	`expr $a + $b` 结果为 30。
-	减法	`expr $a - $b` 结果为 -10。
*	乘法	`expr $a \* $b` 结果为 200。
/	除法	`expr $b / $a` 结果为 2。
%	取余	`expr $b % $a` 结果为 0。
=	赋值	a=$b 将把变量 b 的值赋给 a。
==	相等。用于比较两个数字，相同则返回 true。	[ $a == $b ] 返回 false。
!=	不相等。用于比较两个数字，不相同则返回 true。	[ $a != $b ] 返回 true。

关系运算符

运算符	说明	举例
-eq	检测两个数是否相等，相等返回 true。	[ $a -eq $b ] 返回 false。
-ne	检测两个数是否不相等，不相等返回 true。	[ $a -ne $b ] 返回 true。
-gt	检测左边的数是否大于右边的，如果是，则返回 true。	[ $a -gt $b ] 返回 false。
-lt	检测左边的数是否小于右边的，如果是，则返回 true。	[ $a -lt $b ] 返回 true。
-ge	检测左边的数是否大于等于右边的，如果是，则返回 true。	[ $a -ge $b ] 返回 false。
-le	检测左边的数是否小于等于右边的，如果是，则返回 true。	[ $a -le $b ] 返回 true。

…

Spark在Standalone运行架构中的运行流程

Fri, 27 Sep 2024 19:10:53 +0800

Standalone

Standalone模式是Spark实现的资源调度框架，其主要的节点有Client节点、Master节点和Worker节点。其中Driver既可以运行在Master节点上中，也可以运行在本地Client端。当用spark-shell交互式工具提交Spark的Job时，Driver在Master节点上运行；当使用spark-submit工具提交Job或者在Eclips、IDEA等开发平台上使用”new SparkConf().setMaster(“spark://master:7077”)”方式运行Spark任务时， Driver是运行在本地Client端上的。

具体流程

我们提交一个任务，任务就叫Application
初始化程序的入口SparkContext
初始化DAG Scheduler
初始化Task Scheduler
Task Scheduler向master去进行注册并申请资源（CPU Core和Memory）
Master根据SparkContext的资源申请要求和Worker心跳周期内报告的信息决定在哪个Worker上分配资源，然后在该Worker上获取资源，然后启动StandaloneExecutorBackend；顺便初始化好了一个线程池
StandaloneExecutorBackend向Driver(SparkContext)注册,这样Driver就知道哪些Executor为他进行服务了。到这个时候其实我们的初始化过程基本完成了，我们开始执行transform、ation的代码，但是代码并不会真正的运行，直到我们遇到一个action操作。先生产一个job任务，进行stage的划分。
SparkContext将Applicaiton代码发送给StandaloneExecutorBackend；并且SparkContext解析Applicaiton代码，构建DAG图，并提交给DAG Scheduler分解成Stage（当碰到Action操作时，就会催生Job；每个Job中含有1个或多个Stage，Stage一般在获取外部数据和shuffle之前产生）。
将Stage（或者称为TaskSet）提交给Task Scheduler。Task Scheduler负责将Task分配到相应的Worker，最后提交给StandaloneExecutorBackend执行；
对task进行序列化，并根据task的分配算法，分配task
对接收过来的task进行反序列化，把task封装成一个线程
开始执行Task，并向SparkContext报告，直至Task完成。
资源注销

Spark学习之Spark简述

Fri, 27 Sep 2024 19:10:53 +0800

Spark生态

Spark Core：包含Spark的基本功能；尤其是定义RDD的API、操作以及这两者上的动作。其他Spark的库都是构建在RDD和Spark Core之上的

Spark SQL：提供通过Apache Hive的SQL变体Hive查询语言（HiveQL）与Spark进行交互的API。每个数据库表被当做一个RDD，Spark SQL查询被转换为Spark操作。

Spark Streaming：对实时数据流进行处理和控制。Spark Streaming允许程序能够像普通RDD一样处理实时数据

MLlib：一个常用机器学习算法库，算法被实现为对RDD的Spark操作。这个库包含可扩展的学习算法，比如分类、回归等需要对大量数据集进行迭代的操作。

GraphX：控制图、并行图操作和计算的一组算法和工具的集合。GraphX扩展了RDD API，包含控制图、创建子图、访问路径上所有顶点的操作。

Spark的运行流程

构建Spark Application的运行环境，启动SparkContext

SparkContext向资源管理器（可以是Standalone，Mesos，Yarn）申请运行Executor资源，并启动StandaloneExecutorbackend，

Executor向SparkContext申请Task

SparkContext将应用程序分发给Executor

SparkContext构建成DAG图，将DAG图分解成Stage、将Taskset发送给Task Scheduler，最后由Task Scheduler将Task发送给Executor运行

Task在Executor上运行，运行完释放所有资源

Spark与Hadoop

MapReduce采用硬盘保存临时数据，而Spark采用内存保存临时数据

Spark的运行原理

Fri, 27 Sep 2024 19:10:53 +0800

Spark基本概念

RDD：是弹性分布式数据集（Resilient Distributed Dataset）的简称，是分布式内存的一个抽象概念，提供了一种高度受限的共享内存模型。

DAGScheduler：有向无环图调度器基于DAG划分Stage并以TaskSet的形式提交Stage给TaskScheduler；负责将作业拆分成不同阶段的具有宽窄依赖关系的多批任务；最重要的任务之一就是：计算作业和任务的依赖关系，指定调度逻辑。在SparkContext初始化的过程中被实例化，一个SparkContext对应一个DAGScheduler。

DAG：是Directed Acyclic Graph（有向无环图）的简称，反映RDD之间的依赖关系。窄依赖：父RDD每一个分区最多被一个子RDD的分区所用；表现为一个父RDD的分区对应于一个子RDD的分区，或两个父RDD的分区对应于一个子RDD的分区。

宽依赖：父RDD的每个分区都可能被多个子RDD分区所使用，子RDD分区通常对应所有的父RDD分区

常见的宽窄依赖有：map、filter、union、mapPartitions、mapValues、join（父RDD是hash-partitioned：如果joinAPI之前被调用的RDD API是宽依赖【存在shuffle】，而且两个join的RDD的分区数量一致，join结果的RDD分区数量也一样，这个时候join API是窄依赖）。

常见的宽依赖有：groupByKey、partitionBy、reduceByKey、join（父RDD不是hash-partitioned：除此之外的，RDD的join API都是宽依赖）。

Driver Program：控制程序，负责为Application构建DAG图。

Cluster Manager：集群资源管理中心，负责分配计算资源。

Worker Node：工作节点，负责完成具体计算。

Executor：是运行在工作节点（Worker Node）上的一个进程，负责运行Task，并为应用程序存储数据。

Application：用户编写的Spark应用程序，一个Application包含多个Job。

Job：作业，一个Job包含多个RDD及作用于相应RDD上的各种操作。

Stage：阶段，是作业的基本调度单位，一个作业会分为多组任务，每组任务被称为“阶段”。

TaskScheduler：任务调度器将TaskSet提交给Worker（集群）运行并汇报结果；负责每个具体任务的实际物理调度。

Task：任务，运行在Executor上的工作单元，是Executor中的一个线程。

TaskSet：任务集由一组关联的，但相互之间没有Shuffle依赖关系的任务所组成的任务集。

1）一个Stage创建一个TaskSet；
2）为Stage的每个RDD分区创建一个Task，多个Task分装成TaskSet。

总结：Application由多个Job组成，Job由多个Stage组成，Stage由多个Task组成。Stage是作业调度的基本单位。

整体结构

Spark作业执行过程

我们使用spark-submit提交一个Spark作业之后，这个作业就会启动一个对应的Driver进程。根据你使用的部署模式（deploy-mode）不同，Driver进程可能在本地启动，也可能在集群中某个工作节点上启动。而Driver进程要做的第一件事情，就是向集群管理器（可以是Spark Standalone集群，也可以是其他的资源管理集群，美团•大众点评使用的是YARN作为资源管理集群）申请运行Spark作业需要使用的资源，这里的资源指的就是Executor进程。YARN集群管理器会根据我们为Spark作业设置的资源参数，在各个工作节点上，启动一定数量的Executor进程，每个Executor进程都占有一定数量的内存和CPU core。
在申请到了作业执行所需的资源之后，Driver进程就会开始调度和执行我们编写的作业代码了。Driver进程会将我们编写的Spark作业代码分拆为多个stage，每个stage执行一部分代码片段，并为每个stage创建一批Task，然后将这些Task分配到各个Executor进程中执行。Task是最小的计算单元，负责执行一模一样的计算逻辑（也就是我们自己编写的某个代码片段），只是每个Task处理的数据不同而已。一个stage的所有Task都执行完毕之后，会在各个节点本地的磁盘文件中写入计算中间结果，然后Driver就会调度运行下一个stage。下一个stage的Task的输入数据就是上一个stage输出的中间结果。如此循环往复，直到将我们自己编写的代码逻辑全部执行完，并且计算完所有的数据，得到我们想要的结果为止。
Spark是根据shuffle类算子来进行stage的划分。如果我们的代码中执行了某个shuffle类算子（比如reduceByKey、join等），那么就会在该算子处，划分出一个stage界限来。可以大致理解为，shuffle算子执行之前的代码会被划分为一个stage，shuffle算子执行以及之后的代码会被划分为下一个stage。因此一个stage刚开始执行的时候，它的每个Task可能都会从上一个stage的Task所在的节点，去通过网络传输拉取需要自己处理的所有key，然后对拉取到的所有相同的key使用我们自己编写的算子函数执行聚合操作（比如reduceByKey()算子接收的函数）。这个过程就是shuffle。
当我们在代码中执行了cache/persist等持久化操作时，根据我们选择的持久化级别的不同，每个Task计算出来的数据也会保存到Executor进程的内存或者所在节点的磁盘文件中。
因此Executor的内存主要分为三块：第一块是让Task执行我们自己编写的代码时使用，默认是占Executor总内存的20%；第二块是让Task通过shuffle过程拉取了上一个stage的Task的输出后，进行聚合等操作时使用，默认也是占Executor总内存的20%；第三块是让RDD持久化时使用，默认占Executor总内存的60%。
Task的执行速度是跟每个Executor进程的CPU core数量有直接关系的。一个CPU core同一时间只能执行一个线程。而每个Executor进程上分配到的多个Task，都是以每个Task一条线程的方式，多线程并发运行的。如果CPU core数量比较充足，而且分配到的Task数量比较合理，那么通常来说，可以比较快速和高效地执行完这些Task线程。

Spark的运行模式

Fri, 27 Sep 2024 19:10:53 +0800

Standalone模式

架构

Standalone运行过程

SparkContext连接到Master，向Master注册并申请资源（CPU Core and Memory）。
Master根据SparkContext的资源申请要求和Worker心跳周期内报告的信息决定哪个Worker上分配资源，然后在该Worker上获取资源，然后启动Executor，Executor向SparkContext注册。
SparkContext将Application代码发送到Executor。同时，SparkContext解析Application代码，构建DAG图，并提交给DAGScheduler分解成Stage，然后以Stage（或者称为TaskSet）提交给TaskScheduler，TaskScheduler负责将Task分配到相应的Worker，最后提交给Executor执行。
Executor会建立Executor线程池，开始执行Task，并向SparkContext报告，直至Task完成。
所有Task完成后，SparkContext向Master注销，释放资源。

Spark on Yarn模式

Yarn-Cluster模式

Client向Yarn中提交应用程序，包括ApplicationMaster程序、启动ApplicationMaster的命令、需要在Executor中运行的程序等。
ResourceManager收到请求后，在集群中选择一个NodeManager，为该应用程序分配第一个Container，要求它在这个Container中启动应用程序的ApplicationMaster，其中ApplicationMaster进行SparkContext等的初始化。
ApplicationMaster向ResourceManager注册，这样用户可以直接通过ResourceManage查看应用程序的运行状态，然后它将采用轮询的方式通过RPC协议为各个任务申请资源，并监控它们的运行状态直到运行结束。
一旦ApplicationMaster申请到资源后，便与对应的NodeManager通信，要求它在获得的Container中启动Executor，启动后会向ApplicationMaster中的SparkContext注册并申请Task。
ApplicationMaster中的SparkContext分配Task给Executor执行，Executor运行Task并向ApplicationMaster汇报运行的状态和进度，以让ApplicationMaster随时掌握各个任务的运行状态，从而可以在任务失败时重新启动任务。
应用程序运行完成后，ApplicationMaster向ResourceManager申请注销并关闭自己。

Spark on Yarn-Client 模式

Client向Yarn的ResourceManager申请启动ApplicationMaster。同时，在SparkContext初始化中将创建DAGScheduler和TaskScheduler。
ResourceManager收到请求后，在集群中选择一个NodeManager，为该能够用程序分配第一个Container，要求它在这个Container中启动应用程序的ApplicationMaster。
Client中的SparkContext初始化完毕后，与ApplicationMaster建立通讯，向ResourceManager注册，根据任务信息向ResourceManager申请资源。
一旦ApplicationMaster申请到资源后，便与对应的NodeManager通信，要求它在获得的Container中启动Executor，启动后会向Client中的SparkContext注册并申请Task。
Client中的SparkContext分配Task给Executor执行，Executor运行Task并向Driver汇报运行的状态和进度，以让Client随时掌握各个任务的运行状态，从而可以在任务失败时重新启动任务。
应用程序运行完成后，Client的SparkContext向ResourceManager申请注销并关闭自己。

Yarn-Cluster与Yarn-Client的区别

它们的区别就是ApplicationMaster的区别：Yarn-Cluster中ApplicationMaster不仅负责申请资源，并负责监控Task的运行状况，因此可以关掉Client；而Yarn-Client中ApplicationMaster仅负责申请资源，由Client中的Driver来监控调度Task的运行，因此不能关掉Client。

Spark on Yarn与MapReduce on Yarn的区别

Spark的高性能一定程度上取决于它采用的异步并发模型（这里指server/driver端采用的模型），这与Hadoop 2.0（包括Yarn和MapReduce）是一致的。Hadoop 2.0自己实现了类似Actor的异步并发模型，实现方式是epoll+状态机，而Spark则直接采用了开源软件Akka，该软件实现了Actor模型，性能非常高。尽管二者在server端采用了一致的并发模型，但在任务级别（特指Spark任务和MapReduce任务）上却采用了不同的并发机制：Hadoop MapReduce采用了多进程模型，而Spark采用了多线程模型。

注意，这里的多进程和多线程，指的是同一个节点上多个任务的运行模式。无论是MapReduce和Spark，整体上看，都是多进程：MapReduce应用程序是由多个独立的Task进程组成的；Spark应用成的运行环境是由多个独立的Executor进程构建的临时资源池构成的。

多进程模型便于细粒度控制每个任务占用的资源，但会消耗较多的启动时间，不适合运行低延迟类型的作业，这是MapReduce广为诟病的原因之一。而多线程模型则相反，该模型使得Spark很适合运行低延迟类型的作业。总之，Spark同节点上的任务以多线程的方式运行在一个JVM进程中，可带来以下好处：

任务启动速度快，与之相反的是MapReduce Task进程的慢启动速度，通常需要1s左右；
同节点上所有任务运行在一个进程中，有利于共享内存。这非常适合内存密集型任务，尤其对于那些需要加载大量词典的应用程序，可大大节省内存；
同节点上所有任务可运行在一个JVM进程（Executor）中，且Executor所占资源可连续被多批任务使用，不会在运行部分任务后释放掉，这避免了每个任务重复申请资源带来的时间开销，对于任务数目非常多的应用，可大大降低运行时间。与之对比的是MapReduce中的Task：每个Task单独申请资源，用完后马上释放，不能被其他任务重用，尽管1.0支持JVM重用在一定程度上弥补了该问题，但2.0尚未支持该功能。

尽管Spark的多线程模型带来了很多好处，但同样存在不足，主要有：

由于节点上所有任务运行在一个进程中，因此，会出现严重的资源争用，难以细粒度控制每个任务占用资源。与之相反的是MapReduce，它允许用户单独为Map Task和Reduce Task设置不同的资源，进而细粒度控制任务占用资源量，有利于大作业的正常平稳运行。

MapReduce和Spark运行模型

MapReduce多进程模型

每个Task运行在一个独立的JVM进程中；
可单独为不同类型的Task设置不同的资源量，目前支持内存和CPU两种资源；
每个Task运行完后，释放所占用的资源，这些资源不能被其他Task复用，即使是同一个作业相同类型的Task。也就是说，每个Task都要经历“申请资源->运行Task->释放资源”的过程。

Spark多线程模型

每个节点上可以运行一个或多个Executor服务（一个节点上可以有多个Container）；
每个Executor配有一定数量的slot，表示该Executor中可以同时运行多少个ShuffleMap Task或者Reduce Task；
每个Executor单独运行在一个JVM进程中，每个Task则是运行在Executor中的一个线程（每个线程可以通过轮询的方式运行每个Task）；
同一个Executor内部的Task可共享内存，比如通过函数SparkContext.broadcast广播的文件或者数据结构只会在每个Executor中加载一次，而不会像MapReduce那样，每个Task加载一次；
Executor一旦启动后，将一直运行，且它的资源可以一直被Task复用，直到Spark程序运行完成后才释放退出。

总结

总体上看，Spark采用的是经典的scheduler/workers模式，每个Spark应用程序运行的第一步是构建一个可重用的资源池，然后在这个资源池里运行所有的ShuffleMap Task和Reduce Task（注意，尽管Spark引擎内部只用两类Task便可表示出一个复杂的应用程序，即ShuffleMap Task和Reduce Task），而MapReduce应用程序则不同，它不会构建一个可重用的资源池，而是让每个Task动态申请资源，且运行完后马上释放资源。

SpringBoot配置文件——加载顺序

Fri, 27 Sep 2024 19:10:53 +0800

SpringBoot配置文件——加载顺序

配置文件所在目录

file:./config/ 根目录中的config目录中
file:./ 根目录中
classpath:/config/ resource目录中的config目录下
classpath:/ resource目录下（类路径下 classpath）

读取顺序（优先级顺序）

如果在不同的目录中存在多个配置文件，它的读取顺序是： 1、config/application.properties（项目根目录中config目录下） 2、config/application.yml 3、application.properties（项目根目录下） 4、application.yml 5、resources/config/application.properties（项目resources目录中config目录下） 6、resources/config/application.yml 7、resources/application.properties（项目的resources目录下） 8、resources/application.yml

结论：

配置的优先级如上所示，如果同一个配置配置在多个配置文件中，则优先使用先读取到的，也就是说，1-8的优先级是由高到低的

PS：

创建SpringBoot项目时，一般的配置文件放置在项目的resources目录下，因为配置文件的修改，通过热部署不用重新启动项目，而热部署的作用范围是classpath下

参考：

springboot官方文档：https://docs.spring.io/spring-boot/docs/2.3.3.RELEASE/reference/html/spring-boot-features.html#boot-features-external-config

Spring的启动流程--注解方式启动

Fri, 27 Sep 2024 19:10:53 +0800

Bean生命周期

Spring的启动流程–注解方式启动

1. 创建AnnotationConfigApplicationContext

1.1 创建beanFactory

this.beanFactory = new DefaultListableBeanFactory();

1.2 创建Reader

this.reader = new AnnotatedBeanDefinitionReader(this);

关注

/*
* 将一些RootBeanDefinition注册进DefaultListableBeanFactory
*/
AnnotationConfigUtils.registerAnnotationConfigProcessors(this.registry);

public static Set<BeanDefinitionHolder> registerAnnotationConfigProcessors(
 BeanDefinitionRegistry registry, @Nullable Object source) {

 DefaultListableBeanFactory beanFactory = unwrapDefaultListableBeanFactory(registry);
 if (beanFactory != null) {
 if (!(beanFactory.getDependencyComparator() instanceof AnnotationAwareOrderComparator)) {
 beanFactory.setDependencyComparator(AnnotationAwareOrderComparator.INSTANCE);
 }
 if (!(beanFactory.getAutowireCandidateResolver() instanceof ContextAnnotationAutowireCandidateResolver)) {
 beanFactory.setAutowireCandidateResolver(new ContextAnnotationAutowireCandidateResolver());
 }
 }

 Set<BeanDefinitionHolder> beanDefs = new LinkedHashSet<>(8);

 if (!registry.containsBeanDefinition(CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME)) {
 RootBeanDefinition def = new RootBeanDefinition(ConfigurationClassPostProcessor.class);
 def.setSource(source);
 beanDefs.add(registerPostProcessor(registry, def, CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME));
 }

 if (!registry.containsBeanDefinition(AUTOWIRED_ANNOTATION_PROCESSOR_BEAN_NAME)) {
 RootBeanDefinition def = new RootBeanDefinition(AutowiredAnnotationBeanPostProcessor.class);
 def.setSource(source);
 beanDefs.add(registerPostProcessor(registry, def, AUTOWIRED_ANNOTATION_PROCESSOR_BEAN_NAME));
 }

 // Check for JSR-250 support, and if present add the CommonAnnotationBeanPostProcessor.
 if (jsr250Present && !registry.containsBeanDefinition(COMMON_ANNOTATION_PROCESSOR_BEAN_NAME)) {
 RootBeanDefinition def = new RootBeanDefinition(CommonAnnotationBeanPostProcessor.class);
 def.setSource(source);
 beanDefs.add(registerPostProcessor(registry, def, COMMON_ANNOTATION_PROCESSOR_BEAN_NAME));
 }

 // Check for JPA support, and if present add the PersistenceAnnotationBeanPostProcessor.
 if (jpaPresent && !registry.containsBeanDefinition(PERSISTENCE_ANNOTATION_PROCESSOR_BEAN_NAME)) {
 RootBeanDefinition def = new RootBeanDefinition();
 try {
 def.setBeanClass(ClassUtils.forName(PERSISTENCE_ANNOTATION_PROCESSOR_CLASS_NAME,
 AnnotationConfigUtils.class.getClassLoader()));
 }
 catch (ClassNotFoundException ex) {
 throw new IllegalStateException(
 "Cannot load optional framework class: " + PERSISTENCE_ANNOTATION_PROCESSOR_CLASS_NAME, ex);
 }
 def.setSource(source);
 beanDefs.add(registerPostProcessor(registry, def, PERSISTENCE_ANNOTATION_PROCESSOR_BEAN_NAME));
 }

 if (!registry.containsBeanDefinition(EVENT_LISTENER_PROCESSOR_BEAN_NAME)) {
 RootBeanDefinition def = new RootBeanDefinition(EventListenerMethodProcessor.class);
 def.setSource(source);
 beanDefs.add(registerPostProcessor(registry, def, EVENT_LISTENER_PROCESSOR_BEAN_NAME));
 }

 if (!registry.containsBeanDefinition(EVENT_LISTENER_FACTORY_BEAN_NAME)) {
 RootBeanDefinition def = new RootBeanDefinition(DefaultEventListenerFactory.class);
 def.setSource(source);
 beanDefs.add(registerPostProcessor(registry, def, EVENT_LISTENER_FACTORY_BEAN_NAME));
 }

 return beanDefs;
 }

1.3 创建Scancer

this.scanner = new ClassPathBeanDefinitionScanner(this);

关注

分布式锁的几种常见实现方式

Fri, 27 Sep 2024 19:10:53 +0800

数据库乐观锁

实现方式

用表中一行记录来表示锁，其中表示锁的字段采用唯一约束

当多个线程同时执行插入语句时，只有一个能插入成功，可以认为获得到了锁，其他则会报错：ERROR 1062 (23000): Duplicate entry ‘1’ for key ‘uiq_idx_resource’），这种情况可以认为没有获得到锁

当需要释放锁时，可以删除这一条记录就可以了

这种锁的特点：

锁没有失效时间，一旦锁释放失败，便会一直留在数据库中，影响其他线程获取锁。可以采用定时任务对其进行清理
锁依赖数据库，需要考虑单点故障问题。同时也要考虑给数据库性能带来的影响
锁是非阻塞的，一旦插入失败，直接便会报错，需要采用轮询的方式来实现
锁也是非可重入的，一旦一个线程获取到了锁，由于数据库中已经存在了这一条记录，其本身也不能再次获取到这个锁。这一点可以将主机和线程信息存入数据库，如果存在锁，并且锁也归属于当前线程，则可以将此锁再次分配给它

Redis实现

基本上基于setnx命令实现

SETNX 是SET if Not eXists的简写

解释：

当且仅当 key 不存在，将 key 的值设为 value，返回1；若给定的 key 已经存在，则 SETNX 不做任何动作，返回0。

@Component
public class RedisService {

 @Autowired
 private RedisTemplate<String,String> redisTemplate;

 private static final String COMPARE_AND_DELETE = "if redis.call('get', KEYS[1]) == ARGV[1] then return redis.call('del', KEYS[1]) else return 0 end";


 public Boolean getLock(String key,String value){
 return redisTemplate.opsForValue().setIfAbsent(key, value, 2, TimeUnit.MINUTES);
 }

 public void releaseLock(String key,String value){
 List<String> keys = Collections.singletonList(key);
 redisTemplate.execute(new DefaultRedisScript<>(COMPARE_AND_DELETE,Long.class), keys, value);
 }


}

这里并没有直接使用delete命令，是为了防止删除其他线程的key。、

利用Redisson快速实现分布式锁--Redisson的介绍与使用

Fri, 27 Sep 2024 19:10:53 +0800

什么是Redisson

Redisson 是一个使用 Java编写的Redis 客户端。其以Redis为基础，构建了一种内存数据网格（ in-memory data grid），并提供了redis支持的分布式Java对象和服务。包括超过50中Java对象和若干服务（Set, Multimap, SortedSet, Map, List, Queue, Deque, Semaphore, Lock, AtomicLong, Map Reduce, Publish / Subscribe, Bloom filter, Spring Cache, Tomcat, Scheduler, JCache API, Hibernate, MyBatis, RPC, local cache…）。

简单来讲，Redisson可以帮助我们集中精力处理业务，而不必将过多的精力投入到redis的用法上。在项目中我们常常用它来实现redis分布式锁，替代原生redis+lua脚本的方式。

Maven依赖

项目地址https://github.com/redisson/redisson

<dependency>
<groupId>org.redisson</groupId>
<artifactId>redisson</artifactId>
<version>3.15.5</version>
</dependency>

配置

Redis配置

在使用之前，首先得确保redis的安装与使用。在这里不做赘述。

Redisson支持如下的redis配置方式：

单机模式
主从模式
哨兵模式
集群模式
复制节点（Amazon Web Services (AWS) ElastiCache Cluster and Azure Redis Cache）

Java代码

Config config = new Config();
config.useSingleServer()
 .setAddress("redis://127.0.0.1:6379");

RedissonClient client = Redisson.create(config);

本文示例采用redis单机模式的配置，首先利用SingleServerConfig构建出单机模式下redis的配置对象，并使用setAddress 方法配置IP和端口信息，除此之外，还可以通过对应的setter方法设置retryAttempts、connectionTimeout 和 clientName等参数。然后，通过SingleServerConfig构建出Config对象，并将其传递给Redisson类的create静态方法，获得RedissonClient对象，后续我们便可以使用其进行各种业务操作。

当100个任务同时请求提交任务，线程池时如何工作的

Fri, 27 Sep 2024 19:10:53 +0800

问题

如果100个任务同时往线程池（最小线程5，最大线程10，队列时LinkedBlockingDeque）提交，线程池会发生什么？线程池如何处理这些任务?

线程池

我们首先来看看线程池的工作流程。

当线程池被创建成功后，其中是没有任何一个线程的。任务队列是作为线程池的一个构造参数传入的，如果初始队列中有任务，线程池也并不会马上执行其中的任务。

如图所示，当应用通过execute方法往线程池提交任务时，线程池会做出如下的动作：

1、如果正在运行的线程数小于核心线程数时（corePoolSize)，通过addWorker方法创建新线程，并将此任务作为当前线程的初始任务执行

2、如果当前运行的线程数量大于或者等于核心线程数时，addWorker会return false，这时，将任务放入队列

如果队列满了，通过addWorker创建非核心线程，并立即将任务执行
如果队列满了，通过addWorker创建非核心线程失败，则通过reject方法执行失败策略

如果一个工作线程长时间无事可做，超过keepAliveTime参数设置的超时时间，如果当前运行的线程数大于核心线程数，这个线程便会执行停止策略。

那么其是如何实现的呢？

while (task != null || (task = getTask()) != null) {
 ...
}

在getTask()方法中

Runnable r = timed ?
 workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) :
 workQueue.take();

其实利用的是阻塞队列poll方法的超时时间，当达到超时时间，仍然没有获取到任务，便会返回null，进而Worker中的while循环跳出，结束线程。

问题解答

回到问题本身，当100个请求同时执行execute方法往线程池提交任务时，

由于一开始工作线程数是小于核心线程的，这100个任务会通过CAS争抢的方式创建新核心线程（worker），立即执行任务
如果核心线程数达到5，将任务放入队列中
- 如果放入成功，调用addWorker创建工作线程，从队列中取任务执行（工作线程数大于等于10时，会创建失败，导致任务堆积在队列中，等待其他工作线程执行）
- 如果放入失败，addWorker创建工作线程，立即执行该任务，如果创建失败，抛出异常

扩展

线程池参数的设置策略

线程数

一般根据业务时IO密集型还是计算密集型

如果时计算密集型，那么一般根据设置成CPU核心数，防止过多线程，导致上下文切换，降低运行效率
如果时IO密集型，考虑到充分压榨CPU的计算能力，可以设置为2倍CPU核心数，具体根据业务情况而定

超时时间

根据每一个任务执行所需的时间而定，避免频繁创建和销毁线程，提高线程利用率。

无法将交换文件 /vmfs/volumes/.../XXXXX.vswp 从 0 KB 扩展到 6291456 KB : No space left on device

Fri, 27 Sep 2024 19:10:53 +0800

在编辑虚拟机，增加内存时，出现如下的错误

解决方案：

在编辑虚拟机，增加内存时，将预留内存也一并分配

策略模式

Fri, 27 Sep 2024 19:10:53 +0800

策略模式

策略模式定义了一组算法，将它们逐个封装起来，并使它们可以相互替换。策略可以让算法独立于使用它们的客户而变化。

应用

在业务场景中，我们经常需要根据不同的条件而执行不同方法，这个时候便可以为每一种条件定制一类特定的方法。

类图

如图所示

Strategy: 策略接口或者策略抽象类，并且策略执行的接口
ConcreateStrategyA、ConcreateStrategyB、ConcreateStrategyC：实现策略接口的具体策略类
Context：上下文类，持有具体策略类的实例，并负责调用相关的算法

示例

普通实现

定义接口

public interface PrintStrategy {

 boolean support(String code);

 void print(Message message);

}

实现类

public class OnePrintStrategy implements PrintStrategy {

 @Override
 public boolean support(String code) {
 return "1".equals(code);
 }

 @Override
 public void print(Message message) {
 System.out.println(message.toString());
 }
}

public class TwoPrintStrategy implements PrintStrategy{
 @Override
 public boolean support(String code) {
 return "2".equals(code);
 }

 @Override
 public void print(Message message) {
 System.out.println(message.toString());
 }
}

策略实例持有类

public class StrategyContext{

 private final List<PrintStrategy> strategies;

 public StrategyContext(){
 strategies = new ArrayList<>();
 strategies.add(new OnePrintStrategy());
 strategies.add(new TwoPrintStrategy());
 }

 public PrintStrategy getStrategy(String code){
 for(PrintStrategy printStrategy:strategies){
 if(printStrategy.support(code)){
 return printStrategy;
 }
 }
 throw new RuntimeException("unsupported code");
 }

}

测试

@Data
@AllArgsConstructor
public class Message {

 private String code;

 private String body;

}

public class Demo {
 public static void main(String[] args) {
 StrategyContext strategyContext = new StrategyContext();
 Message message = new Message("2","打印策略2");
 strategyContext.getStrategy(message.getCode()).print(message);
 }
}

Message(code=2, body=打印策略2)

Process finished with exit code 0

枚举实现

枚举

public enum PrintStrategyEnum {

 ONE("1"){
 @Override
 protected void print(Message message) {
 System.out.println("枚举类策略1 "+message.toString());
 }
 },
 TWO("2") {
 @Override
 protected void print(Message message) {
 System.out.println("枚举类策略2 "+message.toString());
 }
 };

 private final String code;

 PrintStrategyEnum(String code) {
 this.code = code;
 }


 protected abstract void print(Message message);

 public String getCode() {
 return code;
 }
}

测试

public class Demo {
 public static void main(String[] args) {
 StrategyContext strategyContext = new StrategyContext();
 Message message = new Message("2","打印策略2");
 strategyContext.getStrategy(message.getCode()).print(message);


 for(PrintStrategyEnum printStrategyEnum: PrintStrategyEnum.values()){
 if(printStrategyEnum.getCode().equals(message.getCode())){
 printStrategyEnum.print(message);
 }
 }



 }
}

设计模式之观察者模式-谈谈你对观察者模式的理解

Fri, 27 Sep 2024 19:10:53 +0800

定义

先来段wiki上面的定义：观察者模式是软件设计模式的一种。在此种模式中，一个目标对象管理所有相依于它的观察者对象，并且在它本身的状态改变时主动发出通知。这通常透过呼叫各观察者所提供的方法来实现。此种模式通常被用来实时事件处理系统。简单来讲，就是定义了一组一对多的关系。当被观察者的状态改变，会通知观察者做出相应的动作。

在开发过程中，常常会遇到如下的场景：

游戏开发中，当人物走到某个格子，触发加血、战斗等动作
微信公众号，当用户关注了某公众号，一旦公众号更新了文章，便可以给用户进行推送

在这种情况下，我们该如何实现符合开闭原则的代码呢，观察者模式便是一个很好的选择。

模式结构及实现

下图便是观察者模式的模式结构。

从图中可以看出，观察者模式主要结构主要包括发布者和订阅者两个行为对象，发布者持有所有订阅者的集合，当需要发布事件或者消息时，通知订阅者做出相应的动作。

代码

定义事件接口，作为观察者与被观察者之间交互的媒介

public interface Event {
}

定义Subscriber接口，作为观察者的接口

public interface Subscriber {

 void update(Event event);

}

Subscriber的两个简单实现类

public class ReadSubscriber implements Subscriber{
 @Override
 public void update(Event e) {
 System.out.println("ReadSubscriber");
 }
}

public class WriteSubscriber implements Subscriber{
 @Override
 public void update(Event e) {
 System.out.println("WriteSubscriber");
 }
}

定义Publisher接口，作为被观察者的接口

public interface Publisher {

 void subscribe(Subscriber subscriber);

 void unsubscribe(Subscriber subscriber);

 void notifySubscribers(Event event);

}

Publisher接口实现类

public class DefaultPublisher implements Publisher{

 private final List<Subscriber> subscribers = new ArrayList<>();

 @Override
 public void subscribe(Subscriber subscriber) {
 subscribers.add(subscriber);
 }

 @Override
 public void unsubscribe(Subscriber subscriber) {
 subscribers.remove(subscriber);
 }

 @Override
 public void notifySubscribers(Event event) {
 for(Subscriber subscriber:subscribers){
 subscriber.update(event);
 }
 }
}

Demo测试

限流的方式-几种限流算法的介绍与对比

Fri, 27 Sep 2024 19:10:53 +0800

简述

java限流大体可以分为3个方面。

合法性
- 验证码
- 黑名单
容器限流
- tomcat
- nginx
算法限流
- 固定时间窗口算法
- 滑动时间窗口算法
- 漏桶算法
- 令牌桶算法

算法限流

固定时间窗口

这是限流算法中最简单也是最暴力的一种朴素算法。既然我们的目标是让APP在一分钟内只能被调用N次。那么我们便可以统计这一分钟内接口被调用的次数，一旦调用的次数超过我们设置的阈值，则拒绝提供服务。这种算法的优势是逻辑容易理解，实现也很容易。劣势则是由于时间窗口是固定的，可能在某些时间段服务器会承受超过设定阈值的请求。

如图所示，比如我们设置一分钟只能提供100次访问服务，如果某个应用在某一分钟后半部访问了100次，在下一分钟前半步访问了100次，看似符合窗口限制条件，实际上，服务器在0 :30~1:30这个时间区间上提供了200次服务（已经超出了服务器的设置的阈值）。并且，这个用户在瞬间耗光了两个时间窗口区间的服务定额，导致其他用户均不能访问了，这在业务上也是不能接受的。

滑动时间窗口算法

滑动时间窗口算法可以认为是对固定时间窗口的改进。也可被称为精度不够，时间来凑。

如图所示，将一分钟分为10个更加小的时间区间，每个小时间区间都有其自己的计数器，对其自身小时间区间进行控制。除此以外，若干个小时间区间组成一个时间窗口，并且随着时间的推移，时间窗口也随之右移。每个一段时间删除最左端的小区间，在最右端添加小区间，对整个时间窗口的总流量也进行控制。如果恶意用户分时间窗口进行大量请求，也能被检测出来。最后，我们也可以得出结论，时间区块分配的越精细，流量控制也会随之更加精细。

dubbo有使用

漏桶算法

漏桶算法(Leaky Bucket)是网络世界中流量整形（Traffic Shaping）或速率限制（Rate Limiting）时经常使用的一种算法，它的主要目的是控制数据注入到网络的速率，平滑网络上的突发流量。漏桶算法提供了一种机制，通过它，突发流量可以被整形以便为网络提供一个稳定的流量。这是漏桶算法的基本定义。

形象一点的解释的话：

漏桶可以看作是一个队列，将客户端的请求依次放入队列中，服务端以一定的速率从队列中获取请求进行处理，如果某一时刻收到了客户端发起的大量请求，队列放不下了，则丢弃数据包。可以用来平滑网络上的突发流量。有点类似于消息队列的作用。

如图所示，请求好比水流，出水速度好比服务端处理请求的速率，一旦大量水流冲击过来，当桶装不下时水变回溢出，体现为直接拒绝客户端的请求。

令牌桶算法

令牌桶是一种用于分组交换计算机网络和电信网络的算法。它可用于检查数据包形式的数据传输是否符合定义的带宽和突发性限制（流量不均匀或变化的度量）。

其原理就是，以一定的速率将令牌放入池子中，当请求到来时，就从池子中获取令牌，持有令牌才能进行后续的访问，获取不到令牌则直接拒绝访问。

当请求的速率等于令牌生成速率时，每一个请求能无延迟的通过令牌池
当请求的速率小于令牌生成速率时，每一个请求能无延迟的通过令牌池，并且多余的令牌会在池子中积累起来，供后续的突发流量使用
当请求的速率大于令牌生成速率时，当前面请求消耗完池子中的令牌后，后续请求获取不到令牌，不能获得服务

特点总结

漏桶能强制以一定的速率消费请求
令牌桶既能限制请求的平均速率，也能应对突发流量情况
固定时间窗口不能实现高精度的控制

CAP定理

Fri, 27 Sep 2024 19:10:52 +0800

概述

1998年，加州大学的计算机科学家 Eric Brewer 提出，分布式系统有三个指标。

Consistency
Availability
Partition tolerance

这三个指标不可能全部做到。

Partition tolerance

分区容错性

大多数分布式系统都分布在多个子网络。每个子网络就叫做一个区（partition）。分区容错的意思是，区间通信可能失败。

（数据同步失败）

Consistency

一致性

不管客户端向哪个节点发送请求，得到的结果应该是一致的。

Availability

可用性

用户只要向集群中任一节点发送了请求，就必须收到响应，否则就不满足可用性。

为什么三者不能同时满足

一致性和可用性，为什么不可能同时成立？答案很简单，因为可能通信失败（即出现分区容错）。

如果保证 G2 的一致性，那么 G1 必须在写操作时，锁定 G2 的读操作和写操作。只有数据同步后，才能重新开放读写。锁定期间，G2 不能读写，没有可用性。

如果保证 G2 的可用性，那么势必不能锁定 G2，所以一致性不成立。

综上所述，G2 无法同时做到一致性和可用性。系统设计时只能选择一个目标。如果追求一致性，那么无法保证所有节点的可用性；如果追求所有节点的可用性，那就没法做到一致性。

参考

https://www.zhihu.com/question/54105974

http://www.ruanyifeng.com/blog/2018/07/cap.html

Dubbo笔记-概述

Fri, 27 Sep 2024 19:10:52 +0800

dubbo 学习

Apache Dubbo 是一款高性能、轻量级的开源Java RPC框架，它提供了三大核心能力：面向接口的远程方法调用，智能容错和负载均衡，以及服务自动注册和发现。

背景

常见的架构

随着互联网的发展，网站应用的规模不断扩大，应用的架构也在不断的迭代发展。

单一应用架构

当网站流量很小时，只需一个应用，将所有功能都部署在一起，以减少部署节点和成本。此时，用于简化增删改查工作量的数据访问框架(ORM)是关键。
垂直应用架构

当访问量逐渐增大，单一应用增加机器带来的加速度越来越小，提升效率的方法之一是将应用拆成互不相干的几个应用，以提升效率。此时，用于加速前端页面开发的Web框架(MVC)是关键。
分布式服务架构

当垂直应用越来越多，应用之间交互不可避免，将核心业务抽取出来，作为独立的服务，逐渐形成稳定的服务中心，使前端应用能更快速的响应多变的市场需求。此时，用于提高业务复用及整合的分布式服务框架(RPC)是关键。
流动计算架构

当服务越来越多，容量的评估，小服务资源的浪费等问题逐渐显现，此时需增加一个调度中心基于访问压力实时管理集群容量，提高集群利用率。此时，用于提高机器利用率的资源调度和治理中心(SOA)是关键。

需求

随着服务的不断增多，暴露出诸多的问题。如服务URL配置管理变得非常困难、服务间依赖关系错踪复杂、服务的容量无法快速准确估计等。

dubbo服务的诞生便是应对如上的几个需求。

dubbo架构

服务提供者（Provider）：暴露服务的服务提供方，服务提供者在启动时，向注册中心注册自己提供的服务。
服务消费者（Consumer）: 调用远程服务的服务消费方，服务消费者在启动时，向注册中心订阅自己所需的服务，服务消费者，从提供者地址列表中，基于软负载均衡算法，选一台提供者进行调用，如果调用失败，再选另一台调用。
注册中心（Registry）：注册中心返回服务提供者地址列表给消费者，如果有变更，注册中心将基于长连接推送变更数据给消费者。
监控中心（Monitor）：服务消费者和提供者，在内存中累计调用次数和调用时间，定时每分钟发送一次统计数据到监控中心。

调用关系:

服务容器负责启动，加载，运行服务提供者。
服务提供者在启动时，向注册中心注册自己提供的服务。
服务消费者在启动时，向注册中心订阅自己所需的服务。
注册中心返回服务提供者地址列表给消费者，如果有变更，注册中心将基于长连接推送变更数据给消费者。
服务消费者，从提供者地址列表中，基于软负载均衡算法，选一台提供者进行调用，如果调用失败，再选另一台调用。
服务消费者和提供者，在内存中累计调用次数和调用时间，定时每分钟发送一次统计数据到监控中心。

使用

Java注解-元注解

Fri, 27 Sep 2024 19:10:52 +0800

元注解

@Retention

public @interface Retention {
 /**
 * Returns the retention policy.
 * @return the retention policy
 */
 RetentionPolicy value();
}

此注解表明了注解的生命周期

public enum RetentionPolicy {
 /**
 * Annotations are to be discarded by the compiler.
 */
 SOURCE,

 /**
 * Annotations are to be recorded in the class file by the compiler
 * but need not be retained by the VM at run time. This is the default
 * behavior.
 */
 CLASS,

 /**
 * Annotations are to be recorded in the class file by the compiler and
 * retained by the VM at run time, so they may be read reflectively.
 *
 * @see java.lang.reflect.AnnotatedElement
 */
 RUNTIME
}

有三种，分别是源代码、字节码、和运行时

Mysql查询优化

Fri, 27 Sep 2024 19:10:52 +0800

查询执行流程

如图所示，mysql的查询一般分为如下步骤：

客服端发送一条查询给服务器
服务器先检查查询缓存，如果命中缓存，则立刻返回存储在缓存中的结果。否则进入下一个阶段。
服务器端进行SQL解析、预处理，在由优化器生成对应的执行计划。
MySQL根据优化器生成的执行计划，调用存储引擎的API来执行查询
将结果返回给客户端

注意点

字段

尽量使用TINYINT、SMALLINT、MEDIUM_INT作为整数类型而非INT，如果非负则加上UNSIGNED
VARCHAR的长度只分配真正需要的空间
使用枚举或整数代替字符串类型
尽量使用TIMESTAMP而非DATETIME，
单表不要有太多字段，建议在20以内
避免使用NULL字段，很难查询优化且占用额外索引空间
用整型来存IP

索引

索引并不是越多越好，要根据查询有针对性的创建，考虑在WHERE和ORDER BY命令上涉及的列建立索引，可根据EXPLAIN来查看是否用了索引还是全表扫描
应尽量避免在WHERE子句中对字段进行NULL值判断，否则将导致引擎放弃使用索引而进行全表扫描
值分布很稀少的字段不适合建索引，例如"性别"这种只有两三个值的字段
字符字段最好不要做主键
不用外键，由程序保证约束
尽量不用UNIQUE，由程序保证约束
使用多列索引时主意顺序和查询条件保持一致，同时删除不必要的单列索引

SQL

可通过开启慢查询日志来找出较慢的SQL
不做列运算：SELECT id WHERE age + 1 = 10，任何对列的操作都将导致表扫描，它包括数据库教程函数、计算表达式等等，查询时要尽可能将操作移至等号右边
sql语句尽可能简单：一条sql只能在一个cpu运算;大语句拆小语句，减少锁时间;一条大sql可以堵死整个库
不用SELECT *
OR改写成IN：OR的效率是n级别，IN的效率是log(n)级别，in的个数建议控制在200以内
不用函数和触发器，在应用程序实现
避免%xxx式查询
少用JOIN
使用同类型进行比较，比如用'123’和'123’比，123和123比
尽量避免在WHERE子句中使用!=或<>操作符，否则将引擎放弃使用索引而进行全表扫描
对于连续数值，使用BETWEEN不用IN：SELECT id FROM t WHERE num BETWEEN 1 AND 5
列表数据不要拿全表，要使用LIMIT来分页，每页数量也不要太大

Redis笔记-数据类型

Fri, 27 Sep 2024 19:10:52 +0800

基本数据类型及应用场景

类型	简介	特性	场景
String(字符串)	二进制安全	可以包含任何数据,比如jpg图片或者序列化的对象,一个键最大能存储512M	—
Hash(字典)	键值对集合,即编程语言中的Map类型	适合存储对象,并且可以像数据库中update一个属性一样只修改某一项属性值(Memcached中需要取出整个字符串反序列化成对象修改完再序列化存回去)	存储、读取、修改用户属性
List(列表)	链表(双向链表)	增删快,提供了操作某一段元素的API	1,最新消息排行等功能(比如朋友圈的时间线) 2,消息队列
Set(集合)	哈希表实现,元素不重复	1、添加、删除,查找的复杂度都是O(1) 2、为集合提供了求交集、并集、差集等操作	1、共同好友 2、利用唯一性,统计访问网站的所有独立ip 3、好友推荐时,根据tag求交集,大于某个阈值就可以推荐
Sorted Set(有序集合)	将Set中的元素增加一个权重参数score,元素按score有序排列	数据插入集合时,已经进行天然排序	1、排行榜 2、带权重的消息队列

字符串（String）

设置值

set命令:为键设置值.

set key value

setex命令:为键设置值,并设置秒级的过期时间.

setex key value seconds

setpx命令:为键设置值,并设置毫秒秒级的过期时间.

setpx key value millisecond

setnx命令:向键设置值前判断键是否存在,不存在则设置值存在则不设置.

setnx key value

setxx命令:与setnx相反,向键设置值前判断键是否存在,存在则设置值存在则不设置.

setxx key value

setnx和setxx的使用场景:由于redis是单线程命令处理机制,如果多个客户端同时向redis服务使用setnx命令也只会有一个客户端执行成功.setnx可以用于分布式锁的一个解决方案.

计数

incr命令:用于对键的值进行自增操作,返回结果为三种:

值不是整数,返回错误.
值是整数,返回自增后的结果.
值不存在,按照值为0自增,返回1.

incr key

incrby命令:用于对键的值进行指定自增量的自增操作,返回结果与incr相同.

incrby key

incrbyfloat命令:用于对键的值进行指定浮点型自增量的自增操作.

incrbyfloat key

decr命令:用于对键的值进行自减操作.

decr key

decrby命令:用于对键的值进行指定值进行减值操作.

decrby key

append命令:用于对键的值进行追加操作,返回追加后的值的得长度.

append key

strlen命令:用于查看键的值得长度.

strlen key

setrange命令:用于键的值内指定索引字符的替换,如果参数是多个字符则从指定位置开始逐个替换,返回替换后值的长度.

spring boot运行非web项目

Fri, 27 Sep 2024 19:10:52 +0800

前言

一直以来，一直使用springboot来创建基于web的项目，今天突然想到，springboot是否可以用于非web项目的使用。

非web运行办法

启动类main方法后面执行

@SpringBootApplication
public class StudyLockApp {
 public static void main(String[] args) {
 ConfigurableApplicationContext configurableApplicationContext = SpringApplication.run(StudyLockApp.class, args);
 RedisService redisService = configurableApplicationContext.getBean(RedisService.class);
 Boolean lock = redisService.getLock("lock", 1);
 System.out.println(lock);
 }

}

通过SpringApplication.run拿到bean容器
获取到已经注入进去的业务bean
执行相应的方法

实现ApplicationRunner接口

@SpringBootApplication
public class StudyLockApp implements ApplicationRunner, ApplicationContextAware {
 private ApplicationContext applicationContext;

 public static void main(String[] args) {
 SpringApplication.run(StudyLockApp.class, args);
 }


 @Override
 public void run(ApplicationArguments args) throws Exception {
 RedisService redisService = applicationContext.getBean(RedisService.class);
 for(int i = 0;i<10;i++){
 Thread thread = new Thread(new ConsumerThread(i,redisService));
 thread.start();
 }
 }

 @Override
 public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
 this.applicationContext = applicationContext;
 }
}

实现CommandLineRunner接口

@SpringBootApplication
public class StudyLockApp implements CommandLineRunner, ApplicationContextAware {
 private ApplicationContext applicationContext;

 public static void main(String[] args) {
 SpringApplication.run(StudyLockApp.class, args);
 }

 @Override
 public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
 this.applicationContext = applicationContext;
 }

 @Override
 public void run(String... args) throws Exception {
 RedisService redisService = applicationContext.getBean(RedisService.class);
 for(int i = 0;i<10;i++){
 Thread thread = new Thread(new ConsumerThread(i,redisService));
 thread.start();
 }
 }
}

Springboot源码

public ConfigurableApplicationContext run(String... args) {
 StopWatch stopWatch = new StopWatch();
 stopWatch.start();
 ConfigurableApplicationContext context = null;
 Collection<SpringBootExceptionReporter> exceptionReporters = new ArrayList<>();
 configureHeadlessProperty();
 SpringApplicationRunListeners listeners = getRunListeners(args);
 listeners.starting();
 try {
 ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);
 ConfigurableEnvironment environment = prepareEnvironment(listeners, applicationArguments);
 configureIgnoreBeanInfo(environment);
 Banner printedBanner = printBanner(environment);
 context = createApplicationContext();
 exceptionReporters = getSpringFactoriesInstances(SpringBootExceptionReporter.class,
 new Class[] { ConfigurableApplicationContext.class }, context);
 prepareContext(context, environment, listeners, applicationArguments, printedBanner);
 refreshContext(context);
 afterRefresh(context, applicationArguments);
 stopWatch.stop();
 if (this.logStartupInfo) {
 new StartupInfoLogger(this.mainApplicationClass).logStarted(getApplicationLog(), stopWatch);
 }
 listeners.started(context);
 callRunners(context, applicationArguments);
 }
 catch (Throwable ex) {
 handleRunFailure(context, ex, exceptionReporters, listeners);
 throw new IllegalStateException(ex);
 }

 try {
 listeners.running(context);
 }
 catch (Throwable ex) {
 handleRunFailure(context, ex, exceptionReporters, null);
 throw new IllegalStateException(ex);
 }
 return context;
 }

private void callRunners(ApplicationContext context, ApplicationArguments args) {
 List<Object> runners = new ArrayList<>();
 runners.addAll(context.getBeansOfType(ApplicationRunner.class).values());
 runners.addAll(context.getBeansOfType(CommandLineRunner.class).values());
 AnnotationAwareOrderComparator.sort(runners);
 for (Object runner : new LinkedHashSet<>(runners)) {
 if (runner instanceof ApplicationRunner) {
 callRunner((ApplicationRunner) runner, args);
 }
 if (runner instanceof CommandLineRunner) {
 callRunner((CommandLineRunner) runner, args);
 }
 }
 }

 private void callRunner(ApplicationRunner runner, ApplicationArguments args) {
 try {
 (runner).run(args);
 }
 catch (Exception ex) {
 throw new IllegalStateException("Failed to execute ApplicationRunner", ex);
 }
 }

 private void callRunner(CommandLineRunner runner, ApplicationArguments args) {
 try {
 (runner).run(args.getSourceArgs());
 }
 catch (Exception ex) {
 throw new IllegalStateException("Failed to execute CommandLineRunner", ex);
 }
 }

其实就是在执行容器初始化后再调用实现的run方法而已。

Zookeeper概述与安装

Fri, 27 Sep 2024 19:10:52 +0800

特性

ZooKeeper 解决的本质问题

消息传递：延迟性，先发送的消息，不一定先到达；
消息传递：丢失性，发送的消息，可能丢失；
节点崩溃：分布式系统内，任何一个节点都可能崩溃。

如何保证分布式一致性

顺序一致性：同一个 Client 发起的事务请求，严格按照发起顺序执行
原子性：事务请求，要么应用到所有节点，要么一个节点都没有应用
单一视图：Client 无论连接到哪个节点，看到的服务端数据都是一致的（Note：不准确，其实是最终一致性）
可靠性：事务一旦执行成功，状态永久保留
实时性：事务一旦执行成功，Client 并不能立即看到最新数据，但 ZooKeeper 保证最终一致性

官方文档：https://zookeeper.apache.org/doc/r3.6.2/zookeeperStarted.html

安装（centos 7）

下载

wget https://mirror.bit.edu.cn/apache/zookeeper/zookeeper-3.6.2/apache-zookeeper-3.6.2-bin.tar.gz
tar zvxf apache-zookeeper-3.6.2-bin.tar.gz
cd apache-zookeeper-3.6.2-bin

配置

单机模式

创建配置文件 conf/zoo.cfg

vi conf/zoo.cfg

写入配置

tickTime=2000
dataDir=/var/lib/zookeeper
clientPort=2181

tickTime : the basic time unit in milliseconds used by ZooKeeper. It is used to do heartbeats and the minimum session timeout will be twice the tickTime.
dataDir : the location to store the in-memory database snapshots and, unless specified otherwise, the transaction log of updates to the database.
clientPort : the port to listen for client connections

启动

bin/zkServer.sh start

连接

bin/zkCli.sh -server 127.0.0.1:2181

Connecting to localhost:2181
log4j:WARN No appenders could be found for logger (org.apache.zookeeper.ZooKeeper).
log4j:WARN Please initialize the log4j system properly.
Welcome to ZooKeeper!
JLine support is enabled
[zkshell: 0]