小温之家—行走在猿类世界

记一次试用阿里公有云ARMS（应用实时监控服务）产品

Sat, 14 Nov 2020 10:19:06 CST

在阿里公有云上手抖买了云服务器ECS（Elastic Compute Service）好久了，花了几百大洋，肉痛。。。那时刚好正值阿里云ARMS（应用实时监控服务）开通试用，那就玩一把吧。ARMS是基于Agent的无侵入式APM（应用性能管理）方案，它对性能监控、分布式链路追踪、故障诊断都有很强的支持，包含应用监控、前端监控、容器监控甚至是自定义监控等非常大而全的功能，简直是一站式全家桶服务。

准备ECS环境

只有一台ECS，那就要物尽其用，体验ECS环境下的ARMS。对ECS进行操作，需先配置安全组规则，定义出入方向的端口等等，第一次SSH登录，需重置密码。考虑只有一台ECS环境，可能要测试多应用，安装Docker和Nginx环境。

1、安装docker环境，启动测试，判断是否安装成功

# 修改软件源sudo yum-config-manager \    --add-repo \    https://mirrors.ustc.edu.cn/docker-ce/linux/centos/docker-ce.reposudo sed -i 's/download.docker.com/mirrors.ustc.edu.cn\/docker-ce/g' /etc/yum.repos.d/docker-ce.repo

sudo yum makecache fastsudo yum install docker-ce

sudo systemctl enable dockersudo systemctl start docker

# hello world镜像测试服务docker run hello-world

参考：https://yeasy.gitbooks.io/docker_practice/content/install/centos.html

2、docker下安装nginx

# 安装Nginx，并挂载资源和配置docker run -d -p 80:80 --name nginx-web \  -v /home/nginx/www:/usr/share/nginx/html \  -v /home/nginx/conf/nginx.conf:/etc/nginx/nginx.conf \  -v /home/nginx/logs:/var/log/nginx \  nginx

vi /home/nginx/www/index.html 编写测试首页

Nginx test !!!    Nginx
    Hello,wenqy!

vi /home/nginx/conf/nginx.conf配置路由到首页

server {        listen       80;        #server_name  localhost;        #charset koi8-r;        #access_log  logs/host.access.log  main;        location / {            root   /usr/share/nginx/html;            index  index.html index.htm;        }}

curl 127.0.0.1:80 测试访问

3、docker镜像加速

开通镜像服务器：https://cr.console.aliyun.com/cn-hangzhou/instances/mirrors

sudo mkdir -p /etc/dockersudo tee /etc/docker/daemon.json <<-'EOF'{  "registry-mirrors": ["https://xxxxxx.mirror.aliyuncs.com"]}EOFsudo systemctl daemon-reloadsudo systemctl restart docker

公网访问

ECS安全组规则里，配置入口方向，开放端口，0.0.0.0/0

curl 123.56.xxx.xxx访问

RDS环境

准备RDS环境，有条件的同学也可以购买RDS（关系型数据库服务），进行RDS操作时，需添加白名单和安全组，申请外网地址，创建数据库账号等等。

ARMS环境

阿里云官网，开通ARMS试用，注意不要选择专业版，专业版按量付费，不差钱的那就另说了。

单应用测试

Docker安装demo应用

准备应用，从start.aliyun.com （类似https://start.spring.io/在线项目初始化器）下载 demo

mvn clean installjava -jar demo-0.0.1-SNAPSHOT.jar

启动失败，提示没有清单属性，META-INF没有定义主类

修改插件配置

org.springframework.bootspring-boot-maven-plugin2.2.6.RELEASE                                  repackage                        com.wenqy.demo.DemoApplication

还要写controller类，来暴露REST服务，本想体验一把start.aliyun.com的便捷性，可能我操作不对，直接放弃，改用之前写的demo

https://github.com/wenqy/java-study/tree/master/spring-security-study/securing-web

准备好应用和Dockerfile文件后，构建demo镜像

[root@iZ2ze7666pvq2l4otgrbseZ securing-web]# docker build -t wenqy/securing-web:1.0.0 .Sending build context to Docker daemon  20.98MBStep 1/4 : FROM openjdk:8-jdk-alpine8-jdk-alpine: Pulling from library/openjdke7c96db7181b: Pull complete f910a506b6cb: Pull complete c2274a1a0e27: Pull complete Digest: sha256:94792824df2df33402f201713f932b58cb9de94a0cd524164a0f2283343547b3Status: Downloaded newer image for openjdk:8-jdk-alpine ---> a3562aa0b991Step 2/4 : COPY securing-web-0.0.1-SNAPSHOT.jar /securing-web-0.0.1-SNAPSHOT.jar ---> d4b27dd36821Step 3/4 : ENTRYPOINT ["java","-jar","/securing-web-0.0.1-SNAPSHOT.jar"] ---> Running in fbc474735d0bRemoving intermediate container fbc474735d0b ---> 13efd600069cStep 4/4 : EXPOSE 8080 ---> Running in d11d875488b3Removing intermediate container d11d875488b3 ---> ea41dcbbfac0Successfully built ea41dcbbfac0Successfully tagged wenqy/securing-web:1.0.0[root@iZ2ze7666pvq2l4otgrbseZ securing-web]# docker imagesREPOSITORY           TAG                 IMAGE ID            CREATED             SIZEwenqy/securing-web   1.0.0               ea41dcbbfac0        9 seconds ago       126MBnginx                latest              ed21b7a8aee9        3 weeks ago         127MBopenjdk              8-jdk-alpine        a3562aa0b991        11 months ago       105MBhello-world          latest              fce289e99eb9        15 months ago       1.84kB

运行容器应用，测试是否启动成功

[root@iZ2ze7666pvq2l4otgrbseZ securing-web]# docker run -d -p 8080:8080 --name securing-web  wenqy/securing-web:1.0.002f8d461e6b9566ccd84d225f8d6d301a057650d2334bda3b5b5174ec80d04cd[root@iZ2ze7666pvq2l4otgrbseZ securing-web]# docker psCONTAINER ID        IMAGE                      COMMAND                  CREATED             STATUS              PORTS                    NAMES02f8d461e6b9        wenqy/securing-web:1.0.0   "java -jar /securing…"   5 seconds ago       Up 5 seconds        0.0.0.0:8080->8080/tcp   securing-web3a5f171848e0        nginx                      "nginx -g 'daemon of…"   8 days ago          Up 7 days           0.0.0.0:80->80/tcp       nginx-web[root@iZ2ze7666pvq2l4otgrbseZ securing-web]# curl localhost:8080            Spring Security Example                Welcome!
        Click here to see a greeting.
    [root@iZ2ze7666pvq2l4otgrbseZ securing-web]#

配置Nginx，将请求转发至应用端口，其中ifconfig 使用docker0的ip

location / {     proxy_pass http://172.17.0.1:8080;}

docker restart nginx重启nginx后，查看效果，访问成功

Docker安装demo应用Agent

1、准备ARMS的licenseKey

在ARMS控制台要接入的应用里获取licenseKey

2、集成已有镜像

编辑Dockerfile文件来集成镜像，注意修改应用和licenseKey。

##       RMS APM DEMO Docker    #####          For Java            #####      withAgent   V0.1        #####                              ######################################FROM wenqy/securing-web:1.0.0WORKDIR /root/# 请根据所在地域替换探针的下载地址。RUN wget "http://arms-apm-hangzhou.oss-cn-hangzhou.aliyuncs.com/ArmsAgent.zip" -O ArmsAgent.zipRUN unzip ArmsAgent.zip -d /root/# LicenseKey 在控制台应用监控接入页面查看。# AppName 为用户自定义 ARMS 监控应用名称，用户名暂不支持中文。# 若所有镜像都接入同一个应用监控任务，配置此处的 arms_licenseKey 和 arms_appName 即可。# 若需将镜像接入其他应用监控任务，可在 docker run 中使用 -e 参数指定该应用的 arms_licenseKey 和 arms_appName 参数，以覆盖此处的配置。ENV arms_licenseKey=ARMS控制台分配的KeyENV arms_appName=ARMS控制台接入应用ENV JAVA_TOOL_OPTIONS ${JAVA_TOOL_OPTIONS} '-javaagent:/root/ArmsAgent/arms-bootstrap-1.7.0-SNAPSHOT.jar -Darms.licenseKey='${arms_licenseKey}' -Darms.appName='${arms_appName}### for check the argsRUN env | grep JAVA_TOOL_OPTIONS### 下面可加入用户 自定义 dockerfile 逻辑。### ......

3、构建并启动新镜像

构建Agent镜像

docker build -t wenqy/arms-springboot:1.0.0 -f Dockerfile .

启动Agent镜像

docker run -d -e "arms_licenseKey=xxxxxx" -e "arms_appName=application" -p 8081:8080 wenqy/arms-springboot:1.0.0

启动成功后，登录ARMS控制台，进行结果验证

编写脚本，对应用进行访问，预热

#!/bin/bashwhile truedocurl localhost:8081sleep 1done

监控信息有一定延迟，一段时间后查看控制台

查看接入应用列表

查看应用metric概览统计分析

查看应用详情监控信息，JVM监控

查看应用详情监控信息，CPU、内存、磁盘等主机监控

应用诊断，线程分析，分析线程栈信息

docker安装探针，参考：https://help.aliyun.com/document_detail/85906.html?spm=a2c4g.11186623.6.588.58b8e108Khh65I

决定应用上下文id的名称org.springframework.boot.context.ContextIdApplicationContextInitializer.getApplicationId(ConfigurableEnvironment)

微服务应用测试

准备应用

像单应用测试一样准备多个微服务应用demo

account-demo https://github.com/wenqy/springcloud-study/tree/master/account-demo

order-demo https://github.com/wenqy/springcloud-study/tree/master/order-demo

inventory-demo https://github.com/wenqy/springcloud-study/tree/master/inventory-demo

eureka-server https://github.com/wenqy/springcloud-study/tree/master/eureka-server

涉及数据库的，对RDS数据库表初始化

构建并启动镜像

Docker构建微服务demo镜像

docker build -t weny/account-demo:1.0.0 .docker build -t weny/order-demo:1.0.0 .docker build -t weny/inventory-demo:1.0.0 .docker build -t weny/eureka-server:1.0.0 .

然后像单应用测试一样为每个微服务demo应用安装Agent镜像，最后启动Agent镜像

docker run -d -p 8400:8400 --name order-demo wenqy/agent-order-demo:1.0.0docker run -d -p 8401:8401 --name inventory-demo wenqy/agent-inventory-demo:1.0.0docker run -d -p 8402:8402 --name account-demo wenqy/agent-account-demo:1.0.0docker run -d -p 9000:9000 --name eureka-server wenqy/eureka-server:1.0.0

测试应用链路是否正常

[root@iZ2ze7666pvq2l4otgrbseZ ~]# curl -X POST "http://172.17.0.1:8400/order/orderPay?amount=1&count=1"success[root@iZ2ze7666pvq2l4otgrbseZ ~]# curl -X POST "http://172.17.0.1:8400/order/orderPay?amount=1&count=1"success[root@iZ2ze7666pvq2l4otgrbseZ ~]#

服务调用关系

order-service -> account-service      -> inventory-service

成功插入订单，服务调用正常

编写访问请求的脚本，让监控探针采集一段时间

#!/bin/bashwhile truedocurl -X POST "http://172.17.0.1:8400/order/orderPay?amount=1&count=1"sleep 2done

登录控制台，等待一段时间查看结果

ARMS图例

调用链路查询，查询调用链路列表

调用链路详情，查看调用关系和耗时

调用链路方法栈，查看方法栈耗时

应用列表，加入探针的应用列表

应用总览，CPU、内存等系统信息

应用总览，慢调用统计分析信息

应用总览，服务拓扑图

应用详情，SQL分析，SQL调用次数和平均耗时

应用详情，异常分析，异常统计及异常堆栈

应用详情，错误分析

应用详情，接口快照

接口调用，错误分析

接口调用，链路下游

数据库调用，QPS、响应时间统计

外部调用，HTTP状态统计、错误数统计等等

应用诊断，异常分析

进入Agent容器，查出探针日志

~/diamond/fixed-139.196.135.144_diamond/snapshot-tenant/c845a7b4-23a1-4f28-a380-5ab30d8a280f/cn-hangzhou # cat arms.trace.cj44pq0njo-3a979069aa8c619 {"profiler":{"agent":{"logger":{"level":"WARN"}},"enable":true,"sampling":{"enable":true,"rate":100,"deadline":1587738635558},"dubbo":{"enable":true},"googlehttpclient":{"enable":true},"hsf":{"enable":true},"httpclient3":{"enable":true},"httpclient4":{"enable":true},"jdkhttp":{"enable":true},"jetty":{"enable":true},"mybatis":{"enable":true},"mysql":{"enable":true},"okhttp":{"enable":true},"oracle":{"enable":true},"postgresql":{"enable":true},"redis":{"enable":true},"spring":{"enable":true},"springboot":{"enable":true},"tomcat":{"enable":true},"mongodb":{"enable":true},"lettuce":{"enable":true},"grpc":{"enable":true},"thrift":{"enable":true},"defined":{"excludeurl":""},"thresholds":{"apdex":500,"sql":500,"interface":500,"limit":100},"callstack":{"maxLength":128},"callsql":{"maxLength":1024}}}~/diamond/fixed-139.196.135.144_diamond/snapshot-tenant/c845a7b4-23a1-4f28-a380-5ab30d8a280f/cn-hangzhou # ~/diamond/fixed-139.196.135.144_diamond/snapshot-tenant/c845a7b4-23a1-4f28-a380-5ab30d8a280f/cn-hangzhou # cd ~~ # ls -ltrtotal 43816-rw-r--r--    1 root     root      44865284 Apr 24 12:14 ArmsAgent.zipdrwxr-xr-x    1 root     root            18 Apr 24 12:23 ArmsAgentdrwxr-xr-x    3 root     root            43 Apr 24 13:40 diamonddrwxr-xr-x    5 root     root           104 Apr 26 02:34 logs~ # cd logs/~/logs # ls -ltrtotal 2028drwxr-xr-x    3 root     root            23 Apr 24 12:23 armsdrwxr-xr-x    2 root     root            32 Apr 24 12:23 diamond-clientdrwxr-xr-x    2 root     root            57 Apr 26 02:34 spas-rw-r--r--    1 root     root         44448 Apr 26 02:34 spring.log.2020-04-24.0.gz-rw-r--r--    1 root     root       1350554 Apr 26 02:47 spring.log

查看镜像容器的依赖包，你会发现它依赖许多第三方开源组件，如：pinpoint、zipkin、opencensus等链路跟踪和其他RPC组件等等。

ARMS提供性能监控、用户体验监控、调用链追踪以及故障诊断等功能，在故障排查，分析和诊断性能瓶颈具重大作用。置于ARMS的Agent方式是否会对应用性能本身造成影响，还有待观察。类似Agent无侵入方法的开源产品有Pinpoint、Skywalking，但很显然，没有商用ARMS整合的大而全。如果应用有ARMS组件的加持，在服务监控预警、故障排查和性能诊断等多方面确实提供很大便利和帮助。

最后的最后，如果有想买阿里云ECS服务，想自己玩玩的胖友，那就顺手使用我的推广链接吧，买过的直接略过。

https://promotion.aliyun.com/ntms/yunparter/invite.html?userCode=n85o6zdm

参考

https://help.aliyun.com/product/34364.html?spm=a2c4g.11186623.6.540.167d31d3gH64oQ

https://yq.aliyun.com/articles/721312?spm=5176.7946893.1411534..7cfa75baEBYWPa

Effective-Java-代码如诗

Fri, 13 Nov 2020 10:46:53 CST

读一本好书，就像和高尚的人谈话。终于向Java界的经典著作《Effective Java》下手了。《Effective Java》不仅是JDK源码设计的指南，更是上层编程领域的金科玉律。

你是否想过如何写好一个注释，是否会为了注释而注释？你是否会忽视方法的访问级别？你是否会为了某个类、方法或变量的命名而烦恼？你是否会滥用继承，而不考虑它们之间的关系？你是否会忽视线程安全问题？你是否会随意实现Serializable接口，是否有认真考虑过序列化？你是否注意到自己的代码可能会发生内存泄漏？你是否考虑过怎样运用设计模式？你的API设计是否考虑版本兼容？你是否急于优化代码？你是否会在代码里做了隐藏规则的约定？你是否会复审自己的代码，觉得怎样实现才合理？你是否想过如何写出诗一般的代码，怎么样才能让人赏心悦目？你是否想过强如JDK源码也有着一些不合理的设计？太多太多。。。

一门语言，无外乎语法、词汇和用法，在用法上推敲琢磨也是司空见惯的事，这用法用的好就是诗，体现了对这门语言的驾驭水平，计算机语言亦是如此，代码可读性，高效性也是开发者的目标。《Effective Java》可以作为开发者的指导方针，引领你走向前方。通用的编程思想、设计原则和模式放之四海而皆准，并不仅仅局限于一门语言。

它就像一位长者，娓娓道来，诉说着曾经的风雨，分享着经验和教训，教你避开障碍，少走弯路，码出高效。它提出了许多准则和建议，值得我们去遵循或者思考。如果你对这本书能如会贯通，或许写出诗一般的代码就不会这么难了。下面整理了自己的非完全阅读笔记，备忘。诚然，有许多事情没有做到，但每个人都应该向诗人进军

Effective-Java

Effective-Java

创建和销毁对象

对象通用方法

类和接口

泛型

枚举和注解

Lambda和Stream

方法

通用程序设计

异常

并发

序列化

人性的弱点—这口心灵鸡汤我干了（附带思维导图）

Fri, 06 Nov 2020 09:41:40 CST

《人性的弱点》这本书听说过很久了，可我迟迟都没有阅读它的欲望，我曾一度以为，它是像《丑陋的中国人》那样，想要道尽人类脆弱的一面和不足之处，以反省自身，一度怀疑它有标题党之嫌。再者，每个人从小到大，谁都听过无数道理，没有理由去听成功学的“心灵鸡汤”，认为最终都会难免流于说教。

马云成功了，连马云自己都不知道有没有说过的话的马云成功学出来了，借着人性对成功的本能贪婪，多少人趋之若鹜，当多少人还陷在了追求成功的泥淖里无法自拔的时候，而兜售成功的成功学他们成功了，他们挣得盆满钵满。每一个人的成功都无法复制。如果可以，要看也要看成功者本人说的话，做过的事。（PS：话说，马云老师，做过演员，唱过歌，当过各种职业，就还没出过书。当周鸿祎、刘强东、李彦宏这些互联网大佬都已经出过书，如果马老师自己出一本书，那场面就火爆了，我一定追随一本）。风靡全球，畅销近百年的卡耐基成功学，到底是帮助他人成功，然后他也成功了，还是只有他成功了？

我无法考证，然而，这搁置许久的书我还是读了，记得是从当当网上下书单，搞促销赠品活动，我顺手把《人性的弱点》赠品勾上了，没想到还是一个选译本。本着不要浪费的原则，我还是读起了它。读完之后，你会发现他并没有像《丑陋的中国人》那样，有着直接丑陋行径的详例描写，更多的是引导你的人生，教你如何更好的把握自己，如何经营的你的人生，提出了许多案例和建议。

如何看待人际交往，为人处世，如何规划人生，怎样树立自己的金钱观、消费观，如何对待自己的工作，如何经营好自己的家庭等等。对于个人，衣着要干净整洁，仪表得体，笑口常开；与人交往，需热情真诚，以心换心，张弛有度；每个人都要树立自己的目标并为之计划，不断实践调整；对于金钱，取之有道，用之有度，节俭而不吝啬，合理消费，把钱花在刀刃上；对待工作要热忱，充满激情，看到背后的成长机会，不要一味地抱怨；对于婚姻，要相互坦诚，家人之间，鼓励永远比批评重要，还要经营好夫妻生活。

读完发现太难了，发现好多自己都没有做到。格物致知、修身齐家，做人永远是一个学问，一个难题。一时做到，却难保一世都能做到。这就需要不断地与自己博弈，不断地实践调整。人不可能听尽所有道理，每个人都有自己的知识盲区，适当的心灵鸡汤喝一喝，还是有耳目一新的感觉的。

对自己进行“盘点”，思考，适时调整自己，如能引发你如何经营自己一生的思考，那它便是成功的。成功对于每个人都可能有不同的定义，但无疑都是每个人的渴望。绝大多数人中没有人可以随随便便成功，我们大都是平凡人，我们如何做好自己？就像阿波罗登月一样，无法根据事先预测的弹道轨迹将飞船送往太空，而是在飞行过程中根据反馈不断调整自己，最终到达终点，完成了人月神话的伟大壮举。人亦是如此，面对未来，尤其是信息时代的今天，复杂可变的因素太多，根本无法考虑全部的可能性，所以，我们需要一个基点，那就是人生目标，根据目标不断地动态控制自己的心态和行为，经营好自己的人生，而不让自己偏离航道而走得越来越远。但是找到一个适合自己的人生目标，却不是一件容易的事情，有可能终其一生都在找寻自己的目标。那就对照自观吧，纸上得来终觉浅，我也一样，先写下这篇读后感，勉励一下自己。

附录贴下思维导图：

附录

把握人际交往的关键

把别人吸引到身边来

做好一生的规划

与金钱和睦相处

学会享受工作

营造幸福家庭

记一次Gitlab-CI集成K8S实录

Thu, 05 Nov 2020 11:43:25 CST

2019年号称云原生元年，企业全面上云，上云就上云原生。各大云厂商云原生事业如火如荼的进行着。Gitlab也不甘人后，很好的支持和构建云原生项目。部署环境的搭建和配置向来繁杂，云原生之前的年代，搭建和配置部署环境还存在大量人工而且重复地劳动，浪费了大量时间和精力在环境部署上，而且环境难以移植，微服务的兴起更是加剧了环境搭建和配置的难度，对运维也是一大挑战。容器及其编排技术因此而孕育而生，宿主环境的无感知，极易地扩缩容，容器技术存在巨大优势。但容器及其编排环境搭建本身也不是一件容易的事情，各种套件你方唱罢我登场。Iass、Pass层领域容器云环境搭建和维护成本问题都摆在那里，各大云厂商云原生事业才有了广阔的市场前景，都想在这一领域独占鳌头。Docker、Kubernetes、Harbor、Prometheus等集群环境不是本文关注的重点，这里只是记录Gitlab-CI集成K8S的试验，依赖现成的K8S集群环境，但曾经被还原过一次，导致一些配置丢失。CI集成K8S跟集成其他环境步骤相同，同样需要两步，第一步，安装Gitlab-Runner及注册授权，需要注意的是，需要选择Kubernetes执行器；第二步是还是编写.gitlab-ci.yaml文件，只是需要Docker等容器命令的相关知识。此外，由于Kubernetes是基于RBAC角色权限设计，需要有Kubernetes Service Account具有操纵K8S集群的权限。

Gitlab-ci绑定k8s集群

我们可以先手动一个K8S集群的集成，预置好具有对K8S集群有操纵权限的账号，供后续使用。

然后在K8S环境里准备好集群环境配置参数

API，URL 指向k8s集群地址

kubectl cluster-info | grep 'Kubernetes master' | awk '/http/ {print $NF}'

CA certificate，需要k8s认证

[root@wenqy gitlab]# kubectl get secretsNAME                  TYPE                                  DATA   AGEdefault-token-xxlhq   kubernetes.io/service-account-token   3      47d[root@wenqy gitlab]# kubectl get secret default-token-xxlhq -o jsonpath="{['data']['ca\.crt']}" | base64 --decode-----BEGIN CERTIFICATE-----MIICyDCCAbCgAwIBAgIBADANBgkqhkiG9w0BAQsFADAVMRMwEQYDVQQDEwprdWJl......gINmxCg80ZwsEXEUo8UE2ybYVd/GmhPShuW/UriJcj6Ncx9viX2EsyoviVU=-----END CERTIFICATE-----[root@wenqy gitlab]#

Token， K8S授予具有cluster-admin账号权限的token

K8S集群环境创建至少有container.clusterRoleBindings.create权限的账号

[root@wenqy gitlab]# cat gitlab-admin-service-account.yaml apiVersion: v1kind: ServiceAccountmetadata:  name: gitlab-admin  namespace: kube-system---apiVersion: rbac.authorization.k8s.io/v1beta1kind: ClusterRoleBindingmetadata:  name: gitlab-adminroleRef:  apiGroup: rbac.authorization.k8s.io  kind: ClusterRole  name: cluster-adminsubjects:- kind: ServiceAccount  name: gitlab-admin  namespace: kube-system[root@wenqy gitlab]# kubectl apply -f gitlab-admin-service-account.yamlserviceaccount/gitlab-admin createdclusterrolebinding.rbac.authorization.k8s.io/gitlab-admin created

K8S集群环境获取Token

[root@wenqy gitlab]# kubectl -n kube-system describe secret $(kubectl -n kube-system get secret | grep gitlab-admin | awk '{print $1}')Name:         gitlab-admin-token-xsknqNamespace:    kube-systemLabels:       Annotations:  kubernetes.io/service-account.name: gitlab-admin              kubernetes.io/service-account.uid: d67285d1-d538-11ea-ba67-000c29b409baType:  kubernetes.io/service-account-tokenData====ca.crt:     1025 bytesnamespace:  11 bytestoken:      eyJhbGciOiJSUzI1NiIsImtpZCI6IiJ9.eyJpc3MiOiJrdWJlcm5ldGVzL3NlcnZpY2VhY2NvdW50Iiwia3ViZXJuZXRlcy5pby9zZXJ2aWN......5qcaEOsXRuVrmG0hAHqVHpAvryuQ3CA[root@wenqy gitlab]#

如果出现is blocked: Requests to the local network are not allowed错误，需要用管理员账号开启配置，允许访问本地网络

填入上述参数后，创建成功

这一步可能不是必须的，需要注意是对哪个名称空间创建服务账号，需要部署在哪个名称空间下，否则可能导致部署失败

操作页面本身有链接参考

http://gitlab.wenqy.com/help/user/project/clusters/add_remove_clusters.md#add-existing-cluster

K8S安装Gitlab-Runner

安装Gitlab-Runner可以有多种形式，或者使用不同的执行器等等。这里采用Helm+Tiller的形式，直接将Gitlab-Runner部署到K8S集群中。

安装Helm

Helm是K8S的应用包管理器，主要用于 Kubernetes 应用程序 Chart 的创建、打包、发布以及创建和管理本地和远程的 Chart 仓库。Helm官方提供一键安装脚本

curl https://raw.githubusercontent.com/helm/helm/master/scripts/get > get_helm.sh$ chmod 700 get_helm.sh$ ./get_helm.sh

安装Tiller

Tiller是 Helm 的服务端，部署在 Kubernetes 集群中。Tiller 用于接收 Helm 的请求，并根据 Chart 生成 Kubernetes 的部署文件（Helm 称为 Release），然后提交给 Kubernetes 创建应用。官方Tiller镜像被墙，利用dockerhub第三方镜像打tag成官方镜像，可以推送到私有镜像仓库，或者找国内的源

docker pull fishead/gcr.io.kubernetes-helm.tiller:v2.12.3docker tag fishead/gcr.io.kubernetes-helm.tiller:v2.12.3 gcr.io/kubernetes-helm/tiller:v2.12.3

helm部署Tiller

helm init --service-account tiller --tiller-image gcr.io/kubernetes-helm/tiller:v2.12.3 --skip-refresh

使用国内源

helm init --service-account tiller --upgrade -i registry.cn-hangzhou.aliyuncs.com/google_containers/tiller:v2.12.3  --stable-repo-url https://kubernetes.oss-cn-hangzhou.aliyuncs.com/charts

查看Tiller是否部署成功

kubectl get pods -n kube-system|grep tiller

如果出现ImagePullBackOff

[root@wenqy gitlab]# kubectl get pods -n kube-system|grep tillertiller-deploy-85d786df69-l6ch4            0/1     ImagePullBackOff   0          12d

可以先拉取tiller镜像到本地，编辑配置文件，把拉取策略改为imagePullPolicy:Never，只从本地拉取

#使用命令编辑配置，IfNotPresent ：如果本地存在镜像就优先使用本地镜像kubectl edit deployment tiller-deploy -n kube-system

重启Tiller pod

kubectl get pods -n kube-system|grep tillerkubectl get pod tiller-deploy-d87494c4-qnr7t -n kube-system -o yaml | kubectl replace --force -f -

给Tiller授权

创建 Kubernetes 的服务帐号和绑定角色

kubectl create serviceaccount --namespace kube-system tillerkubectl create clusterrolebinding tiller-cluster-rule --clusterrole=cluster-admin --serviceaccount=kube-system:tiller

使用 kubectl patch 更新 API 对象

kubectl patch deploy --namespace kube-system tiller-deploy -p '{"spec":{"template":{"spec":{"serviceAccount":"tiller"}}}}'

查看是否授权成功

kubectl get deploy --namespace kube-system   tiller-deploy  --output yaml|grep  serviceAccount

查看是否安装成功

[root@wenqy gitlab]# helm versionClient: &version.Version{SemVer:"v2.16.1", GitCommit:"bbdfe5e7803a12bbdf97e94cd847859890cf4050", GitTreeState:"clean"}Server: &version.Version{SemVer:"v2.16.1", GitCommit:"bbdfe5e7803a12bbdf97e94cd847859890cf4050", GitTreeState:"clean"}

安装Gitlab-Runner

准备url、token等信息

准备Helm values.yaml配置，注意填写gitlabUrl、token、tag、harbor secret和hostAliases等信息或者限制资源

imagePullPolicy: IfNotPresentgitlabUrl: http://gitlab.wenqy.com/runnerRegistrationToken: "aYT_P3W8qddRy6hpFf7a"terminationGracePeriodSeconds: 3600concurrent: 10checkInterval: 30rbac:  create: false  clusterWideAccess: false  # serviceAccountName: default  podSecurityPolicy:         enabled: false    resourceNames:            - gitlab-runnermetrics:                                                                                                       enabled: truerunners:  image: ubuntu:18.04  tags: "k8s-runner"  privileged: true  pollTimeout: 180  outputLimit: 4096  cache: {}  builds: {}  services: {}  helpers: {}securityContext:  fsGroup: 65533  runAsUser: 100resources: {}affinity: {}nodeSelector: {}tolerations: []hostAliases:                                                                                                 - ip: "192.168.1.106"    hostnames: ["dockerhub.wenqy.com"]                                                                       podAnnotations: {}podLabels: {}

由于K8S集群环境没有配置VPC，这里没有开启缓存，需要注意的是，使用docker in docker构建镜像时privileged必须为true，开启特权模式，即privileged: true，否则会报无法连接docker daemon的错误，开启特权意味着Pod对docker的资源限制可能失效

参考

https://gitlab.com/gitlab-org/charts/gitlab-runner/-/blob/master/values.yaml

这里总是按照最新的Gitlab-runner版本，利用Helm安装Gitlab-runner

helm repo add gitlab https://charts.gitlab.iohelm install --namespace gitlab --name gitlab-runner -f  values.yaml gitlab/gitlab-runner

如果提示报错:

[root@wenqy gitlab]# helm install --namespace gitlab --name gitlab-runner -f values.yaml gitlab/gitlab-runnerError: Could not get apiVersions from Kubernetes: unable to retrieve the complete list of server APIs: metrics.k8s.io/v1beta1: the server is currently unable to handle the request

删除无用api，再次安装Gitlab-Runner

[root@wenqy gitlab]# kubectl get apiserviceNAME                                   SERVICE                      AVAILABLE                  AGEv1beta1.extensions                     Local                        True                       47dv1beta1.metrics.k8s.io                 kube-system/metrics-server   False (MissingEndpoints)   47dv2beta2.autoscaling                    Local                        True                       47d[root@wenqy gitlab]# kubectl delete apiservice v1beta1.metrics.k8s.ioapiservice.apiregistration.k8s.io "v1beta1.metrics.k8s.io" deleted

查看Gitlab-Runner pod状态

kubectl describe pod gitlab-runner-gitlab-runner-9ffb46694-d62rc -n gitlab

校验Gitlab-Runner是否成功

[root@wenqy gitlab]# kubectl get pod -n gitlabNAME                                          READY   STATUS    RESTARTS   AGEgitlab-runner-gitlab-runner-9ffb46694-d62rc   1/1     Running   0          27m

回到gitlab，gitlab-runner出现绿色实心圈，说明注册成功了

CI流水线

变量定义

编写.gitlab-ci.yaml文件前，可以先定义一些变量，保存kubeConfig或者私有镜像仓库的账号信息等等

获取kube_config编码串，定义到变量中，利用kube_config访问集群，在deploy阶段可有用

echo $(cat ~/.kube/config | base64) | tr -d " "

gitlab-ci部署阶段，将编码串解码写入配置

variables:  KUBECONFIG: /etc/deploy/config  ....deploy_k8s_job:  image: dockerhub.wenqy.com/gitlab/kubectl:1.0.0  stage: deploy_k8s  tags:    - k8s-runner  before_script:    - mkdir -p /etc/deploy    - echo $kube_config |base64 -d > $KUBECONFIG

如果Gitlab-ci绑定k8s集群使用的Service Account对指定的namespace拥有create权限的话，是可以跳过这步kube_config配置的。

重新分配Service Account

由于k8s环境被人还原过一次，很多配置都丢失了，gitlab-ci绑定的Service Account不一致，gitlab-ci报错：

ERROR: Job failed (system failure): pods is forbidden: User "system:serviceaccount:gitlab:default" cannot create resource "pods" in API group "" in the namespace "gitlab"

新增namespace为gitlab,name为default的Service Account

# Source: gitlab-runner/templates/service-account.yamlapiVersion: v1kind: ServiceAccountmetadata:  name: default  namespace: gitlab---# Source: gitlab-runner/templates/role.yamlapiVersion: rbac.authorization.k8s.io/v1kind: "ClusterRole"metadata:  name: default  namespace: gitlabrules:- apiGroups: ["*"]  resources: ["*"]  verbs: ["*"]---# Source: gitlab-runner/templates/role-binding.yamlapiVersion: rbac.authorization.k8s.io/v1kind: "ClusterRoleBinding"metadata:  name: default  namespace: gitlabroleRef:  apiGroup: rbac.authorization.k8s.io  kind: "ClusterRole"  name: defaultsubjects:- kind: ServiceAccount  name: default  namespace: gitlab

删除原有gitlab-runner

[root@wenqy gitlab]# helm lsNAME            REVISION        UPDATED                         STATUS          CHART                   APP VERSION     NAMESPACEgitlab-runner   1               Mon Aug  3 18:11:11 2020        DEPLOYED        gitlab-runner-0.19.1    13.2.1          gitlab   [root@wenqy gitlab]# helm del --purge gitlab-runner

可以修改values.yaml，添加serviceAccountName属性，指定gitlab-runner使用Service Account账号角色权限操纵

runners:  serviceAccountName: default

参考

https://gitlab.com/gitlab-org/gitlab-runner/-/issues/3841

重建Gitlab-Runner,可以指定Gitlab-Runner版本

helm install --namespace gitlab --name gitlab-runner -f  values.yaml gitlab/gitlab-runner --version 0.14.0

分配imagePullSecrets

重新注册Gitlab-Runner后，gitlab-ci报错，无法拉取自定义镜像

 ERROR: Job failed (system failure): prepare environment: image pull failed: rpc error: code = Unknown desc = Error response from daemon: pull access denied for xxxxxxx/gitlab/maven_deps, repository does not exist or may require 'docker login'. Check https://docs.gitlab.com/runner/shells/index.html#shell-profile-loading for more information

可以暂时先在K8S集群宿主机里手动拉取私服上的自定义镜像，默认拉取策略是IfNotPresent，优先从本地拉取，而出现问题原因没有配置拉取镜像的秘钥，指向docker registry的域名映射，在values.yaml分配秘钥，重新安装Gitlab-Runner

runners:                                                                                                     imagePullSecrets:["harbor-secret"]hostAliases:                                                                                                 - ip: "192.168.181.106"    hostnames: ["dockerhub.wenqy.com"]

开启特权模式

继续执行gitlab-ci流水线，问题来到了下面：

68 $ docker login -u $REGISTRY_USERNAME -p $REGISTRY_PASSWORD dockerhub.wenqy.com69 WARNING! Using --password via the CLI is insecure. Use --password-stdin.70 time="2020-08-03T10:47:18Z" level=info msg="Error logging in to v2 endpoint, trying next endpoint: Get https://dockerhub.wenqy.com/v2/: dial tcp xx.xx.xx.xx:443: connect: connection refused"71 Get https://dockerhub.wenqy.com/v2/: dial tcp xx.xx.xx.xx:443: connect: connection refused72 ERROR: Job failed: command terminated with exit code 1

这次在k8s集群环境还原之前，出现过类似问题，当时是docker in docker版本问题所导致，采用版本降级处理。那现在为什么不行了呢？因为使用的docker image是stable,稳定版可能升级了，我把矛头还是指向了docker版本问题，使用具体的低版本，还在docker login之前使用docker info，还是出现问题：

docker: Cannot connect to the Docker daemon at tcp://docker:2375. Is the docker daemon running?.

太多人碰到了这个问题，官方文档为此都出了故障排除集锦。问题虽已解决过，还是纠结于其中。基础环境已经一致，应当刹车才对。查看官方文档，docker-dind需要开启特权模式。由于k8s环境还原，helm values.xml文件也丢失了，凭借印象，还特地把privileged改为false，不知其所以然，实在是尴尬。按照说法，docker需要挂载/var/run/docker.sock与docker daemon通信，docker容器内默认是普通用户权限，这时需要提升到root权限。

# values.yamlrunners:               privileged: true

特权模式也可能带来相应的安全隐患，据官网说法还可能带来一定的性能损失，docker-dind应该不是一个值得推荐的build方式。另外一种是使用google的kaniko，但由于众所周知的The Great Firewall of China，kaniko是被屏蔽的。知识终究是有国界的，因为知识最终是以人为载体的。可以考虑第三方kaniko，这里不做尝试。

参考

https://docs.gitlab.com/runner/executors/kubernetes.html#configuring-executor-service-account

https://docs.gitlab.com/ee/ci/docker/using_docker_build.html#use-docker-in-docker-workflow-with-docker-executor

kube_config配置

因为使用了自定义变量kube_config配置，k8s环境还原后，配置已然不对，导致报错：

unable to recognize "deployment.yaml": Get https://192.168.1.141:6443/api?timeout=32s: x509: certificate signed by unknown authority (possibly because of "crypto/rsa: verification error" while trying to verify candidate authority certificate "kubernetes")

在k8s宿主机上重新获取配置，定义变量值，解决问题

sudo cp -i /etc/kubernetes/admin.conf $HOME/.kube/configecho $(cat ~/.kube/config | base64) | tr -d " "

自定义镜像

由于没有启动缓存，项目每次构建时需要从阿里云私服下载依赖都非常慢，先迫不得已做个妥协，做一个黑盒镜像，先把依赖缓存到镜像，在推送到镜像私服上去，加快构建步骤，这步并不是必须的。

docker run it maven:3.6.2-jdk-14 sh# 容器内创建maven工程，跑pommvn -s ci_settings.xml --batch-mode package -B -DskipTests# 退出容器后提交一个新的镜像docker psdocker commit 065b4f9d20ac maven_deps:3.6.2-jdk-14docker tag  maven_deps:3.6.2-jdk-14 dockerhub.wenqy.com/gitlab/maven_deps:3.6.2-jdk-14

docker:dind版本问题

因为之前说过docker in docker 版本问题，在构建应用镜像的阶段也会导致下面错误：

docker: Cannot connect to the Docker daemon at tcp://docker:2375. Is the docker daemon running?.

问题的原因在于docker:dind的19.03版本以后，默认会开启TLS通信，由于k8s集群环境没有开启TLS，需要关闭TLS，或者降级dind版本到18.09。

关闭TLS

将TLS证书目录路径设空DOCKER_TLS_CERTDIR: ''

docker_build_job:  #image: docker:stable  image: docker:19.03.0  stage: docker_build  variables:    DOCKER_DRIVER: overlay2    DOCKER_TLS_CERTDIR: ''    #CI_DEBUG_TRACE: "true"  services:    - name: docker:19.03.0-dind

降级版本

将docker:dind版本降级到18.09

docker_build_job:  image: docker:18.09.7  stage: docker_build  variables:    DOCKER_DRIVER: overlay2    DOCKER_HOST: tcp://localhost:2375    #CI_DEBUG_TRACE: "true"  services:    - name: docker:18.09.7-dind      entrypoint: ["dockerd-entrypoint.sh"]      command: ["--insecure-registry", "dockerhub.wenqy.com"]

因为Harbor Registry服务器是开启Https的，需要设置insecure-registry参数，在Https不可用的情况下，docker可以回退到http。否则可能会出现x509等类似的问题。

WARNING! Using --password via the CLI is insecure. Use --password-stdin. time="2020-04-02T04:09:23Z" level=info msg="Error logging in to v2 endpoint, trying next endpoint: Get https://dockerhub.wenqy.com/v2/: x509: certificate is valid for www.wenqy.com, wenqy.com, not dockerhub.wenqy.com" Get https://dockerhub.wenqy.com/v2/: x509: certificate is valid for www.wenqy.com, wenqy.com, not dockerhub.wenqy.com

指定node运行

因为k8s环境是别人的，只是挂了一个节点到k8s环境，k8s环境还原后，node节点label信息也丢失了，匹配不到node节点运行pod

Events:  Type     Reason            Age                From               Message  ----     ------            ----               ----               -------  Warning  FailedScheduling  13m (x3 over 13m)  default-scheduler  0/3 nodes are available: 3 node(s) didn't match node selector.

k8s利用label标签来绑定到特定node运行pod

[root@wenqy .kube]# [root@wenqy .kube]# kubectl get nodes --show-labelsNAME              STATUS   ROLES    AGE   VERSION   LABELSwenqy   Ready    master   49d   v1.13.2   beta.kubernetes.io/arch=amd64,beta.kubernetes.io/os=linux,kubernetes.io/hostname=wenqy,node-role.kubernetes.io/master=harbornode01         Ready       49d   v1.13.2   beta.kubernetes.io/arch=amd64,beta.kubernetes.io/os=linux,kubernetes.io/hostname=harbornode01,vsftp=ftpharbornode03         Ready       49d   v1.13.2   beta.kubernetes.io/arch=amd64,beta.kubernetes.io/os=linux,kubernetes.io/hostname=harbornode03[root@wenqy .kube]#  [root@wenqy .kube]# kubectl label nodes harbornode03 disktype=ssdnode/harbornode03 labeled[root@wenqy .kube]# kubectl get nodes --show-labelsNAME              STATUS   ROLES    AGE   VERSION   LABELSwenqy   Ready    master   49d   v1.13.2   beta.kubernetes.io/arch=amd64,beta.kubernetes.io/os=linux,kubernetes.io/hostname=wenqy,node-role.kubernetes.io/master=harbornode01         Ready       49d   v1.13.2   beta.kubernetes.io/arch=amd64,beta.kubernetes.io/os=linux,kubernetes.io/hostname=harbornode01,vsftp=ftpharbornode03         Ready       49d   v1.13.2   beta.kubernetes.io/arch=amd64,beta.kubernetes.io/os=linux,disktype=ssd,kubernetes.io/hostname=harbornode03

指定node运行pod

#deployment.yamlspec:  ...  template:    ...    spec:      nodeSelector:        disktype: ssd # lable 指定node节点跑

K8s生成Secrets

CI流水线成功部署，pod启动出现ImagePullBackOff，报错详情提示需要docker login

k8s还原，secret也丢失了，创建secret，指定名称空间

[root@wenqy .kube]# kubectl create secret docker-registry harbor-secret --docker-server=dockerhub.wenqy.com --docker-username=gitlab --docker-password=Gitlab123456 -n gitlabsecret/harbor-secret created[root@wenqy .kube]# kubectl  get secretNAME                  TYPE                                  DATA   AGEdefault-token-xxlhq   kubernetes.io/service-account-token   3      49dharbor-secret         kubernetes.io/dockerconfigjson        1      7s[root@wenqy .kube]#

资源限制

k8s环境资源有限，还是借挂节点，需要对CPU、memory等资源进行限制，防止对集群的崩溃

spec:  ...  template:    ...    spec:      ...      containers:      - name: springboot-hsf-test        image: dockerhub.wenqy.com/gitlab/springboot-hsf-test:IMAGE_TAG        imagePullPolicy: Always        resources: #资源管理          requests: #容器运行时，最低资源需求，也就是说最少需要多少资源容器才能正常运行            cpu: 0.1 #CPU资源（核数），两种方式，浮点数或者是整数+m，0.1=100m，最少值为0.001核（1m）            memory: 1024Mi #内存使用量          limits: #资源限制            cpu: 0.5            memory: 2048Mi

查看logs

继续，还是出现CrashLoopBackOff，项目启动失败，查看日志

kubectl logs springboot-hsf-test-89775f989-tt65l -n gitlab

java启动报错，出现打开jar zip流报错，判断依赖jar包损坏，项目采用阿里云hsf框架jar形式构建，项目启动需要指定Pandora容器的位置，构建docker镜像时，需要从Nginx服务器中拉取Pandora sar包，域名和Nginx转发规则有被人改过，无法下载sar包，到此，发现原因，将sar包传至正确的域名指向位置

配置ingress

流水线执行成功，成功部署至k8s，直接访问内网IP健康检查地址，说明项目启动成功

[root@wenqy ~]# kubectl get pod -n gitlab -o wideNAME                                          READY   STATUS    RESTARTS   AGE     IP           NODE        NOMINATED NODE   READINESS GATESgitlab-runner-gitlab-runner-df75bf48d-wg644   1/1     Running   0          16h     10.96.1.55   harbornode01              springboot-hsf-test-54cd4ff877-7n8sp          1/1     Running   0          9m50s   10.96.2.56   harbornode03              [root@wenqy ~]# [root@wenqy ~]# curl 10.96.2.56:18081/healthok[root@wenqy ~]#

配置项目K8S Service类型为ClusterIP，通过集群的内部 IP 暴露服务，服务只能够在集群内部可以访问，这也是默认的 ServiceType

#deployment.yaml---apiVersion: v1kind: Servicemetadata:  name: springboot-hsf-testspec:  ports:  - port: 18081    targetPort: 18081    name: springboot-hsf-test  selector:    app: springboot-hsf-test  type: ClusterIP

利用Ingress暴露服务给外部，相当于外部负载均衡器，配置网址映射规则和路径匹配会路由到一个或多个后端服务。

[root@wenqy gitlab]# cat ingress.yaml apiVersion: extensions/v1beta1kind: Ingressmetadata:  name: gitlab-ingress  namespace: gitlab  annotations:    nginx.ingress.kubernetes.io/rewrite-target: /spec: rules: - host: busi.com   http:     paths:     - path: /springboot-hsf-test       backend:         serviceName: springboot-hsf-test         servicePort: 18081[root@wenqy gitlab]# kubectl apply -f ingress.yaml

host配置为域名，不能配置为IP，会报错

[root@wenqy gitlab]# kubectl get ingress -n gitlabNAME             HOSTS      ADDRESS   PORTS   AGEgitlab-ingress   busi.com             80      25m[root@wenqy gitlab]# kubectl describe ingress gitlab-ingress -n gitlabName:             gitlab-ingressNamespace:        gitlabAddress:          Default backend:  default-http-backend:80 ()Rules:  Host      Path  Backends  ----      ----  --------  busi.com              /springboot-hsf-test   springboot-hsf-test:18081 ()Annotations:  kubectl.kubernetes.io/last-applied-configuration:  {"apiVersion":"extensions/v1beta1","kind":"Ingress","metadata":{"annotations":{"nginx.ingress.kubernetes.io/rewrite-target":"/"},"name":"gitlab-ingress","namespace":"gitlab"},"spec":{"rules":[{"host":"busi.com","http":{"paths":[{"backend":{"serviceName":"springboot-hsf-test","servicePort":18081},"path":"/springboot-hsf-test"}]}}]}}  nginx.ingress.kubernetes.io/rewrite-target:  /Events:  Type    Reason  Age   From                      Message  ----    ------  ----  ----                      -------  Normal  CREATE  25m   nginx-ingress-controller  Ingress gitlab/gitlab-ingress

本机配置DNS，修改/etc/hosts配置

192.168.1.142 busi.com

用域名访问健康检查URL，成功

[root@wenqy gitlab]# curl busi.com/springboot-hsf-test/healthok[root@wenqy gitlab]#

如果有部署类似360开源的wayne这种devops部署平台或者Kubernetes 的DashBoard，可以在管理平台直接创建ingress，进行路由

运行结果

流水线最终运行效果

Pineline执行完后，构建镜像推送到私有仓库，登录Harbor查看

访问健康检查URL也返回正确结果，项目已经在k8s集群环境中启动成功。

我们可以自建Maven私服、镜像私服等减少网络带来的延迟进行优化等等。测试环境暂且告一段落了，这里也可以推送部署到阿里云容器服务等第三方云服务厂商

总结

Gitlab CI将应用自动化部署到K8S集群环境步骤还是简单的，但与K8S环境的对接过程还是有点曲折，基础镜像被还原，由于问题和数据没有及时的记录、备份、整理和理解，让人措手不及，凭借对当时的印象和模糊经验，可能反而让你记忆混淆，南辕北辙。英语烂，不解其意，知识储备和理解不够也是问题出现的根源。需要及时总结出现的问题和解决方案，好记性不如烂笔头，需要形成自己的知识库，一知半解的东西更需要记录和备忘，以待备查。Gitlab-Runner版本、docker版本间可能存在较大的差异，需要甄别版本特性，不要使用latest或stable版本，防止自动升级导致意外。提醒我们版本应保持向后兼容，实在重大版本无法兼容，应提供升级方案或者版本回退方案。虽然历史不是简单的重复，但是人总是踏入同一条错误的河流，不然，错误为什么无法避免，战争为何无法避免。

测试项目和资料：https://github.com/wenqy/springboot-hsf-test

参考

https://help.aliyun.com/document_detail/99943.html?spm=a2c4g.11186623.6.618.69556f171qQLGo

https://docs.docker.com/registry/insecure/#deploy-a-plain-http-registry

https://gitlab.com/gitlab-org/gitlab-runner/-/tree/master/

https://help.aliyun.com/document_detail/106968.html?spm=5176.11065259.1996646101.searchclickresult.15237c2bLJVndo 使用GitLab CI在Kubernetes服务上运行GitLab Runner并执行Pipeline

https://about.gitlab.com/releases/2019/07/31/docker-in-docker-with-docker-19-dot-03/ Update: Changes to GitLab CI/CD and Docker in Docker with Docker 19.03

https://docs.gitlab.com/ee/ci/docker/using_docker_build.html#docker-cannot-connect-to-the-docker-daemon-at-tcpdocker2375-is-the-docker-daemon-running

https://kubernetes.io/zh/docs/concepts/services-networking/ingress/

https://kubernetes.io/zh/docs/concepts/services-networking/service/

http://360yun.org/wayne/

https://github.com/cnych/gitlab-ci-k8s-demo

https://gitee.com/linlion/gitlab-docker-k8s

Gitlab-CI初识

Wed, 04 Nov 2020 20:21:45 CST

GitLab CI (Continuous Integration)是GitLab内置的进行持续集成的工具。基于特征分支开发后，需要发起Merge Requests合并共享代码库。Merge Requests总是频繁发生，合并请求过来后，可以触发流水线自动去构建、测试、验证新代码功能，及早发现错误，减少集成问题。我们也总是希望在任何时候都能发布稳定版本的软件，自动推送功能变更到演示环境，甚至是生产环境，完成持续地交付（Continuous Delivery）和部署（Continuous Deployment），以减少部署带来的风险和及时得到客户的反馈。通过Gitlab CI减少了人为错误的机会和跨团队沟通成本，提高整个团队的效率。

GitLab CI/CD作为Gitlab整个DevOps生命周期的重要组成部分，对应用的构建、测试、部署和监控都起到重要作用。对于Docker、Kubernetes等容器化技术有着天然的集成，简直就是为云原生而生。

对于Gitlab项目集成CI/CD很容易上手，像之前【Gitlab概览】提到过的那样，只需两个步骤：1、安装Gitlab-Runner及配置，2、工程目录下创建和编写.gitlab-ci.yaml文件。

Gitlab-Runner

GitLab-Runner是一个Go语言编写的开源项目，用于运行Job并将结果发送回GitLab，它与GitLab CI/CD一起，协调持续集成服务。它能部署到任何一个地方、任何一个平台，只要它能ping通Gitlab。多个项目可以使用同一个Gitlab-Runner，一个项目也可以使用多个Gitlab-Runner，而Gitlab-Runner还可以并发地执行多个Job，它是灵活的，减轻了Gitlab构建项目的负担。Gitlab-Runner对Docker、Kubernetes的等天然支持，使得项目与容器云服务有很好的集成。

Gitlab-Runner类型

主要有三种类型的Runner:Shared、Group 、Specific。

Shared Runners	适用于所有应用，且只有系统管理员能够创建
Create a group Runner	项目组下的所有应用，具有组权限的人才能创建
Specific Runners	特定项目使用

我们可以用管理员账号登录，注册Shared Runner

安装Gitlab-Runner

安装Gitlab-Runner的版本要注意与Gitlab的版本一致。可能由于新版本引入新功能特性或者Bug，存在版本差异，版本不一致可能造成无法预知的后果。

以CentOS7，Shell执行器为例，可以利用官方的一键脚本安装最新版本的Gitlab-Runner

# For RHEL/CentOS/Fedoracurl -L https://packages.gitlab.com/install/repositories/runner/gitlab-runner/script.rpm.sh | sudo bash

也可以使用软件源，安装特定版本，注意修改软件源

# For RHEL/CentOS/Fedorasudo yum install gitlab-runner# for RPM based systemsyum list gitlab-runner --showduplicates | sort -rsudo yum install gitlab-runner-10.0.0-1

安装时会自动创建Gitlab-Runner的用户，并用这个用户账号运行CI任务。需要注意权限问题。对应Linux root用户，Runner使用的默认配置路径/etc/gitlab-runner/config.toml，对于修改配置，如，并发数参数等，大多数选项，可以不需要重启。默认每5分钟检查一次文件，自动获取所有更改。

Gitlab-Runner注册

Gitlab-Runner拉取Gitlab代码需要授权，这时需要注册URL和Token。以CentOS7，Shell执行器为例，键入命令

#sudo gitlab-ci-multi-runner registersudo gitlab-runner register

按步骤，交互式访问需要依次输入GitLab URL、Gitlab token、Description for the Runner、Tags associated with the Runner、Runner executor等等。非容器化项目，Executor这里选Shell，如果想将项目部署到容器，可以选择相应的Docker、Kubernetes执行器。而利用Tags可以指定项目运行的Gitlab-Runner。URL和Token可以在Gitlab上分配，以Specitic Runner为例

注册成功后，运行Gitlab-Runner

gitlab-runner run

当出现绿色实心圈则表示Gitlab-Runner注册成功，而且正在运行。这时，只要在项目下编写.gitlab-ci.yaml文件就可以啦

编写.gitlab-ci.yml

GitLab CI使用YAML文件(.gitlab-ci.yml)来管理项目配置。默认存放于项目仓库的根目录，它包含了项目如何被编译的描述语句。YAML文件使用一系列约束定义了Job启动时所要做的事情。

如果.gitlab-ci.yml未指定Runner的tag，可能一直处于Pending状态，这时，可以编辑Runner配置，勾上Run untagged jobs。

Pipelines是整个Gitlab CI最顶层的组件，是一个分成不同阶段(Stage)的作业(Job)的集合。每个推送到 Gitlab 的提交都会产生一个与该提交关联的Pipeline，若一次推送包含了多个提交，则Pipeline与最后那个提交相关联。我们很容易利用每个Pipeline的ID标识做资源隔离，或者作为镜像的版本等等。根据配置可以展现出不同类型的Pipeline，可能是有向无环图(DAG)的，可能是父子结构的等等。

以Java Maven Jar项目为例，通常包含package、test、deploy这三个步骤。先上效果图：

Gitlab CI Pipeline定义了Stage这个阶段概念，对批量的作业进行了一个逻辑上划分。多个Stage间是顺序执行的，一个 Stage失败，后续的 Stage不会被执行，整个 CI 过程会被认为失败。

stages:  - build  - test  - deploy

上述Maven样例中整个 CI 环节包含三个Stage：build、test 和deploy。分别对应maven的打包、测试、部署阶段。其中一个阶段失败，都会导致后面的阶段不可用。

Job是Runner要执行的指令集合，Job 可以被关联到一个Stage，一个Stage可能包含多个Job 。当一个Stage执行的时候，与其关联的所有Job都会被执行。同一个Stage下的Job是可以并发执行的，至于并发能力，这取决于Runner配置的并发数和服务器并行能力。

从官网截了一个图出来，比较直观，Stage间是串行的，同个Stage下Job间是并行的。

我们可以先看下deploy Job的描述片段：

deploy:  stage: deploy  script:    - mvn $MAVEN_CLI_OPTS deploy  only:    - master

Job包含script，一段由Runner执行的shell脚本。在script中，对于直接定义|、>等管道和重定向的shell复合命令，有可能会出现莫名问题，需要甄别。我们可以定义before_script，after_script来辅助Job执行script前后需要准备或者收尾的事情。

#定义全局 before_script:default:  before_script:    - global before script#覆盖全局before_scriptjob:  before_script:    - execute this instead of global before script  script:    - my command  after_script:    - execute this after my script

对于多个Job，有些步骤可能是重复的，如Maven的打包和测试阶段都需要寻找依赖，这时，可以利用缓存机制，将依赖缓存下来，加快Job的执行时间。

variables:  MAVEN_CLI_OPTS: "-s ci_settings.xml --batch-mode"  MAVEN_OPTS: "-Dmaven.repo.local=.m2/repository"  cache:  paths:    - .m2/repository/    - target/

很多时候我们并不希望每次push都触发Pipeline，希望定义触发规则还触发Pipeline，我们可能希望指定某个分支，或者以分支名正则关联，或者排除某些分支，或者某个变量的值，或者某个commit的信息，或者某一类代码的变化，或者希望手动触发，或者定时触发，甚至是自定义触发规则等等。这时我们可以利用only和except定义怎么触发Pipeline。

  only:    refs:      - branches    variables:      - $ENABLE_VERIFY == "true"    changes:      - "**/*.java"

在编辑.gitlab-ci.yaml文件中可以使用预置的变量，如：$CI_PIPELINE_ID表示正在构建的PipelineID，可以在script中使用这个变量。将预置变量CI_DEBUG_TRACE值设为true，则进入debug模式，将打印更多的CI日志。

  variables:    CI_DEBUG_TRACE: "true"

我们有可能需要Gitlab-Runner生成的结果回传给Gitlab，提供下载。

  artifacts:    #expire_in: 1 week    paths:      - target/*.jar

如果上传打包太大会报错:

ERROR: Uploading artifacts to coordinator... too large archive  id=407 responseStatus=413 Request Entity Too Large status=413 Request Entity Too Large token=EQ-TLvUS FATAL: too large

需要调整允许上传附件的最大大小

修改/etc/gitlab/gitlab.rbGitlab配置，将client_max_body_size值设为0，表示不限制大小

nginx['client_max_body_size'] = 0

我们有可能引入手动，以便更好的控制部署，有时候会只希望负责人手动批准，触发任务部署。

  when: mannual  allow_failure: false

对于微服务这种项目，我们可能还要打通上下游项目，需要触发多项目的Pipeline。而且多个项目间权限不同，有可能还需要引入批准步骤等等，这些高级特性还有待挖掘。语法中还有模板的功能，这些就详见官方文档了。

以Shell为执行器的Gitlab Runner服务器，在运行Maven Job时，需要提前准备JDK\Maven环境。万事俱备之后，Push代码后，直接自动触发Pipeline。

值得注意的是，Gitlab Runner跑Pipeline拉取代码到仓库构建目录，存在一定规则：

/$RUNNER_TOKEN_KEY/$CONCURRENT_ID/$NAMESPACE/$PROJECT_NAME

我们也很容易从Pipeline的日志里看出端倪:/etc/profile.d/builds/53GgNRQd/0/wenqy/simple-maven-dep

配置邮箱后，构建失败会发起邮箱通知：

此外YAML格式文件编写还是易出错的，Gitlab嵌入了校验.gitlab-ci.yml内容格式的调试工具，还是比较人性化的。

总之，Gitlab项目要启用CI/CD还是相当容易，.gitlab-c.yaml文件提供了很大的灵活度，可以根据具体项目的需要定制属于自己团队特殊的CI/CD，Gitlab CI/CD无疑为团队的整个效益提供一大助力，为敏捷开发提供了支持。

参考

https://about.gitlab.com/stages-devops-lifecycle/continuous-integration/

https://docs.gitlab.com/ee/ci/quick_start/

https://docs.gitlab.com/runner/install/linux-repository.html

https://docs.gitlab.com/runner/install/kubernetes.html

https://docs.gitlab.com/runner/commands/README.html

https://docs.gitlab.com/ee/ci/runners/#using-tags

https://docs.gitlab.com/ee/ci/yaml/README.html

https://docs.gitlab.com/ee/ci/examples/artifactory_and_gitlab/

https://gitlab.com/gitlab-org/gitlab/-/blob/master/lib/gitlab/ci/templates/Maven.gitlab-ci.yml

https://gitlab.com/gitlab-org/gitlab/-/pipelines/177402875

Gitlab安装及使用

Tue, 03 Nov 2020 22:40:10 CST

Gitlab是基于Ruby on Rails开源的项目管理和代码托管平台，可以很方便的管理公司私有库，所以通常是自建Gitlab。下面来看下Gitlab服务的安装。

官方硬件需求至少需要4GB内存。在CentOS 7安装为例，安装Gitlab。

安装配置依赖包

Gitlab服务需要系统防火墙打开HTTP, HTTPS 和 SSH访问。这些依赖通常是通用的，运维人员可能已经安装好

sudo yum install -y curl policycoreutils-python openssh-serversudo systemctl enable sshdsudo systemctl start sshdsudo firewall-cmd --permanent --add-service=httpsudo firewall-cmd --permanent --add-service=httpssudo systemctl reload firewalld

安装邮局服务

我们可以安装Postfix进行邮件通知，注意DNS解析。如果安装有其他邮局服务，可以跳过。此外，安装Gitlab后，还需配置smtp。

sudo yum install postfixsudo systemctl enable postfixsudo systemctl start postfix

安装Gitlab软件包

我们可以使用官方提供的一键脚本安装包，安装最新稳定版

//输出到文件里是为了看下下载的脚本内容curl https://packages.gitlab.com/install/repositories/gitlab/gitlab-ee/script.rpm.sh > rpm.shchmod +x rpm.sh./rpm.sh

或者在线下载官方包进行安装

wget -O gitlab.rpm https://packages.gitlab.com/gitlab/gitlab-ce/packages/el/7/gitlab-ce-12.10.4-ce.0.el7.x86_64.rpm/download.rpmrpm -ivh gitlab.rpm#可以查看安装了哪些的文件，看到gitlab安装在/opt/gitlab目录下#rpm -ql gitlab-ce-12.10.4-ce.0.el7.x86_64

也可以使用软件源安装

# 配置yum源cat << EOF >> /etc/yum.repos.d/gitlab-ce.repo[gitlab-ce]name=gitlab-cebaseurl=http://mirrors.tuna.tsinghua.edu.cn/gitlab-ce/yum/el6Repo_gpgcheck=0Enabled=1Gpgkey=https://packages.gitlab.com/gpg.keyEOF#更新本地yum缓存sudo yum makecache#安装Gitlab-ce社区版sudo yum install gitlab-ce        #自动安装最新版sudo yum install gitlab-ce-x.x.x    #安装指定版本

我们还可以将gitlab安装在docker、kubernetes等容器服务里

修改配置

默认配置文件路径：/etc/gitlab/gitlab.rb，修改配置后，需要重启服务方可生效。

配置URL

external_url 'http://gitlab.wenqy.com:80'nginx['listen_port'] = 80

默认nginx 监听的是80 端口，如果nginx 修改端口，external_url 里面也必须带端口。gitlab安装内置默认用户root，首次访问external_url时，需要root用户登陆，设置密码。如果配置不修改重启，可能会出现502错误。

配置unicorn端口

unicorn是Ruby语言领域的一款http server软件。默认端口是8080。如果是非独享服务器，Tomcat默认端口也是8080，容易发生端口占用冲突，也会导致502错误。此时，可以需要unicorn端口。

unicorn['port'] = 8901

配置SSH

新暴露了ssh的端口8902

gitlab_rails['gitlab_ssh_host'] = '192.168.1.34'gitlab_rails['gitlab_shell_ssh_port'] = 8902

修改ssh协议后，/etc/ssh/sshd_config配置文件新增ssh端口

#Port 22Port 22port 8902

防火墙开放端口

iptables -I INPUT -p tcp -m state --state NEW -m tcp --dport 8902 -j ACCEPTiptables-saveiptables -nL --line-number

重启ssh服务

systemctl restart sshd.service

配置邮箱

填写配置好的smtp信息

gitlab_rails['smtp_enable'] = truegitlab_rails['smtp_address'] = "smtp.wenqy.com"gitlab_rails['smtp_port'] = 25gitlab_rails['smtp_user_name'] = "wenqy@wenqy.com"gitlab_rails['smtp_password'] = "123456"gitlab_rails['smtp_domain'] = "smtp.uf-tobacco.com"gitlab_rails['smtp_authentication'] = "login"gitlab_rails['smtp_tls'] = falsegitlab_rails['smtp_enable_starttls_auto'] = truegitlab_rails['smtp_openssl_verify_mode'] = 'none'gitlab_rails['smtp_ssl'] = falsegitlab_rails['smtp_force_ssl'] = falsegitlab_rails['gitlab_email_enabled'] = truegitlab_rails['gitlab_email_display_name'] = 'Gitlab'gitlab_rails['gitlab_email_from'] = 'wenqy@wenqy.com'

重启后进入console测试邮箱发送

gitlab-rails console#进入控制台，然后发送邮件Notify.test_email('wen.qy@qq.com', '邮件标题', '邮件正文').deliver_now

重启gitlab

修改配置后，重启生效

#重器gitlab配置服务sudo gitlab-ctl reconfigure#重启gitlabgitlab-ctl restart

常用命令

gitlab-ctl start #启动全部服务gitlab-ctl restart #重启全部服务gitlab-ctl stop #停止全部服务gitlab-ctl restart nginx #重启单个服务gitlab-ctl status #查看全部组件的状态gitlab-ctl show-config #验证配置文件gitlab-ctl uninstall #删除gitlab(保留数据）gitlab-ctl cleanse #删除所有数据，重新开始gitlab-ctl tail   #查看服务的日志gitlab-rails console production #进入控制台 ，可以修改root 的密码gitlab-ctl --help #查看gitlab-ctl命令的帮助信息

汉化

如果需要汉化，汉化包与gitlab软件包版本要一致，否则可能发送意想不到的错误，汉化之前更应该先备份gitlab数据。未尝试，不建议汉化。

# 暂停gitlabgitlab-ctl stop# 查看gitlab版本cat /opt/gitlab/embedded/service/gitlab-rails/VERSION12.8.1-ee# 下载对应版本汉化包git clone https://gitlab.com/xhang/gitlab.git# 备份cp -r /opt/gitlab/embedded/service/gitlab-rails{,.ori}# 汉化包覆盖cp -rf gitlab-10-3-stable-zh/* /opt/gitlab/embedded/service/gitlab-rails/# 启动gitlab-ctl start

安装git

Gitlab是基于git做版本控制，访问gitlab需要安装git，在linux用yum源安装

# 修改yum源，指向163mv /etc/yum.repos.d/CentOS-Base.repo /etc/yum.repos.d/CentOS-Base.repo.backup# 下载对应版本repo文件, 放入/etc/yum.repos.d/wget http://mirrors.163.com/.help/CentOS7-Base-163.repo# 如果yum命令直接卡死，造成rpm数据库异常，杀进程# 删除rpm数据文件 rm -f /var/lib/rpm/__db.00*# 重建rpm数据文件 rpm -vv --rebuilddb# 清除缓存yum clean allyum makecache# 安装gityum -y install git

Groups

一个 GitLab 的组是一些项目的集合，连同关于多少用户可以访问这些项目的数据。每一个组都有一个项目命名空间（与用户一样），所以如果一个叫 training 的组拥有一个名称是 materials 的项目，那么这个项目的 url 会是 http://server/training/materials。

每一个组都有许多用户与之关联，每一个用户对组中的项目以及组本身的权限都有级别区分。权限的范围从 “访客”（仅能提问题和讨论）到 “拥有者”（完全控制组、成员和项目）。权限的种类太多以至于难以在这里一一列举，不过在 GitLab 的管理界面上有帮助链接。

项目

一个 GitLab 的项目相当于 git 的版本库。每一个项目都属于一个用户或者一个组的单个命名空间。如果这个项目属于一个用户，那么这个拥有者对所有可以获取这个项目的人拥有直接管理权；如果这个项目属于一个组，那么该组中用户级别的权限也会起作用。

每一个用户账号都有一个 命名空间 ，即该用户项目的逻辑集合。如果一个叫 wenqy 的用户拥有一个名称是 springcloudstudy的项目，那么这个项目的 url 会是 http://server/wenqy/springcloudstudy 。

每一个项目都有一个可视级别，控制着谁可以看到这个项目页面和仓库。如果一个项目是私有的，这个项目的拥有者必须明确授权从而使特定的用户可以访问。一个内部的项目可以被所有登录的人看到，而一个公开的项目则是对所有人可见的。注意，这种控制既包括 git fetch 的使用也包括对项目 web 用户界面的访问。

配置SSH Keys

我们需要经常免登录git账号进行推送代码，这时需要配置SSH Keys，将生成的RSA 公钥填入。

当通常情况下，我们已经在GitHub、码云上已经分配了账号，可能是相同的ID，也可能在一个平台上有多个账号，我们可能需要区分不同的平台和账号和一个平台的多个账号。我们可以看下同时配置GitHub两个账号，用命令生成公钥私钥对

ssh-keygen -t rsa -C "one@github.com"
ssh-keygen -t rsa -C "two@github.com"

运行命令后不要一路回车，分别在第一次对话出现“Enter file in which to save the key”的时候输入不同的文件名，避免覆盖。两份包含私钥和公钥的4个文件，后缀为.pub的文件为公钥文件。linux或mac用户一定要在~/.ssh路径下运行命令行，不然生成的文件不会出现在当前目录，Windows用户则在“C:\Users\用户名\.ssh”目录下运行命令行。

配置config文件

在.ssh目录下创建config文件，在config文件中添加以下内容:

#github server oneHost one.github.comHostname github.comUser onePreferredAuthentications publickeyIdentityFile C:\\Users\\xmn-wenqy.HELLO-WORLD\\.ssh\\id_rsa#github server twoHost two.github.comHostname github.comUser twoPreferredAuthentications publickeyIdentityFile C:\\Users\\xmn-wenqy.HELLO-WORLD\\.ssh\\id_rsa_cloud

每个账号单独配置一个Host，每个Host要取一个别名，一般为每个Host主要配置HostName和IdentityFile两个属性，配置完保存即可。Host的名字可以自定义名字，不过这个会影响git相关命令，例如：Host one.github.com这样定义的话，使用命令git clone git@one.github.com:one/project.git，git@后面紧跟的名字改为one.github.com

为仓库设置局部的用户名和邮箱

# 取消全局 用户名/邮箱 配置git config --global --unset user.namegit config --global --unset user.email    # 单独为每个repo设置 用户名/邮箱git config user.name "one_name" ; git config user.email "one_email"git config user.name "two_name" ; git config user.email "two_email"

配置好SSH Keys后就可以免登录推送代码到gitlab了。

钩子

GitLab 在项目和系统级别上都支持钩子程序。对任意级别，当有相关事件发生时，GitLab 的服务器会执行一个包含描述性 JSON 数据的 HTTP 请求。这是自动化连接你的 git 版本库和 GitLab 实例到其他的开发工具，比如 CI 服务器，聊天室，或者部署工具的一个极好方法。

对应root超级用户，有更多的管理权限，有管理面板，可以对使用者、项目进行管理和统计分析等等。

架构

gitlab 依赖的组件默认安装在/var/opt/gitlab/目录下

Gitlab利用Nginx或者Apache作为web前端代理到Unicorn web服务端。默认情况下，Unicorn和前端之间的通信是通过Unix domain socket进行的，但也支持通过TCP转发请求。利用Sidekiq从Redis队列中拉取job并处理，是Ruby后台任务处理器；利用Redis缓存作业、会话等信息；利用PostgreSQL做持久化数据库，保存用户、权限、issues等元信息；利用GitLab Shell接收SSH请求，GitLab Shell通过Gitaly访问存储库，为Git对象提供服务，并与Redis通信，将作业提交给Sidekiq供GitLab处理。GitLab Shell通过GitLab API查询以确定授权和访问；Gitaly从GitLab Shell和GitLab web app执行Git操作，并为GitLab web app提供一个API，以从Git获取属性（例如titile、、branches、tags、其他元数据），并获取blob（例如diff、commits、files）;GitLab Workhorse是由GitLab设计的程序，可帮助缓解Unicorn的压力，它旨在充当智能反向代理，以帮助加快整个GitLab的运行速度。

此外，官方推荐服务器CPU核数至少4核，存储空间不少于gitlab所有存储库之和，磁盘最好采用逻辑卷管理方便扩展硬盘驱动器，gitlab占用太多内存，容易导致服务器崩溃，可以启用swap分区，缓解内存压力，例如，阿里云ECS默认是没有开启swap的，这值得注意一下。日志目录默认安装在/var/log/gitlab路径下。还应该注意Gitlab的性能优化、数据备份和迁移。

Gitlab安装和部署还是相对容易的，只是依赖的组件相对庞杂，太过吃内存。对于熟悉Git和GitHub的人也是极易上手，甚至是无感知使用的。

参考

https://about.gitlab.com/install/#centos-7

https://gitlab.com/gitlab-org/gitlab-foss/

https://packages.gitlab.com/gitlab/gitlab-ce

https://docs.gitlab.com/omnibus/settings/smtp.html

https://docs.gitlab.com/ee/install/requirements.html

https://docs.gitlab.com/ce/development/architecture.html

https://blog.csdn.net/ouyang_peng/article/details/84066417 解决GitLab内存消耗大的问题

Gitlab概览

Sat, 24 Oct 2020 11:48:44 CST

Gitlab是开源的基于Git的仓库管理系统，也可以管理软件开发的整个生命周期，是项目管理和代码托管平台，支撑着整个DevOps的生命周期。Gitlab很容易选为GitHub\码云\gogs\gitea的替代品，作为公司私有库管理的工具。我们可以用Gitlab Workflow来协同整个团队的软件开发管理过程。

软件开发阶段

Gitlab工作流将软件开发定义为10个阶段，并提供相应的解决方案，帮助团队高效协作，完成项目开发。

IDEA	项目的通常来自一个idea的诞生，idea可能来自某次闲聊。Gitlab集成Mattermost，提供内部通讯工具。（默认未开启）
ISSUE	为IDEA建个ISSUE讨论，团队成员追踪、讨论、提升
PLAN	讨论达成一致，需要优化和组织工作流，可以利用ISSUE Board
CODE	准备就绪，进入编码阶段
COMMIT	利用版本控制，提交代码到功能分支
TEST	利用GitLab CI，可以运行脚本来构建和测试应用
REVIEW	构建和测试成功后，可以进行代码复审
STAGING	部署代码到演示环境，检查是否符合期望，以便及时调整
PRODUCTION	如预期顺畅，部署应用到生产环境
FEEDBACK	回顾项目，利用Cycle Analytics对关键部分反馈，总结和提升

Gitlab flow

区别于SVN等版本控制系统，基于Git的版本管理对于创建分支和合并变得更加容易，也方便项目的管理。

利用工单追踪，将功能特征驱动开发和功能特征分支有机结合在一起。受保护的分支对于权限较低开发者等角色需要通过发起合并请求，复核评审通过后最终才能合并到保护分支。GitLab flow是GitLab官方推荐的分支管理策略。我们可以在原则上约定：分支分为永久分支和临时分支，都是在master分支以外建立。永久分支不会被删除，包括主分支master，准生产分支pre-production，生产分支production。临时分支分为Feature特征分支和Fix修复分支，在开发完成会被删除。一种简单的方案，通常可以基于最新的master主分支，创建特征分支，进行特征开发，最后合并请求到master分支。

只有一个master主分支，这样的好处在于，可以代码及时合并，可以是本地代码库存量最小，也可以更快的持续交付。当然，与此同时，部署、环境、集成等相关问题也没得到很好的解决。

对于每一次分支合并，我们总是期望可以部署一个稳定的版本。我们可以考虑多环境分支的情况。

Gitlab flow 的最大原则叫做"上游优先"（upsteam first）。代码的变化，必须由“上游”向“下游”发展。Feature和Fix是master的“上游”，master是pre-production的上游，pre-production是production的“上游”。比如，生产环境出现了bug 或者要开发新的feature，这时就要建一个临时Hotfix或Feature分支，开发完成把它合并到master，确认没有问题，再cherry-pick到pre-production，这一步也没有问题，才进入production。Feature和Fix在开发人员在开发环境部署测试，master在测试环境中部署测试，pre-production在演示环境中部署测试，production在生产环境发布，一条流水线下来，可以持续完成项目的部署交付。

此外，我们可以有多稳定版本的分支策略，用于将软件发布给外界。

版本发布适用于APP、小程序等有版本规划的项目。稳定分支以master为起点，并尽可能晚地创建。通过尽可能晚的分支，可以最大程度地减少将错误修正应用于多个分支的时间。在master上打出稳定的分支版本。如果稳定分支发行后，出现bug，可以先将错误修复到master，然后cherry-picked到稳定分支，我们可以通过设置Tag来提高补丁版本，可以维护一个稳定分支专门指向最新版本发布的分支提交。

此外，我们可以对分支名称做个约定，在Gitlab上基于issue创建的分支默认是issue编号+issue标题等等。

Issue

GitLab 有一个强大的工单追溯系统，在使用过程中，允许你和你的团队，以及你的合作者分享和讨论建议。所有的开发工作都应该以工单任务为导向。

我们可以填写是否私密、受托人、截止日期、标签 、里程碑等信息，利用这些信息可以更加方便地组织活动和安排优先级。

Labels

GitLab 标签也是Gitlab flow的重要组成部分，可以对issue工单进行分类和定位。也可以通过定义优先级标签组织它们。通常和Boards一起，来组织计划和工作流程。

我们可以根据需要设计一些常用标签，如待办类，Bug类，功能改进类等进行定位、统计和跟踪。

Boards

Gitlab 工单面板是一个用于计划以及组织工单，使之符合项目工作流的工具。Boards包含了与其相关的对应标签，每一个列表包含了相关的被标记的issue工单，并且以卡片的形式展示出来。这些issue卡片可以在列表之间推拽移动，被移动的卡片，其标签将会依据你移动的位置更新到相应列表上。

Milestones

Milestones 是GitLab 中基于共同目标、时间进度追踪团队工作的最好工具。它定义了目标阶段对应的工单集合和合并请求。通常是团队协作在截止日期完成某个目标。例如，发布一个新的版本，启动一个新的产品，在某个日期前完成，或者按季度收尾一些项目。

Merge Request

我们可以根据issue创建branch和发起Merge Requests(MR)合并到目标分支。

开发者检出特征分支开发，提交后并推送到远程。功能分支和修复分支合并进master分支，必须通过Merge Requests。审核员可以对这些提交和变化进行评审，可以反复这个过程，直到符合代码规范，才合并到目标分支。

master分支应该受到保护，不是每个人都可以直接修改这个分支，以及拥有审批 Merge Request的权力。

上图展示了保护分支的权限设置，规定了哪些角色具有Branch的MR和push的权限。否则，推送无权限的分支时可能会出现以下错误：

you are not allowed to push code to protected branches on this project

每一次 MR 都会有一个标题（这个标题总结了这次的改动）并且一个用 Markdown 书写的描述。在描述中，你可以简单的描述该 MR 做了什么，涉及的任何工单和 MR（在它们之间创建联系），并且，你也可以添加个关闭工单模式，当该MR 被合并的时候，相关联的工单就会自动被关闭。在描述里添加 Closes #xxx，xxx为对应的issue编号。Merge成功后，自动关闭工单。

有权限角色在Merge RequestMerge 前，注意下Merge的内容，评审通过后，最好能确保每一次Merge后对应Master分支都是稳定的。

WIP MR

WIP (Work in Process) MR,避免 MR 在准备就绪前被合并。只需要添加 WIP: 在 MR 的标题开头，它将不会被合并，除非你把 WIP: 删除。当你改动已经准备好被合并，编辑工单来手动删除 WIP: 。或者使用快捷方式，只需要在评论或者 MR 描述中输入斜线命令**/wip**并提交即可快速添加到合并请求中。

Code Review

一旦你创建一个合并请求，审核方收到反馈，就可以决定是否合并这个请求了。审核者可以进行差异比较，回复或者解决它们。在图形界面中可以看到提交历史，通过提交历史，你可以追踪文件的每一次改变。你可以以行内差异或左右对比的方式浏览它们,甚至评论他们。

如果有合并冲突，甚至可以在线编辑解决。

Memebers

项目拥有者和维护者需要添加协作的团队成员，进行项目协同，可以选择已注册gitlab的有效成员进行邀请。

受邀人会受到电子邮件，同意后就可以加入团队了。低权限角色只能开发，甚至只能浏览，无权限维护。

CI/CD

GitLab CI/CD是构建项目持续集成、持续部署和持续交付的有效工具。首先需要在项目根目录下创建文件.gitlab-ci.yml。

例如，我们可以在项目中每一次Merge Request，都可以触发pipeline 去构建、测试和部署。而具体的构建规则可以根据编写不同的.gitlab-ci.yaml脚本实现。CI/CD pipelines的运行离不开Gitlab Runner。所以，还需要安装GitLab Runner，它可以在任何地方（能ping通Gitlab）运行，也可以是以Shell、docker、kubernetes等不同的形式运行。GitLab Runner向Gitlab注册，需要Gitlab授权。注册成功后，GitLab Runners负责从Gitlab拉取代码进行构建、测试和部署。区别于Jenkins，Gitlab-CI更加适合DevOps人员，开发与运维是同一个人，非常适合敏捷开发。Jenkins通过Hook可以使编译服务和代码仓库分离，耦合度低，适合多角色团队，职责分明。将另有篇幅概述，这一块暂不赘述。

周期分析

我们可以通过周期分析，可以查看各个阶段的统计，及时反馈项目的进展和改进项目的不足之处。

Issue	从创建一个工单，到分配这个工单给一个里程碑或者添加工单到你的工单看板的时间
Plan	从给工单分配一个里程碑或者把它添加到工单看板，到推送第一次提交的时间
Code	从第一次提交到提出该合并请求的时间
Test	CI 为了相关合并请求而运行整个过程的时间
Review	从创建一个合并请求到合并它的时间
Staging	从合并到发布成为产品的时间
Production（Total）	从创建工单到把代码发布成产品的时间

Markdown Tips

在Issue 或 Merge Request 等对应的markdown描述或者git commit -m ""注释信息中，可以添加特殊标识来实现一些特性。可以看下简单的例子：

## 增加一个新页面这个 MR 将会为这个项目创建一个包含该 app 概览的 `readme.md`。Closes #1,#2 and https://gitlab.wenqy.com/group/project/issues/<8>related to #3:smile:/cc @wenqy @all

上面是MR的一段描述。合并时，会关闭编号为1,2的issue工单，以及url指向的项目工单。这还做了一个编号为3的issue工单关联，不会关闭。并邮件通知用户。还支持emoji表情。

添加关闭工单样式到你的 MR 以便可以使用【GitLab周期分析】追踪你的项目进展，是十分重要的。它将会追踪“CODE”阶段，衡量第一次提交及创建一个相关的合并请求所间隔的时间。

第一次提交

第一次提交时添加一个关联的Issue编号，利用Ref #关联

git commit -m "this is my commit message. Ref #xxx"

或者使用全称Related to关联

git commit -m "this is my commit message. Related to https://gitlab.com///issues/"

链接第一次提交与Issue，将有助于【GitLab周期分析】跟踪工作流程，它将度量计划该Issue的实现所用的时间，即从创建Issue到进行第一次提交之间的时间。

任务列表

在描述里添加 - [] 子任务，划分子任务

- [x] Completed task - [ ] Incomplete task - [ ] Sub-task 1 - [x] Sub-task 2 - [ ] Sub-task

描述里面体现子任务的列表

此外，markdown描述里输入#，触发已有issue下拉；输入！，触发已有MR下拉；输入/，触发命令；输入:，触发emoji

在CI中还可以在git commit 注释里添加[ci skip]跳过CI等等。

此外，还可以对Issue和Merge Request等描述定义描述模板，规范描述。

Gitlab还有wiki和代码片段等知识库的管理和分享功能，方便团队规范行为。

总结

Gitlab开源免费，可以自建gitlab。它清晰且直观地划分了软件开发管理的各个阶段，可以无缝衔接过渡到每个阶段。它能预测和控制项目的生命周期，整个平台很容易上手和使用，以自己的工作流管理项目的整个生命周期非常方便，轻量而敏捷，甚至可以说是一体化管理，为敏捷而生，是一个值得推荐的协同开发项目管理工具。

参考

https://about.gitlab.com/blog/2016/10/25/gitlab-workflow-an-overview/

https://about.gitlab.com/blog/2014/09/29/gitlab-flow/

https://docs.gitlab.com/ee/topics/gitlab_flow.html

https://docs.gitlab.com/ee/user/markdown.html

https://gitlab.com/gitlab-org/omnibus-gitlab/-/labels

java8并发学习

Sun, 09 Feb 2020 17:17:44 CST

这里继续学习记录java8的并发知识。关于什么是并发，什么是并行，什么是进程，什么是线程，有什么关系区别等等就不贴出来啦。

并发在Java5中首次被引入并在后续的版本中不断得到增强。Java从JDK1.0开始执行线程。在开始一个新的线程之前，你必须指定由这个线程执行的代码，通常称为task。

线程与执行器

Runnable

我们可以通过实现Runnable--一个定义了一个无返回值无参数的run()方法的函数接口，来实现task。

/**     * Runnable     *      * @author wenqy     * @date 2020年1月17日 下午3:19:58     */    private void testRunnable() {        Runnable task = () -> {            String threadName = Thread.currentThread().getName();            System.out.println(“Hello “ + threadName);        };        task.run(); // 非线程方式调用，还在主线程里        Thread thread = new Thread(task);        thread.start();        System.out.println(“Done!”);  // runnable是在打印’done’前执行还是在之后执行,顺序是不确定的    }

我们可以将线程休眠确定的时间。通过这种方法来模拟长时间运行的任务。

/**     * 设置线程休眠时间，模拟长任务     *      * @author wenqy     * @date 2020年1月17日 下午3:25:01     */    private void testRunnableWithSleep() {        Runnable runnable = () -> {            try {                String name = Thread.currentThread().getName();                System.out.println(“Foo “ + name);                TimeUnit.SECONDS.sleep(1); // 休眠1s                System.out.println(“Bar “ + name);            }            catch (InterruptedException e) {                e.printStackTrace();            }        };        Thread thread = new Thread(runnable);        thread.start();    }

Executor

并发API引入了ExecutorService作为一个在程序中直接使用Thread的高层次的替换方案。Executors支持运行异步任务，通常管理一个线程池，这样一来我们就不需要手动去创建新的线程。在不断地处理任务的过程中，线程池内部线程将会得到复用，Java进程从没有停止！Executors必须显式的停止-否则它们将持续监听新的任务。

ExecutorService提供了两个方法来达到这个目的--shutdwon()会等待正在执行的任务执行完而shutdownNow()会终止所有正在执行的任务并立即关闭executor。

ExecutorService executor = Executors.newSingleThreadExecutor(); // 单线程线程池        executor.submit(() -> {            String threadName = Thread.currentThread().getName();            System.out.println(“Hello “ + threadName);            try {                TimeUnit.SECONDS.sleep(6);            } catch (InterruptedException e) {                System.err.println(“my is interrupted”);            } // 休眠1s        });        // => Hello pool-1-thread-1        // Executors必须显式的停止-否则它们将持续监听新的任务        try {            System.out.println(“attempt to shutdown executor”);            executor.shutdown(); // 等待正在执行的任务执行完            executor.awaitTermination(5, TimeUnit.SECONDS); // 等待指定时间优雅关闭executor。在等待最长5s的时间后，executor最终会通过中断所有的正在执行的任务关闭            System.out.println(“wait for 5s to shutdown”);        } catch (InterruptedException e) {            System.err.println(“tasks interrupted”);        } finally {            if (!executor.isTerminated()) {                System.err.println(“cancel non-finished tasks”);            }            executor.shutdownNow(); // 终止所有正在执行的任务并立即关闭executor            System.out.println(“shutdown finished”);        }

Callable

Callables也是类似于runnables的函数接口，不同之处在于，Callable返回一个值。一样提交给 executor services。在调用get()方法时，当前线程会阻塞等待，直到callable在返回实际的结果 123 之前执行完成。

Callable task = () -> {            try {                TimeUnit.SECONDS.sleep(5); // 休眠5s后返回整数                return 123;            }            catch (InterruptedException e) {                throw new IllegalStateException(“task interrupted”, e);            }        };        ExecutorService executor = Executors.newFixedThreadPool(1); // 固定线程池        Future future = executor.submit(task);        System.out.println(“future done? “ + future.isDone());//      executor.shutdownNow(); // 如果关闭executor，所有的未中止的future都会抛出异常。        Integer result = future.get(); // 在调用get()方法时，当前线程会阻塞等待，直到callable在返回实际的结果123之前执行完成        System.out.println(“future done? “ + future.isDone());        System.out.println(“result: “ + result);        executor.shutdownNow(); // 需要显式关闭        System.out.println(“result: “ + future.get());    }

任何future.get()调用都会阻塞，然后等待直到callable中止。在最糟糕的情况下，一个callable持续运行--因此使你的程序将没有响应。我们可以简单的传入一个时长来避免这种情况。

ExecutorService executor = Executors.newFixedThreadPool(1);        Future future = executor.submit(() -> {            try {                TimeUnit.SECONDS.sleep(2);                return 123;            }            catch (InterruptedException e) {                throw new IllegalStateException(“task interrupted”, e);            }        });        // 任何future.get()调用都会阻塞，然后等待直到callable中止,传入超时时长终止        future.get(1, TimeUnit.SECONDS);  // 抛出 java.util.concurrent.TimeoutException

invokeAll

Executors支持通过invokeAll()一次批量提交多个callable。这个方法结果一个callable的集合，然后返回一个future的列表。

ExecutorService executor = Executors.newWorkStealingPool(); // ForkJoinPool 一个并行因子数来创建，默认值为主机CPU的可用核心数        List> callables = Arrays.asList(                () -> “task1”,                () -> “task2”,                () -> “task3”);        executor.invokeAll(callables)            .stream()            .map(future -> { // 返回的所有future，并每一个future映射到它的返回值                try {                    return future.get();                }                catch (Exception e) {                    throw new IllegalStateException(e);                }            })            .forEach(System.out::println);

invokeAny

批量提交callable的另一种方式就是invokeAny()，它的工作方式与invokeAll()稍有不同。在等待future对象的过程中，这个方法将会阻塞直到第一个callable中止然后返回这一个callable的结果。

private static Callable callable(String result, long sleepSeconds) {        return () -> {            TimeUnit.SECONDS.sleep(sleepSeconds);            return result;        };    }    public static void main(String[] args) throws InterruptedException, ExecutionException {        ExecutorService executor = Executors.newWorkStealingPool();        List> callables = Arrays.asList(        callable(“task1”, 2),        callable(“task2”, 1),        callable(“task3”, 3));        String result = executor.invokeAny(callables);        System.out.println(result); // task2    }

这个例子又使用了另一种方式来创建executor--调用newWorkStealingPool()。这个工厂方法是Java8引入的，返回一个ForkJoinPool类型的 executor，它的工作方法与其他常见的execuotr稍有不同。与使用一个固定大小的线程池不同，ForkJoinPools使用一个并行因子数来创建，默认值为主机CPU的可用核心数。

ScheduledExecutor

为了持续的多次执行常见的任务，我们可以利用调度线程池。ScheduledExecutorService支持任务调度，持续执行或者延迟一段时间后执行。调度一个任务将会产生一个专门的future类型--ScheduleFuture，它除了提供了Future的所有方法之外，他还提供了getDelay()方法来获得剩余的延迟。在延迟消逝后，任务将会并发执行。

为了调度任务持续的执行，executors 提供了两个方法scheduleAtFixedRate()和scheduleWithFixedDelay()。第一个方法用来以固定频率来执行一个任务，另一个方法等待时间是在一次任务的结束和下一个任务的开始之间

/**     * 获取剩余延迟     * @throws InterruptedException     * @author wenqy     * @date 2020年1月17日 下午4:56:58     */    private static void scheduleDelay() throws InterruptedException {        ScheduledExecutorService executor = Executors.newScheduledThreadPool(1);        Runnable task = () -> System.out.println(“Scheduling: “ + System.nanoTime());        ScheduledFuture future = executor.schedule(task, 3, TimeUnit.SECONDS); // 3s后执行        TimeUnit.MILLISECONDS.sleep(1337);        long remainingDelay = future.getDelay(TimeUnit.MILLISECONDS);        System.out.printf(“Remaining Delay: %sms\n”, remainingDelay); // 剩余的延迟        executor.shutdown();    }    /**     * 以固定频率来执行一个任务     *      * @throws InterruptedException     * @author wenqy     * @date 2020年1月17日 下午4:57:45     */    private static void scheduleAtFixedRate() throws InterruptedException {        ScheduledExecutorService executor = Executors.newScheduledThreadPool(1);        Runnable task = () -> {            System.out.println(“at fixed rate Scheduling: “ + System.nanoTime());            try {                TimeUnit.SECONDS.sleep(2);            } catch (InterruptedException e) {                e.printStackTrace();            }        };        int initialDelay = 0; // 初始化延迟，用来指定这个任务首次被执行等待的时长        int period = 1;        executor.scheduleAtFixedRate(task, initialDelay, period, TimeUnit.SECONDS); // 不考虑任务的实际用时    }    /**     * 以固定延迟来执行一个任务     *  等待时间 period 是在一次任务的结束和下一个任务的开始之间     * @throws InterruptedException     * @author wenqy     * @date 2020年1月17日 下午5:03:28     */    private static void scheduleWithFixedDelay() throws InterruptedException {        ScheduledExecutorService executor = Executors.newScheduledThreadPool(1);        Runnable task = () -> {            try {                TimeUnit.SECONDS.sleep(2);                System.out.println(“WithFixedDelay Scheduling: “ + System.nanoTime());            }            catch (InterruptedException e) {                System.err.println(“task interrupted”);            }        };        executor.scheduleWithFixedDelay(task, 0, 1, TimeUnit.SECONDS);    }

同步与锁

我们学到了如何通过执行器服务同时执行代码。当我们编写这种多线程代码时，我们需要特别注意共享可变变量的并发访问。

int count = 0;    void increment() {        count = count + 1;    }

我们在不同的线程上共享可变变量，并且变量访问没有同步机制，这会产生竞争条件。上面例子被多个线程同时访问，就会出现未知的错误。

我们可以用synchronized关键字支持线程同步

synchronized void incrementSync() {      count = count + 1;}

synchronized关键字也可用于语句块

void incrementSync2() {        synchronized (this) {            count = count + 1;        }    }

java在内部使用所谓的**"监视器"**（monitor），也称为监视器锁（monitor lock）或内在锁（ intrinsic lock）来管理同步。监视器绑定在对象上，例如，当使用同步方法时，每个方法都共享相应对象的相同监视器。

所有隐式的监视器都实现了重入（reentrant）特性。重入的意思是锁绑定在当前线程上。线程可以安全地多次获取相同的锁，而不会产生死锁（例如，同步方法调用相同对象的另一个同步方法）

并发API支持多种显式的锁，它们由Lock接口规定，用于代替synchronized的隐式锁。锁对细粒度的控制支持多种方法，因此它们比隐式的监视器具有更大的开销。

ReentrantLock

ReentrantLock类是互斥锁，与通过synchronized访问的隐式监视器具有相同行为，但是具有扩展功能。就像它的名称一样，这个锁实现了重入特性，就像隐式监视器一样。

锁可以通过lock()来获取，通过unlock()来释放。把你的代码包装在try-finally代码块中来确保异常情况下的解锁非常重要。

/** * 可重入锁 *  * @author wenqy * @date 2020年1月18日 下午3:41:50 */private void safeIncreByLock() {    count = 0;    ExecutorService executor = Executors.newFixedThreadPool(2);    executor.submit(() -> {        lock.lock();        try {            ConcurrentUtils.sleep(1);        } finally {            lock.unlock();        }    });    executor.submit(() -> {        System.out.println(“Locked: “ + lock.isLocked());        System.out.println(“Held by me: “ + lock.isHeldByCurrentThread());        boolean locked = lock.tryLock(); // 尝试拿锁而不阻塞当前线程        // 在访问任何共享可变变量之前，必须使用布尔值结果来检查锁是否已经被获取        System.out.println(“Lock acquired: “ + locked);    });    ConcurrentUtils.stop(executor);}

ReadWriteLock

ReadWriteLock接口规定了锁的另一种类型，包含用于读写访问的一对锁。读写锁的理念是，只要没有任何线程写入变量，并发读取可变变量通常是安全的。所以读锁可以同时被多个线程持有，只要没有线程持有写锁。这样可以提升性能和吞吐量，因为读取比写入更加频繁。

/** * 读写锁 *  * @author wenqy * @date 2020年1月18日 下午3:41:21 */private void readWriteLock() {    ExecutorService executor = Executors.newFixedThreadPool(2);    Map map = new HashMap<>();    ReadWriteLock lock = new ReentrantReadWriteLock();    executor.submit(() -> {        lock.writeLock().lock();        try {            ConcurrentUtils.sleep(1);            map.put(“foo”, “bar”);        } finally {            lock.writeLock().unlock();        }    });    Runnable readTask = () -> {        lock.readLock().lock();        try {            System.out.println(map.get(“foo”));            ConcurrentUtils.sleep(1);        } finally {            lock.readLock().unlock();        }    };    executor.submit(readTask);    executor.submit(readTask);    ConcurrentUtils.stop(executor);    // 两个读任务需要等待写任务完成。在释放了写锁之后，两个读任务会同时执行，并同时打印结果。    // 它们不需要相互等待完成，因为读锁可以安全同步获取}

StampedLock

Java 8 自带了一种新的锁，叫做StampedLock，它同样支持读写锁，就像上面的例子那样。与ReadWriteLock不同的是，StampedLock的锁方法会返回表示为long的标记。你可以使用这些标记来释放锁，或者检查锁是否有效。

/**     * java8 StampedLock     *      tampedLock并没有实现重入特性，相同线程也要注意死锁     * @author wenqy     * @date 2020年1月18日 下午3:40:46     */    private void stampedLock() {        ExecutorService executor = Executors.newFixedThreadPool(2);        Map map = new HashMap<>();        StampedLock lock = new StampedLock();        executor.submit(() -> {            long stamp = lock.writeLock(); // 读锁或写锁会返回一个标记            try {                ConcurrentUtils.sleep(1);                map.put(“foo”, “bar”);            } finally {                lock.unlockWrite(stamp);            }        });        Runnable readTask = () -> {            long stamp = lock.readLock();            try {                System.out.println(map.get(“foo”));                ConcurrentUtils.sleep(1);            } finally {                lock.unlockRead(stamp);            }        };        executor.submit(readTask);        executor.submit(readTask);        ConcurrentUtils.stop(executor);    }

此外，StampedLock支持另一种叫做乐观锁（optimistic locking）的模式。乐观的读锁通过调用tryOptimisticRead()获取，它总是返回一个标记而不阻塞当前线程，无论锁是否真正可用。如果已经有写锁被拿到，返回的标记等于0。你需要总是通过lock.validate(stamp)检查标记是否有效。

/** * 乐观锁 *  乐观锁在刚刚拿到锁之后是有效的。和普通的读锁不同的是，乐观锁不阻止其他线程同时获取写锁。 *  在第一个线程暂停一秒之后，第二个线程拿到写锁而无需等待乐观的读锁被释放。 *  此时，乐观的读锁就不再有效了。甚至当写锁释放时，乐观的读锁还处于无效状态。 *  所以在使用乐观锁时，你需要每次在访问任何共享可变变量之后都要检查锁，来确保读锁仍然有效。 *  * @author wenqy * @date 2020年1月18日 下午3:49:31 */private void optimisticLock() {    System.out.println(“—–>optimisticLock—->”);    ExecutorService executor = Executors.newFixedThreadPool(2);    StampedLock lock = new StampedLock();    executor.submit(() -> {        long stamp = lock.tryOptimisticRead();        try {            System.out.println(“Optimistic Lock Valid: “ + lock.validate(stamp));            ConcurrentUtils.sleep(1);            System.out.println(“Optimistic Lock Valid: “ + lock.validate(stamp));            ConcurrentUtils.sleep(2);            System.out.println(“Optimistic Lock Valid: “ + lock.validate(stamp));        } finally {            lock.unlock(stamp);        }    });    executor.submit(() -> {        long stamp = lock.writeLock();        try {            System.out.println(“Write Lock acquired”);            ConcurrentUtils.sleep(2);        } finally {            lock.unlock(stamp);            System.out.println(“Write done”);        }    });    ConcurrentUtils.stop(executor);}/** * 读锁转换为写锁 *  * @author wenqy * @date 2020年1月18日 下午4:00:10 */private void convertToWriteLock() {    count = 0;    System.out.println(“—–>convertToWriteLock—->”);    ExecutorService executor = Executors.newFixedThreadPool(2);    StampedLock lock = new StampedLock();    executor.submit(() -> {        long stamp = lock.readLock();        try {            if (count == 0) {                stamp = lock.tryConvertToWriteLock(stamp); // 读锁转换为写锁而不用再次解锁和加锁                if (stamp == 0L) { // 调用不会阻塞，但是可能会返回为零的标记，表示当前没有可用的写锁                    System.out.println(“Could not convert to write lock”);                    stamp = lock.writeLock(); // 阻塞当前线程，直到有可用的写锁                }                count = 23;            }            System.out.println(count);        } finally {            lock.unlock(stamp);        }    });    ConcurrentUtils.stop(executor);}

信号量

除了锁之外，并发API也支持计数的信号量。不过锁通常用于变量或资源的互斥访问，信号量可以维护整体的准入许可。

/**     * 信号量     *      * @author wenqy     * @date 2020年1月18日 下午4:13:11     */    private void doSemaphore() {        ExecutorService executor = Executors.newFixedThreadPool(10);        Semaphore semaphore = new Semaphore(5); // 并发访问总数        Runnable longRunningTask = () -> {            boolean permit = false;            try {                permit = semaphore.tryAcquire(1, TimeUnit.SECONDS);                if (permit) {                    System.out.println(“Semaphore acquired”);                    ConcurrentUtils.sleep(5);                } else { // 等待超时之后，会向控制台打印不能获取信号量的结果                    System.out.println(“Could not acquire semaphore”);                }            } catch (InterruptedException e) {                throw new IllegalStateException(e);            } finally {                if (permit) {                    semaphore.release();                }            }        };        IntStream.range(0, 10)            .forEach(i -> executor.submit(longRunningTask));        ConcurrentUtils.stop(executor);    }

原子变量

java.concurrent.atomic包包含了许多实用的类，用于执行原子操作。如果你能够在多线程中同时且安全地执行某个操作，而不需要synchronized关键字或锁，那么这个操作就是原子的。

本质上，原子操作严重依赖于比较与交换（CAS），它是由多数现代CPU直接支持的原子指令。这些指令通常比同步块要快。所以在只需要并发修改单个可变变量的情况下，我建议你优先使用原子类，而不是锁。可以看下java包提供的一些原子变量例子AtomicInteger、LongAdder 、LongAccumulator、concurrentHashMap等等。

/**     * AtomicInteger     *      incrementAndGet     * @author wenqy     * @date 2020年1月18日 下午4:27:10     */    private void atomicIntegerIncre() {        AtomicInteger atomicInt = new AtomicInteger(0);        ExecutorService executor = Executors.newFixedThreadPool(2);        IntStream.range(0, 1000)            .forEach(i -> executor.submit(atomicInt::incrementAndGet)); // ++        ConcurrentUtils.stop(executor);        System.out.println(atomicInt.get());    // => 1000    }    /**     * AtomicInteger     *  updateAndGet     * @author wenqy     * @date 2020年1月18日 下午4:29:26     */    private void atomicIntegerUpdateAndGet() {        AtomicInteger atomicInt = new AtomicInteger(0);        ExecutorService executor = Executors.newFixedThreadPool(2);        IntStream.range(0, 1000)            .forEach(i -> {                Runnable task = () ->                    atomicInt.updateAndGet(n -> n + 2); // 结果累加2                executor.submit(task);            });        ConcurrentUtils.stop(executor);        System.out.println(atomicInt.get());    // => 2000    }    /**     * LongAdder     *      AtomicLong的替代，用于向某个数值连续添加值     *      内部维护一系列变量来减少线程之间的争用，而不是求和计算单一结果     *      当多线程的更新比读取更频繁时，这个类通常比原子数值类性能更好。     *      这种情况在抓取统计数据时经常出现，例如，你希望统计Web服务器上请求的数量。     *      LongAdder缺点是较高的内存开销，因为它在内存中储存了一系列变量。     * @author wenqy     * @date 2020年1月18日 下午4:33:29     */    private void longAdder() {        LongAdder adder = new LongAdder();        ExecutorService executor = Executors.newFixedThreadPool(2);        IntStream.range(0, 1000)            .forEach(i -> executor.submit(adder::increment));        ConcurrentUtils.stop(executor);        System.out.println(adder.sumThenReset());   // => 1000    }    /**     * LongAccumulator     *      LongAccumulator是LongAdder的更通用的版本     *      内部维护一系列变量来减少线程之间的争用     * @author wenqy     * @date 2020年1月18日 下午4:35:11     */    private void longAccumulator() {        LongBinaryOperator op = (x, y) -> 2 * x + y;        LongAccumulator accumulator = new LongAccumulator(op, 1L);        ExecutorService executor = Executors.newFixedThreadPool(2);        // i=0  2 * 1 + 0 = 2;        // i=2  2 * 2 + 2 = 6;        // i=3  2 * 6 + 3 = 15;        // i=4  2 * 15 + 4 = 34;        IntStream.range(0, 10)            .forEach(i -> executor.submit(() -> {                        accumulator.accumulate(i);                        System.out.println(“i:” + i + ” result:” + accumulator.get());                    })                );        // 初始值为1。每次调用accumulate(i)的时候，当前结果和值i都会作为参数传入lambda表达式。        ConcurrentUtils.stop(executor);        System.out.println(accumulator.getThenReset());     // => 2539    }    /**     * concurrentMap     *      * @author wenqy     * @date 2020年1月18日 下午4:38:09     */    private void concurrentMap() {        System.out.println(“—–>concurrentMap—–>”);        ConcurrentMap map = new ConcurrentHashMap<>();        map.put(“foo”, “bar”);        map.put(“han”, “solo”);        map.put(“r2”, “d2”);        map.put(“c3”, “p0”);        map.forEach((key, value) -> System.out.printf(“%s = %s\n”, key, value));        String value = map.putIfAbsent(“c3”, “p1”);        System.out.println(value);    // p0  提供的键不存在时，将新的值添加到映射        System.out.println(map.getOrDefault(“hi”, “there”));    // there 传入的键不存在时，会返回默认值        map.replaceAll((key, val) -> “r2”.equals(key) ? “d3” : val);        System.out.println(map.get(“r2”));    // d3        map.compute(“foo”, (key, val) -> val + val);        System.out.println(map.get(“foo”));   // barbar 转换单个元素，而不是替换映射中的所有值        map.merge(“foo”, “boo”, (oldVal, newVal) -> newVal + ” was “ + oldVal);        System.out.println(map.get(“foo”));   // boo was foo    }    /**     * concurrentHashMap     *      * @author wenqy     * @date 2020年1月18日 下午4:38:42     */    private void concurrentHashMap() {        System.out.println(“—–>concurrentHashMap—–>”);        ConcurrentHashMap map = new ConcurrentHashMap<>();        map.put(“foo”, “bar”);        map.put(“han”, “solo”);        map.put(“r2”, “d2”);        map.put(“c3”, “p0”);        map.forEach(1, (key, value) ->        System.out.printf(“key: %s; value: %s; thread: %s\n”,            key, value, Thread.currentThread().getName())); // 可以并行迭代映射中的键值对        String result = map.search(1, (key, value) -> {            System.out.println(Thread.currentThread().getName());            if (“foo”.equals(key)) { // 当前的键值对返回一个非空的搜索结果                return value; // 只要返回了非空的结果，就不会往下搜索了            }            return null;        }); // ConcurrentHashMap是无序的。搜索函数应该不依赖于映射实际的处理顺序        System.out.println(“Result: “ + result);        String searchResult = map.searchValues(1, value -> {            System.out.println(Thread.currentThread().getName());            if (value.length() > 3) {                return value;            }            return null;        }); // 搜索映射中的值        System.out.println(“Result: “ + searchResult);        String reduceResult = map.reduce(1,            (key, value) -> {                System.out.println(“Transform: “ + Thread.currentThread().getName());                return key + “=” + value;            },            (s1, s2) -> {                System.out.println(“Reduce: “ + Thread.currentThread().getName());                return s1 + “, “ + s2;            });        // 第一个函数将每个键值对转换为任意类型的单一值。        // 第二个函数将所有这些转换后的值组合为单一结果，并忽略所有可能的null值        System.out.println(“Result: “ + reduceResult);    }

我们学了java8的一些新特性和并发编程例子，暂且告一段落了，demo已上传至github：https://github.com/wenqy/java-study

参考

https://github.com/winterbe/java8-tutorial java8教程

https://wizardforcel.gitbooks.io/modern-java/content/ 中文译站

https://github.com/wenqy/java-study 学习例子

java8数据流再识

Sat, 08 Feb 2020 17:18:52 CST

数据流操作要么是衔接操作，要么是终止操作。当一个函数不修改数据流的底层数据源，它就是无干扰的。当一个函数的操作的执行是确定性的，它就是无状态的。

数据流可以从多种数据源创建，尤其是集合。可以有不同类型的数据流。

/**     * 从多种数据源创建数据流     *      * @author wenqy     * @date 2020年1月17日 上午11:00:15     */    private void diffStreamType() {        System.out.println(“—–>diffStreamType—–>”);        Arrays.asList(“a1”, “a2”, “a3”)            .stream()            .findFirst()            .ifPresent(System.out::println);  // a1        Stream.of(“a1”, “a2”, “a3”)            .findFirst()            .ifPresent(System.out::println);  // a1        IntStream.range(1, 4)   // 基本数据类型 // 1 2 3            .forEach(System.out::println);    }

基本数据流和对象数据流间也可以转换

/**     * 基本数据流操作     *      * @author wenqy     * @date 2020年1月17日 上午11:01:26     */    private void baseStream() {        System.out.println(“—–>baseStream—–>”);        Arrays.stream(new int[] {1, 2, 3})            .map(n -> 2 * n + 1)            .average() // 终止操作，求平均值            .ifPresent(System.out::println);  // 5.0        Stream.of(“a1”, “a2”, “a3”)            .map(s -> s.substring(1))            .mapToInt(Integer::parseInt) // 对象数据流转换为基本数据流            .max()            .ifPresent(System.out::println);  // 3        IntStream.range(1, 4)            .mapToObj(i -> “a” + i) // 基本数据流转换为对象数据流            .forEach(System.out::println); // a1 a2 a3    }

数据流处理时，衔接操作的一个重要特性就是延迟性，在调用链上是垂直移动的，减少每个元素上所执行的实际操作数量。

/**     * 处理顺序     *      * @author wenqy     * @date 2020年1月17日 上午11:08:33     */    private void streamHandleSort() {        System.out.println(“—–>streamHandleSort—–>”);        Stream.of(“d2”, “a2”, “b1”, “b3”, “c”)            .filter(s -> {                System.out.println(“filter: “ + s);                return true;            })            .forEach(s -> System.out.println(“forEach: “ + s));        // filter:  d2 forEach: d2 … 每个元素在调用链上垂直移动        Stream.of(“d2”, “a2”, “b1”, “b3”, “c”)            .map(s -> {                System.out.println(“map: “ + s);                return s.toUpperCase();            })            .anyMatch(s -> {                System.out.println(“anyMatch: “ + s);                return s.startsWith(“A”);            });        // map:d2 anyMatch:D2 map:a2 anyMatch:A2 anyMatch返回true时终止        Stream.of(“d2”, “a2”, “b1”, “b3”, “c”)            .map(s -> {                System.out.println(“map: “ + s);                return s.toUpperCase();            })            .filter(s -> {                System.out.println(“filter: “ + s);                return s.startsWith(“A”);            })            .forEach(s -> System.out.println(“forEach: “ + s));        // map和filter会对底层集合的每个字符串调用五次，而forEach只会调用一次        Stream.of(“d2”, “a2”, “b1”, “b3”, “c”)            .filter(s -> {                System.out.println(“filter: “ + s);                return s.startsWith(“a”);            })            .map(s -> {                System.out.println(“map: “ + s);                return s.toUpperCase();            })            .forEach(s -> System.out.println(“forEach: “ + s));        // filter移动到调用链的顶端  map只会调用一次 执行更快        Stream.of(“d2”, “a2”, “b1”, “b3”, “c”)            .sorted((s1, s2) -> {                System.out.printf(“sort: %s; %s\n”, s1, s2);                return s1.compareTo(s2);            })            .filter(s -> {                System.out.println(“filter: “ + s);                return s.startsWith(“a”);            })            .map(s -> {                System.out.println(“map: “ + s);                return s.toUpperCase();            })            .forEach(s -> System.out.println(“forEach: “ + s));        // 排序是一类特殊的衔接操作。它是有状态的操作，因为你需要在处理中保存状态来对集合中的元素排序        Stream.of(“d2”, “a2”, “b1”, “b3”, “c”)            .filter(s -> {                System.out.println(“filter: “ + s);                return s.startsWith(“a”);            })            .sorted((s1, s2) -> {                System.out.printf(“sort: %s; %s\n”, s1, s2);                return s1.compareTo(s2);            })            .map(s -> {                System.out.println(“map: “ + s);                return s.toUpperCase();            })            .forEach(s -> System.out.println(“forEach: “ + s));        // 重排调用链来优化性能,这个例子中sorted永远不会调用,极大提升性能    }

java8的数据流不能被复用。一旦你调用了任何终止操作，数据流就关闭了，要克服这个限制，我们需要为每个我们想要执行的终止操作创建新的数据流调用链。例如，我们创建一个数据流供应器，来构建新的数据流，并且设置好所有衔接操作。

/**     * 复用数据流     *      * @author wenqy     * @date 2020年1月17日 上午11:40:02     */    private void streamReuse() {        System.out.println(“—–>streamReuse—–>”);        Stream stream =                Stream.of(“d2”, “a2”, “b1”, “b3”, “c”)                    .filter(s -> s.startsWith(“a”));        stream.anyMatch(s -> true);    // ok//      stream.noneMatch(s -> true);   // exception  java.lang.IllegalStateException: stream has already been operated upon or closed        Supplier> streamSupplier =                () -> Stream.of(“d2”, “a2”, “b1”, “b3”, “c”)                        .filter(s -> s.startsWith(“a”));        // 每次对get()的调用都构造了一个新的数据流，我们将其保存来调用终止操作        streamSupplier.get().anyMatch(s -> true);   // ok        streamSupplier.get().noneMatch(s -> true);  // ok    }

collect

collect是非常有用的终止操作，将流中的元素存放在不同类型的结果中，例如List、Set或者Map。collect接受收集器（Collector），它由四个不同的操作组成：供应器（supplier）、累加器（accumulator）、组合器（combiner）和终止器（finisher）。

/**     * collect是非常有用的终止操作，将流中的元素存放在不同类型的结果中，例如List、Set或者Map。     * collect接受收集器（Collector），它由四个不同的操作组成：     *  供应器（supplier）、累加器（accumulator）、组合器（combiner）和终止器（finisher）     *      * @author wenqy     * @date 2020年1月17日 上午11:45:18     */    private void streamCollect() {        System.out.println(“—–>streamCollect—–>”);        List persons = getPersionList();        List filtered =            persons                .stream()                .filter(p -> p.getFirstName().startsWith(“P”))                .collect(Collectors.toList()); // 构造list        System.out.println(filtered);    // [Person [firstName=Peter, lastName=null, age=23], Person [firstName=Pamela, lastName=null, age=23]]        Map> personsByAge = persons            .stream()            .collect(Collectors.groupingBy(p -> p.getAge())); // 构造map key: age        personsByAge            .forEach((age, p) -> System.out.format(“age %s: %s\n”, age, p));        IntSummaryStatistics ageSummary =            persons                .stream()                .collect(Collectors.summarizingInt(p -> p.getAge()));        System.out.println(ageSummary); // 统计：简单计算最小年龄、最大年龄、算术平均年龄、总和和数量        String phrase = persons            .stream()            .filter(p -> p.getAge() >= 18)            .map(p -> p.getFirstName()) // 键必须是唯一的，否则会抛出IllegalStateException异常            .collect(Collectors.joining(” and “, “In China “, ” are of legal age.”));        System.out.println(phrase); // 所有人连接为一个字符串        Collector personNameCollector =            Collector.of(                () -> new StringJoiner(” | “),          // supplier                (j, p) -> j.add(p.getFirstName().toUpperCase()),  // accumulator                (j1, j2) -> j1.merge(j2),               // combiner                StringJoiner::toString);                // finisher        String names = persons            .stream()            .collect(personNameCollector);        System.out.println(names);  // MAX | PETER | PAMELA | DAVID        // 构建自己特殊收集器。将流中的所有人转换为一个字符串，包含所有大写的名称，并以|分割。    }

flatMap

我们已经了解了如何通过使用map操作，将流中的对象转换为另一种类型。map有时十分受限，因为每个对象只能映射为一个其它对象。但如何我希望将一个对象转换为多个或零个其他对象呢？flatMap这时就会派上用场。

flatMap将流中的每个元素，转换为其它对象的流。所以每个对象会被转换为零个、一个或多个其它对象，以流的形式返回。这些流的内容之后会放进flatMap所返回的流中。

/** * flatMap将流中的每个元素，转换为其它对象的流。 * 所以每个对象会被转换为零个、一个或多个其它对象，以流的形式返回。 * 这些流的内容之后会放进flatMap所返回的流中 *  * @author wenqy * @date 2020年1月17日 下午1:38:09 */private void streamFlatMap() {    System.out.println(“—–>streamFlatMap—–>”);    List foos = new ArrayList<>();    // create foos    IntStream        .range(1, 4)        .forEach(i -> foos.add(new Foo(“Foo” + i)));    // create bars    foos.forEach(f ->        IntStream            .range(1, 4)            .forEach(i -> f.bars.add(new Bar(“Bar” + i + ” <- “ + f.name))));    foos.stream()        .flatMap(f -> f.bars.stream())        .forEach(b -> System.out.println(b.name)); // 将含有三个foo对象中的流转换为含有九个bar对象的流    IntStream.range(1, 4)        .mapToObj(i -> new Foo(“Foo” + i))        .peek(f -> IntStream.range(1, 4)            .mapToObj(i -> new Bar(“Bar” + i + ” <- “ + f.name))            .forEach(f.bars::add)) // 简化为流式操作的单一流水线        .flatMap(f -> f.bars.stream())        .forEach(b -> System.out.println(b.name));    Optional.of(new Outer())        .flatMap(o -> Optional.ofNullable(o.nested))        .flatMap(n -> Optional.ofNullable(n.inner))        .flatMap(i -> Optional.ofNullable(i.foo))        .ifPresent(System.out::println);    // 如果存在的话，每个flatMap的调用都会返回预期对象的Optional包装，    // 否则为null的Optional包装,避免潜在NullPointerException}

reduce

归约操作将所有流中的元素组合为单一结果。Java8支持三种不同类型的reduce方法。

/**     * 归约操作将所有流中的元素组合为单一结果     *      * @author wenqy     * @date 2020年1月17日 下午2:01:23     */    private void streamReduce() {        System.out.println(“—–>streamReduce—–>”);        List persons = getPersionList();        persons            .stream()            .reduce((p1, p2) -> p1.getAge() > p2.getAge() ? p1 : p2)            .ifPresent(System.out::println);    // 计算年龄最大的人 Pamela        Person result =            persons                .stream()                .reduce(new Person(“”, 0), (p1, p2) -> {                    p1.setAge(p1.getAge() + p2.getAge());                    p1.setFirstName(p1.getFirstName() + p2.getFirstName());                    return p1;  // 构造带有聚合后名称和年龄的新Person对象                });        // name=MaxPeterPamelaDavid; age=76        System.out.format(“name=%s; age=%s.\n”, result.getFirstName(), result.getAge());        Integer ageSum = persons            .stream()            .reduce(0, (sum, p) -> sum += p.getAge(), (sum1, sum2) -> sum1 + sum2);        System.out.println(ageSum);  // 计算所有人的年龄总和 76        Integer ageSum2 = persons            .stream()            .reduce(0,                (sum, p) -> {                    System.out.format(“accumulator: sum=%s; person=%s\n”, sum, p);                    return sum += p.getAge();                },                (sum1, sum2) -> {                    System.out.format(“combiner: sum1=%s; sum2=%s\n”, sum1, sum2);                    return sum1 + sum2;                });        System.out.println(ageSum2); // 输出调试信息，combiner并没有输出        Integer ageSum3 = persons            .parallelStream()            .reduce(0,                (sum, p) -> {                    System.out.format(“accumulator: sum=%s; person=%s [%s]\n”, sum, p, Thread.currentThread().getName());                    return sum += p.getAge();                },                (sum1, sum2) -> {                    System.out.format(“combiner: sum1=%s; sum2=%s [%s]\n”, sum1, sum2, Thread.currentThread().getName());                    return sum1 + sum2;                });        System.out.println(ageSum3); // 并行方式    }

parallelStream

流可以并行执行，在大量输入元素上可以提升运行时的性能。并行流使用公共的ForkJoinPool，由ForkJoinPool.commonPool()方法提供。底层线程池的大小最大为五个线程 -- 取决于CPU的物理核数。

组合器函数只在并行流中调用，而不在串行流中调用

/**     * 并行流     *      * @author wenqy     * @date 2020年1月17日 下午2:31:57     */    private void streamParallel() {        System.out.println(“—–>streamParallel—–>”);        ForkJoinPool commonPool = ForkJoinPool.commonPool();        System.out.println(commonPool.getParallelism());    // 底层线程池的大小 — 取决于CPU的物理核数 本机 默认 7         // 可用JVM参数增减 -Djava.util.concurrent.ForkJoinPool.common.parallelism=5        Arrays.asList(“a1”, “a2”, “b1”, “c2”, “c1”)            .parallelStream()            .filter(s -> {                System.out.format(“filter: %s [%s]\n”,                    s, Thread.currentThread().getName());                return true;            })            .map(s -> {                System.out.format(“map: %s [%s]\n”,                    s, Thread.currentThread().getName());                return s.toUpperCase();            })            .forEach(s -> System.out.format(“forEach: %s [%s]\n”,                s, Thread.currentThread().getName()));        // 并行流使用了所有公共的ForkJoinPool中的可用线程来执行流式操作        Arrays.asList(“a1”, “a2”, “b1”, “c2”, “c1”)            .parallelStream()            .filter(s -> {                System.out.format(“filter: %s [%s]\n”,                    s, Thread.currentThread().getName());                return true;            })            .map(s -> {                System.out.format(“map: %s [%s]\n”,                    s, Thread.currentThread().getName());                return s.toUpperCase();            })            .sorted((s1, s2) -> {                System.out.format(“sort: %s <> %s [%s]\n”,                    s1, s2, Thread.currentThread().getName());                return s1.compareTo(s2);            })            .forEach(s -> System.out.format(“forEach: %s [%s]\n”,                s, Thread.currentThread().getName()));        // sort看起来只在主线程上串行执行。实际上，并行流上的sort在背后使用了Java8中新的方法Arrays.parallelSort()。        // 如javadoc所说，这个方法会参照数据长度来决定以串行或并行来执行,如果指定数据的长度小于最小粒度，它使用相应的Arrays.sort方法来排序        // 所有并行流操作都共享相同的JVM相关的公共ForkJoinPool。所以你可能需要避免实现又慢又卡的流式操作，因为它可能会拖慢你应用中严重依赖并行流的其它部分。    }

参考

https://github.com/winterbe/java8-tutorial java8教程

https://wizardforcel.gitbooks.io/modern-java/content/ 中文译站

品茗Java8新特性

Fri, 07 Feb 2020 17:51:14 CST

看了下openjdk官网 http://openjdk.java.net/projects/jdk/14/ jdk14今年就要发布稳定版本了，连java8都没有系统的学习过。那就来学习下java8吧，这是一个长期维护的版本。这里主要来学习java8的一些新特性。对应demo可以下载链接：

https://github.com/wenqy/java-study

接口默认方法

使用default关键字，为接口声明添加非抽象的方法实现接口默认方法

public interface DefaultInterfaceMethod {    double calc(int a);    /**     * 接口使用 default关键字，添加非抽象方法实现（扩展方法）     * @param a     * @return     * @author wenqy     * @date 2020年1月16日 上午9:55:20     */    default double sqrt(int a) {        return Math.sqrt(a);    }}

然后实现匿名内部类，并调用默认方法

DefaultInterfaceMethod interfaceMethod = new DefaultInterfaceMethod() {    @Override    public double calc(int a) {        return sqrt(a * 100);    }};System.out.println(“calc：” + interfaceMethod.calc(100)); // calc：100.0System.out.println(“sqrt：” + interfaceMethod.sqrt(16)); // sqrt：4.0

Lambda表达式

来看下排序的例子，静态工具方法Collections.sort接受一个list，和一个Comparator接口作为输入参数，java8之前需要一个匿名对象，java8可以用Lambda表达式变得简洁

    /**     * Java8之前方法（匿名对象）实现排序     * @param names     * @author wenqy     * @date 2020年1月16日 上午10:07:45     */    private static void sortByBefore8Method(List names) {        Collections.sort(names, new Comparator() {            @Override            public int compare(String a, String b) {                return b.compareTo(a);            }        });    }    /**     * 用Lambda表达式排序，Java编译器能够自动识别参数类型     * @param names     * @author wenqy     * @date 2020年1月16日 上午10:09:40     */    private static void sortByLambda(List names) {//      可以这样写//      Collections.sort(names, (String a, String b) -> {//          return b.compareTo(a);//      });//      也可以这样写//      Collections.sort(names, (String a, String b) -> b.compareTo(a));//      还可以这样写        Collections.sort(names, (a, b) -> b.compareTo(a));    }

Java编译器能够自动识别参数的类型，所以可以省略掉类型不写。

函数式接口

每一个lambda都能够通过一个特定的接口，与一个给定的类型进行匹配。一个所谓的函数式接口必须要有且仅有一个抽象方法声明。每个与之对应的lambda表达式必须要与抽象方法的声明相匹配。由于默认方法不是抽象的，因此你可以在你的函数式接口里任意添加默认方法。

任意只包含一个抽象方法的接口，我们都可以用来做成lambda表达式。为了让你定义的接口满足要求，你应当在接口前加上@FunctionalInterface 标注。编译器会注意到这个标注，如果你的接口中定义了第二个抽象方法的话，编译器会抛出异常。

/** *  * 每一个lambda都能够通过一个特定的接口，与一个给定的类型进行匹配。 * 一个所谓的函数式接口必须要有且仅有一个抽象方法声明。 * 每个与之对应的lambda表达式必须要与抽象方法的声明相匹配。 *  * @FunctionalInterface 标注。 *  编译器会注意到这个标注，如果接口中定义了第二个抽象方法的话，编译器会抛出异常 *  * @version V5.0 * @author wenqy * @date   2020年1月16日 */@FunctionalInterfacepublic interface Converter {    /**     * 类型转换  F->T     * @param from     * @return     * @author wenqy     * @date 2020年1月16日 上午10:22:32     */    T convert(F from);//  T mapping(F from);}

方法和构造函数引用

函数式接口可以通过方法或构造函数引用使代码变得更简洁。Java 8 允许你通过::关键字获取方法或者构造函数的的引用。

static class Something {    String startsWith(String s) {        return String.valueOf(s.charAt(0));    }}private static  void convert(Converter converter, F from) {    T converted = converter.convert(from);    System.out.println(converted);}public static void main(String[] args) {    Converter converter1 = Integer::valueOf; // 静态方法引用    convert(converter1,“123”); // “1”    Something something = new Something();    Converter converter2 = something::startsWith; // 对象方法引用    convert(converter2,“Java”); // “J”    PersonFactory personFactory = Person::new;  // 构造函数引用(构造参数需一致)    Person person = personFactory.create(“Peter”, “Parker”);    System.out.println(person); // Person [firstName=Peter, lastName=Parker]}

Lambda访问范围

对于lambda表达式外部的变量，其访问权限的粒度与匿名对象的方式非常类似。你能够访问局部对应的外部区域的局部final变量，以及成员变量和静态变量。默认方法无法在lambda表达式内部被访问。

我们可以访问lambda表达式外部的final局部变量，但是与匿名对象不同的是，变量num并不需要一定是final，然而，num在编译的时候被隐式地当做final变量来处理。

 static class Lambda {        static int outerStaticNum;        int outerNum;        /**         * 访问成员变量         *          * @author wenqy         * @date 2020年1月16日 上午11:15:31         */        void accessOuterNum() {            Converter converter = (from) -> {                outerNum = 23;                return String.valueOf(outerNum + from);            };            System.out.println(“accessOuterNum：” + converter.convert(2)); // 25//          outerNum = 3;        }        /**         * 访问静态变量         *          * @author wenqy         * @date 2020年1月16日 上午11:18:41         */        void accessOuterStaticNum() {            Converter converter = (from) -> {                outerStaticNum = 72;                return String.valueOf(outerStaticNum + from);            };            System.out.println(“accessOuterStaticNum：” + converter.convert(2)); // 74//          outerStaticNum = 3;        }        /**         * 访问局部变量         *      可以访问lambda表达式外部的final局部变量         *      但是与匿名对象不同的是，变量num并不需要一定是final         * @author wenqy         * @date 2020年1月16日 上午11:06:09         */        void accessLocalVariable() {//          final int num = 1;            int num = 1;            Converter stringConverter =                    (from) -> String.valueOf(from + num);            System.out.println(“accessLocalVariable：” + stringConverter.convert(2));     // 3//          num = 3; // 编译的时候被隐式地当做final变量来处理，无法改变值        }    }    public static void main(String[] args) {        Lambda lambda = new Lambda();        lambda.accessLocalVariable();        lambda.accessOuterNum();        lambda.accessOuterStaticNum();//      默认方法无法在lambda表达式内部被访问,无法通过编译//      DefaultInterfaceMethod formula = (a) -> sqrt( a * 100);    }

内置函数式接口

Java 8 API 还提供了很多新的函数式接口，来降低程序员的工作负担。让我们来看下几个内置的函数式接口

Predicate是一个布尔类型的函数，该函数只有一个输入参数。Predicate接口包含了多种默认方法，用于处理复杂的逻辑动词（and, or，negate）

Function接口接收一个参数，并返回单一的结果。默认方法可以将多个函数串在一起（compse, andThen）

Supplier接口产生一个给定类型的结果。与Function不同的是，Supplier没有输入参数

Consumer代表了在一个输入参数上需要进行的操作

Comparator接口在早期的Java版本中非常著名。Java 8 为这个接口添加了不同的默认方法

Optional不是一个函数式接口，而是一个精巧的工具接口，用来防止NullPointerException产生。他是一个简单的值容器，这个值可以是null，也可以是non-null。考虑到一个方法可能会返回一个non-null的值，也可能返回一个空值。为了不直接返回null，我们在Java 8中就返回一个Optional

/**     * 布尔类型函数     *      * @author wenqy     * @date 2020年1月16日 上午11:39:26     */    private static void testPredicates() {        System.out.println(“——>testPredicates——>”);        Predicate predicate = (s) -> s.length() > 0;        System.out.println(predicate.test(“foo”)); // true        System.out.println(predicate.negate().test(“foo”)); // false        Predicate nonNull = Objects::nonNull;        Predicate isNull = Objects::isNull;        System.out.println(nonNull.test(null)); // false        System.out.println(isNull.test(null)); // true        Predicate isEmpty = String::isEmpty;        Predicate isNotEmpty = isEmpty.negate();        System.out.println(isEmpty.test(“”)); // true        System.out.println(isNotEmpty.test(“”)); // false    }    /**     * 内置 Function 函数，将多个函数串联     *      * @author wenqy     * @date 2020年1月16日 上午11:41:35     */    private static void testFunctions() {        System.out.println(“——>testFunctions——>”);        Function toInteger = Integer::valueOf;        Function backToString = toInteger.andThen(String::valueOf);        System.out.println(backToString.apply(“123”));     // “123”    }    /**     * 内置 Supplier 函数     *  产生一个给定类型的结果     * @author wenqy     * @date 2020年1月16日 上午11:52:51     */    private static void testSuppliers() {        System.out.println(“——>testSuppliers——>”);        Supplier personSupplier = Person::new;        Person person = personSupplier.get();   // new Person        person.setFirstName(“wen”);        person.setLastName(“qy”);        System.out.println(person);    }    /**     * 内置 Consumer 函数     *  输入参数上需要进行操作     * @author wenqy     * @date 2020年1月16日 下午1:48:33     */    private static void testConsumers() {        System.out.println(“——>testConsumers——>”);        Consumer greeter = (p) -> System.out.println(“Hello, “ + p.getFirstName());        greeter.accept(new Person(“Luke”, “Skywalker”));    }    /**     *      * 内置 Comparator 函数     *      用于比较     * @author wenqy     * @date 2020年1月16日 下午1:54:29     */    private static void testComparators() {        System.out.println(“——>testComparators——>”);        Comparator comparator = (p1, p2) -> p1.getFirstName().compareTo(p2.getFirstName());        Person p1 = new Person(“John”, “Doe”);        Person p2 = new Person(“Alice”, “Wonderland”);        System.out.println(comparator.compare(p1, p2)); // > 0        System.out.println(comparator.reversed().compare(p1, p2)); // < 0    }    /**     * Optional     *  值容器，用来防止NullPointerException产生     * @author wenqy     * @date 2020年1月16日 下午1:58:44     */    private static void testOptionals() {        System.out.println(“——>testOptionals——>”);        Optional optional = Optional.of(“bam”);        System.out.println(optional.isPresent()); // true        System.out.println(optional.get()); // “bam”        System.out.println(optional.orElse(“fallback”)); // “bam”        optional.ifPresent((s) -> System.out.println(s.charAt(0)));     // “b”    }

流Stream

java.util.Stream表示了某一种元素的序列，在这些元素上可以进行各种操作。Stream操作可以是中间操作，也可以是完结操作。完结操作会返回一个某种类型的值，而中间操作会返回流对象本身，并且你可以通过多次调用同一个流操作方法来将操作结果串起来（就像StringBuffer的append方法一样）。Stream是在一个源的基础上创建出来的，例如java.util.Collection中的list或者set（map不能作为Stream的源）。Stream操作往往可以通过顺序或者并行两种方式来执行。Stream并不会改变原有的序列。

List stringCollection = new ArrayList<>();public StreamsMain() {    init();}private void init() {    if (stringCollection.isEmpty()) {        stringCollection.add(“ddd2”);        stringCollection.add(“aaa2”);        stringCollection.add(“bbb1”);        stringCollection.add(“aaa1”);        stringCollection.add(“bbb3”);        stringCollection.add(“ccc”);        stringCollection.add(“bbb2”);        stringCollection.add(“ddd1”);    }}/** *  * Filter接受一个predicate接口类型的变量，并将所有流对象中的元素进行过滤。 * 该操作是一个中间操作，因此它允许我们在返回结果的基础上再进行其他的流操作（forEach）。 * ForEach接受一个function接口类型的变量，用来执行对每一个元素的操作。 * ForEach是一个中止操作。它不返回流，所以我们不能再调用其他的流操作。 * @author wenqy * @date 2020年1月16日 下午2:34:58 */private void testFilter() {    System.out.println(“—–>testFilter—–>”);    stringCollection        .stream()        .filter((s) -> s.startsWith(“a”)) // 过滤以“a”开头的集合        .forEach(System.out::println);}/** * Sorted是一个中间操作，能够返回一个排过序的流对象的视图。 * 流对象中的元素会默认按照自然顺序进行排序，除非你自己指定一个Comparator接口来改变排序规则 *  * @author wenqy * @date 2020年1月16日 下午2:38:28 */private void testSorted() {    System.out.println(“—–>testSorted—–>”);    stringCollection        .stream()        .sorted() // 自然排序        .filter((s) -> s.startsWith(“a”)) // 过滤以“a”开头的集合        .forEach(System.out::println);    // sorted不会改变原来集合中元素的顺序。原来string集合中的元素顺序是没有改变的。    System.out.println(stringCollection);}/** * map是一个对于流对象的中间操作，通过给定的方法，它能够把流对象中的每一个元素对应到另外一个对象上。 * 下面的例子就演示了如何把每个string都转换成大写的string.  * 不但如此，你还可以把每一种对象映射成为其他类型。 * 对于带泛型结果的流对象，具体的类型还要由传递给map的泛型方法来决定。 *  * @author wenqy * @date 2020年1月16日 下午2:43:38 */private void testMap() {    System.out.println(“—–>testMap—–>”);    stringCollection        .stream()        .map(String::toUpperCase) // 每个元素转大写        .sorted((a, b) -> b.compareTo(a))        .forEach(System.out::println);    // sorted不会改变原来集合中元素的顺序。原来string集合中的元素顺序是没有改变的。    System.out.println(stringCollection);}/** * 匹配操作有多种不同的类型，都是用来判断某一种规则是否与流对象相互吻合的。 * 所有的匹配操作都是终结操作，只返回一个boolean类型的结果。 *  * @author wenqy * @date 2020年1月16日 下午2:47:48 */private void testMatch() {    System.out.println(“—–>testMatch—–>”);    boolean anyStartsWithA =        stringCollection            .stream()            .anyMatch((s) -> s.startsWith(“a”));    System.out.println(anyStartsWithA);      // true    boolean allStartsWithA =        stringCollection            .stream()            .allMatch((s) -> s.startsWith(“a”));    System.out.println(allStartsWithA);      // false    boolean noneStartsWithZ =        stringCollection            .stream()            .noneMatch((s) -> s.startsWith(“z”));    System.out.println(noneStartsWithZ);      // true}/** * Count是一个终结操作，它的作用是返回一个数值，用来标识当前流对象中包含的元素数量。 *  * @author wenqy * @date 2020年1月16日 下午2:51:40 */private void testCount() {    System.out.println(“—–>testCount—–>”);    long startsWithB =        stringCollection            .stream()            .filter((s) -> s.startsWith(“b”))            .count();    System.out.println(startsWithB);    // 3}/** * 该操作是一个终结操作，它能够通过某一个方法，对元素进行削减操作。 * 该操作的结果会放在一个Optional变量里返回。 *  * @author wenqy * @date 2020年1月16日 下午2:54:00 */private void testReduce() {    System.out.println(“—–>testReduce—–>”);    Optional reduced =        stringCollection            .stream()            .sorted()            .reduce((s1, s2) -> s1 + “#” + s2);    reduced.ifPresent(System.out::println); // “aaa1#aaa2#bbb1#bbb2#bbb3#ccc#ddd1#ddd2”}

并发流Stream

数量量大时，可以使用并行流进行操作来提高运行效率。

//  int max = 1000000; // 大数据量并发才有优势    int max = 400000;    List values = new ArrayList<>(max);    public ParallelStreamsMain() {        init();    }    private void init() {        for (int i = 0; i < max; i++) {            UUID uuid = UUID.randomUUID();            values.add(uuid.toString());        }    }    /**     * 顺序排序     *      * @author wenqy     * @date 2020年1月16日 下午3:20:22     */    private void sequenceSorted() {        System.out.println(“——>sequenceSorted—–>”);        long t0 = System.nanoTime();        long count = values.stream().sorted().count();        System.out.println(count);        long t1 = System.nanoTime();        long millis = TimeUnit.NANOSECONDS.toMillis(t1 – t0);        System.out.println(String.format(“sequential sort took: %d ms”, millis));    }    /**     * 并行排序     *      * @author wenqy     * @date 2020年1月16日 下午3:21:56     */    private void parallelSorted() {        System.out.println(“——>parallelSorted—–>”);        long t0 = System.nanoTime();        long count = values.parallelStream().sorted().count();        System.out.println(count);        long t1 = System.nanoTime();        long millis = TimeUnit.NANOSECONDS.toMillis(t1 – t0);        System.out.println(String.format(“parallel sort took: %d ms”, millis));    }

Map

map是不支持流操作的。而更新后的map现在则支持多种实用的新方法

Map map = new HashMap<>();for (int i = 0; i < 10; i++) {    map.putIfAbsent(i, “val” + i); // 旧值存在时返回旧值，不进行替换}map.forEach((id, val) -> System.out.println(val));map.computeIfPresent(3, (num, val) -> val + num);map.get(3);             // val33map.computeIfPresent(9, (num, val) -> null); // 返回null时，remove(key)map.containsKey(9);     // falsemap.computeIfAbsent(23, num -> “val” + num);map.containsKey(23);    // truemap.computeIfAbsent(3, num -> “bam”); // 旧值存在时返回旧值，不进行替换map.get(3);             // val33map.remove(3, “val3”);  // 校验value删除map.get(3);             // val33map.remove(3, “val33”);map.get(3);             // nullmap.getOrDefault(42, “not found”);  // not found 不存在则返回默认值map.merge(9, “val9”, (value, newValue) -> value.concat(newValue)); // 先前key 9 已经删除了，不存在key，则返回 valueSystem.out.println(map.get(9));             // val9map.merge(9, “concat”, (value, newValue) -> value.concat(newValue)); // 存在key,才进行合并System.out.println(map.get(9));             // val9concat

时间日期API

Java 8 包含了全新的时间日期API，这些功能都放在了java.time包下。新的时间日期API是基于Joda-Time库开发的，但是也不尽相同。

/** * Clock提供了对当前时间和日期的访问功能。Clock是对当前时区敏感的 *  * @author wenqy * @date 2020年1月16日 下午4:36:49 */private static void testClock() {    System.out.println(“—–>testClock—–>”);    Clock clock = Clock.systemDefaultZone();    long millis = clock.millis();    System.out.println(millis); // 获取当前毫秒时间    Instant instant = clock.instant();    Date date = Date.from(instant);   // java.util.Date    System.out.println(date); // 获取日期 Thu Jan 16 16:38:01 CST 2020}/** * 时区类可以用一个ZoneId来表示。 * 时区类还定义了一个偏移量，用来在当前时刻或某时间与目标时区时间之间进行转换。 *  * @author wenqy * @date 2020年1月16日 下午4:40:38 */private static void testTimezones() {    System.out.println(“—–>testTimezones—–>”);    System.out.println(ZoneId.getAvailableZoneIds());    // prints all available timezone ids    ZoneId zone1 = ZoneId.of(“Europe/Berlin”);    ZoneId zone2 = ZoneId.of(“Brazil/East”);    ZoneId zone3 = ZoneId.of(“Asia/Shanghai”);    System.out.println(zone1.getRules());    System.out.println(zone2.getRules());    System.out.println(zone3.getRules());}/** * 本地时间类表示一个没有指定时区的时间 *  * @author wenqy * @date 2020年1月16日 下午4:49:11 */private static void testLocalTime() {    System.out.println(“—–>testLocalTime—–>”);    LocalTime now1 = LocalTime.now(ZoneId.of(“Europe/Berlin”));    LocalTime now2 = LocalTime.now(ZoneId.of(“Asia/Shanghai”));    // 比较两个时间    System.out.println(now1.isBefore(now2));  // true    long hoursBetween = ChronoUnit.HOURS.between(now1, now2);    long minutesBetween = ChronoUnit.MINUTES.between(now1, now2);    // 柏林时区在东一区，上海时区在东八区   柏林比北京时间慢7小时    System.out.println(hoursBetween);       // 7    System.out.println(minutesBetween);     // 420    // 时间字符串解析操作    LocalTime late = LocalTime.of(23, 59, 59);    System.out.println(late);       // 23:59:59    DateTimeFormatter germanFormatter =        DateTimeFormatter            .ofLocalizedTime(FormatStyle.SHORT)            .withLocale(Locale.GERMAN);    LocalTime leetTime = LocalTime.parse(“13:37”, germanFormatter);    System.out.println(leetTime);   // 13:37}/** * 本地日期 *  每一次操作都会返回一个新的时间对象 *  * @author wenqy * @date 2020年1月16日 下午5:05:52 */private static void testLocalDate() {    System.out.println(“—–>testLocalDate—–>”);    LocalDate today = LocalDate.now(); // 今天    LocalDate tomorrow = today.plus(1, ChronoUnit.DAYS); // 明天=今天+1    LocalDate yesterday = tomorrow.minusDays(2); // 昨天=明天-2    System.out.println(yesterday);    LocalDate independenceDay = LocalDate.of(2014, Month.JULY, 4);    DayOfWeek dayOfWeek = independenceDay.getDayOfWeek(); // 获取周    System.out.println(dayOfWeek); // FRIDAY}/** * 日期-时间 *  final对象 * @author wenqy * @date 2020年1月16日 下午5:12:37 */private static void testLocalDateTime() {    System.out.println(“—–>testLocalDateTime—–>”);    LocalDateTime sylvester = LocalDateTime.of(2019, Month.DECEMBER, 31, 23, 59, 59);    DayOfWeek dayOfWeek = sylvester.getDayOfWeek();    System.out.println(dayOfWeek);      // TUESDAY    Month month = sylvester.getMonth();    System.out.println(month);          // DECEMBER    long minuteOfDay = sylvester.getLong(ChronoField.MINUTE_OF_DAY);    System.out.println(minuteOfDay);    // 1439    // 加上时区，转日期Date    Instant instant = sylvester            .atZone(ZoneId.systemDefault())            .toInstant();    Date legacyDate = Date.from(instant);    System.out.println(legacyDate);     // Tue Dec 31 23:59:59 CST 2019    // 自定义格式对象    DateTimeFormatter formatter =        DateTimeFormatter            .ofPattern(“yyyy-MM-dd HH:mm:ss”);  // 线程安全，不可变    LocalDateTime parsed = LocalDateTime.parse(“2020-01-16 17:13:00”, formatter);    String string = formatter.format(parsed);    System.out.println(string);     // 2020-01-16 17:13:00}

可重复注解

Java 8中的注解是可重复的

/** * @Repeatable，Java 8 允许我们对同一类型使用多重注解 *  * @version V5.0 * @author wenqy * @date   2020年1月16日 */@Repeatable(Hints.class)@Retention(RetentionPolicy.RUNTIME) // 需要指定runtime,否则测试会失败public @interface Hint {    String value();}

在Person类添加注解，尝试获取类注解

/** * @Hint 可重复注解（新方法） * 使用注解容器（老方法）: @Hints({@Hint(“hint1”), @Hint(“hint2”)}) * @version V5.0 * @author wenqy * @date   2020年1月16日 */@Hint(“hint1”)@Hint(“hint2”)//@Hints({@Hint(“hint1”), @Hint(“hint2”)})public class Person {    // …}Hint hint = Person.class.getAnnotation(Hint.class);System.out.println(hint);                   // nullHints hints1 = Person.class.getAnnotation(Hints.class);System.out.println(hints1.value().length);  // 2Hint[] hints2 = Person.class.getAnnotationsByType(Hint.class);System.out.println(hints2.length);          // 2

String

java8添加了对字符数据流的流式操作

System.out.println(String.join(“:”, “foobar”, “foo”, “bar”)); // foobar:foo:bar        // 指定分割符，将字符串拼接        System.out.println(                “foobar:foo:bar”                .chars() // 字符数据流                .distinct()                .mapToObj(c -> String.valueOf((char)c))                .sorted()                .collect(Collectors.joining())                ); // :abfor        System.out.println(                Pattern.compile(“:”)                .splitAsStream(“foobar:foo:bar”)                .filter(s -> s.contains(“bar”))                .sorted()                .collect(Collectors.joining(“:”))            ); // bar:foobar        System.out.println(                Stream.of(“bob@gmail.com”, “alice@hotmail.com”)                    .filter(Pattern.compile(“.*@gmail\\.com”).asPredicate())                    .count()            ); // 1

数值处理

Java8添加了对无符号数的额外支持。新增了一些方法来处理数值溢出

System.out.println(Integer.MAX_VALUE);      // 2147483647        System.out.println(Integer.MAX_VALUE + 1);  // -2147483648        long maxUnsignedInt = (1l << 32) – 1; //         String string = String.valueOf(maxUnsignedInt);        int unsignedInt = Integer.parseUnsignedInt(string, 10); // 无符号转换        String string2 = Integer.toUnsignedString(unsignedInt, 10);        System.out.println(string2);        try {            Integer.parseInt(string, 10);        } catch (NumberFormatException e) {            System.err.println(“could not parse signed int of “ + maxUnsignedInt);        }        try {            Math.addExact(Integer.MAX_VALUE, 1);        }        catch (ArithmeticException e) {            System.err.println(e.getMessage());            // => integer overflow        }        try {            Math.toIntExact(Long.MAX_VALUE);        }        catch (ArithmeticException e) {            System.err.println(e.getMessage());            // => integer overflow        }

文件处理

java8新增了对文件处理的方法

/** * 文件查找 * @throws IOException * @author wenqy * @date 2020年1月18日 下午3:02:05 */private static void findFiles() throws IOException {    Path start = Paths.get(“”);    int maxDepth = 5;    try (Stream stream = Files.find(start, maxDepth, (path, attr) ->            String.valueOf(path).endsWith(“.js”))) {        String joined = stream            .sorted()            .map(String::valueOf)            .collect(Collectors.joining(“; “));        System.out.println(“Found: “ + joined);    }}/** * 获取文件列表 * @throws IOException * @author wenqy * @date 2020年1月18日 下午3:02:26 */private static void listFiles() throws IOException {    try (Stream stream = Files.list(Paths.get(“”))) {        String joined = stream            .map(String::valueOf)            .filter(path -> !path.startsWith(“.”))            .sorted()            .collect(Collectors.joining(“; “));        System.out.println(“List: “ + joined);        // 列出了当前工作目录的所有文件，之后将每个路径都映射为它的字符串表示。之后结果被过滤、排序，最后连接为一个字符串    }}/** * 文件读写处理 * @throws IOException * @author wenqy * @date 2020年1月18日 下午3:02:52 */private static void handleFiles() throws IOException {    List lines = Files.readAllLines(Paths.get(“res/nashorn1.js”)); // 整个文件都会读进内存,不高效。文件越大，所用的堆区也就越大    lines.add(“print(‘foobar’);”);    Files.write(Paths.get(“res/nashorn1-modified.js”), lines);    try (Stream stream = Files.lines(Paths.get(“res/nashorn1.js”))) { // 行读取，高效点        stream            .filter(line -> line.contains(“print”))            .map(String::trim)            .forEach(System.out::println);    }    try (BufferedReader reader = Files.newBufferedReader(Paths.get(“res/nashorn1.js”))) { // BufferedReader 更精细        System.out.println(reader.readLine());    }    Path pathOut = Paths.get(“res/output.js”);    try (BufferedWriter writer = Files.newBufferedWriter(pathOut)) { // BufferedWriter 写入文件        writer.write(“print(‘Hello World’);”);    }    try (BufferedReader reader = Files.newBufferedReader(Paths.get(“res/nashorn1.js”))) {        long countPrints = reader            .lines() // 流式处理            .filter(line -> line.contains(“print”))            .count();        System.out.println(countPrints);    }}

避免 Null 检查

java8之前，如果是多层内嵌对象，需要多次判空，引入Optional 类型提高安全性

public static void main(String[] args) {    Outer outer = new Outer();    if (outer != null && outer.nested != null && outer.nested.inner != null) {        System.out.println(outer.nested.inner.foo);    }    Optional.of(new Outer())        .map(Outer::getNested)        .map(Nested::getInner)        .map(Inner::getFoo)        .ifPresent(System.out::println);    Outer obj = new Outer();    resolve(() -> obj.getNested().getInner().getFoo())        .ifPresent(System.out::println);    // 这两个解决方案可能没有传统 null 检查那么高的性能}private static  Optional resolve(Supplier resolver) {    try {        T result = resolver.get();        return Optional.ofNullable(result);    }    catch (NullPointerException e) {        return Optional.empty();    }}

初识java8新特性，java8语法糖还是挺香的，java8之前方法调用一堆的回调，让人看的眼花缭乱，不整洁。但让人想吐槽的是调试，加难了调试力度，可能是新手错觉。。。

参考

https://github.com/winterbe/java8-tutorial java8教程

https://wizardforcel.gitbooks.io/modern-java/content/ 中文译站

https://github.com/wenqy/java-study

Git学步

Thu, 06 Feb 2020 23:37:16 CST

Git 是一款开源的分布式版本控制系统，是Linux之父Linus开发的版本控制软件，为帮助管理Linux内核开发而诞生，这期间有故事，当然，这不是我记录文章的重点，我只是感慨：牛逼！

这里只是记录Git学习的常用命令，话说20%的命令可以涵盖80%的场景，二八定律套一套，就可少学一套！这里不会记录Git的安装，也不会记载与SVN等其他版本控制系统的区别，只是学一学别人的步伐，具体深究详情可参考链接。

创建版本库

初始化本地仓库，当前目录下多了一个.git的目录

git init

将新建文件加入到Index暂存区

git add testgitaddfile.txt

将暂存区提交到当前分支版本库，创建Git版本库时，Git自动为我们创建了唯一一个master分支

git commit -m "add file"

提交流程可以由下面简图标识：

推送到远程关联的主分支

git push -u origin master

这里我已经绑定了自己安装的Gitlab，同步到Gitlab服务器

登录Gitlab查看，查看确实提交上去了

状态与比较

修改testgitaddfile.txt文件内容后，查看状态，如看文件是否修改过

git status

上图结果输出，可知，testgitaddfile.txt被修改过了，但还没有准备提交的修改。

我们可以进行文件比较，查看修改内容

git diff testgitaddfile.txt

可以看出距离上次文件修改添加了内容"I miss you very much!"

再次添加文件到暂存区git add testgitaddfile.txt后，查看状态，变成未提交：

再次git commit testgitaddfile.txt后，状态变成没有未提交的文件，工作区是干净的：

git diff 是只比较比较工作区和暂存区（最后一次add）的区别，git diff --cached 是只比较暂存区和版本库的区别，git diff HEAD -- filename 是只比较工作区和版本库（最后一次commit）的区别。

修改工作区testgitaddfile.txt文件内容后，再次比较：

暂存区和版本库当前分支比较没有变化，工作区和暂存区、工作区和版本库当前分支比较都发生变化了。

git add 文件，提交到暂存区后，继续比较：

工作区和暂存区比较没有变化，版本库当前分支和暂存区、工作区和版本库当前分支比较都发生变化了。

回退与撤销

我们可以先查看提交的版本历史记录，--pretty=oneline 进行单行输出，比较方便

git log --pretty=oneline

commit id版本号计算出一串十六进制数字。

HEAD表示当前版本上一个版本就是HEAD^ 上上一个版本就是HEAD^^，当然往上100个版本写100个^比较容易数不过来，所以写成HEAD~100

回退上一个版本，这样历史就可以重写了

git reset --hard HEAD^

历史是可以重写了，但是难免后悔，总想回到最后发生的剧本，蓦然回首才发现，最初注定的结局才是最香的。查看命令历史，并回到最新版本

git reloggit reset --hard ff9e036

人无完人，犯错总是难免的，工作区内容改错了，就原谅你，权当没有发生。我们需要撤销修改，回到最后一次add状态，直接丢弃工作区的修改

git checkout -- testgitaddfile.txt

没有--，就变成了"切换到另一个分支"的命令，撤销工作区修改注意加上--

git reset命令既可以回退版本，也可以把暂存区的修改回退到工作区。当我们用HEAD时，表示最新的版本

当你不仅改乱了工作区文件的内容，还添加到了暂存区时，想丢弃修改，分两步，第一步用命令git reset HEAD ，回退暂存区，第二步操作git checkout -- 回退工作区。

已经提交了不合适的修改到版本库时，直接版本回退，体验不同的平行空间吧

删除文件

当某些不和适宜的文件需要丢弃时，就需要删除，也要提交到版本库

用rm 命令删掉文件后，查看文件状态

文件处于删除状态，需要把版本库的文件也删了

git rm test.txtgit commit -m "remove test.txt"

在Git世界了后悔药总是可以吃的，可以恢复版本库中被删除的文件

git checkout -- test.txt

我们只能恢复到文件的最新版本，你会丢失最近一次提交后修改的内容

远程仓库

我们可以在码云gitee创建新的仓库，如testproject

对于如何在gitee或github上创建账号，生成ssh key并把公钥key放至对应的账号配置中就自行参考了，关联远程仓库并推送

git remote add gitee git@gitee.com:wenqygitee/testproject.gitgit push -u gitee master

-u参数，Git不但会把本地的master分支内容推送的远程新的master分支，把本地的master分支和远程的master分支关联起来

登录Gitee查看，发现推送成功啦

查看远程库地址

git remote -v

取消远程库关联

git remote rm origin

关联多个远程库时，可以未不同的远程库关联不同的名，也可以取消关联，重新绑定。

克隆远程库

克隆自建Gitlab的仓库项目

git clone git@xx.xxx.xxx.xxx:root/testproject.git

分支管理

创建并切换分支，-b参数表示创建并切换

git checkout -b dev

相当于两条命令

git branch devgit checkout dev

列出所有分支，当前分支前面会标一个*号

git branch

git merge dev 指定分支合并到当前分支

git merge --no-ff -m "merge with no-ff" dev

默认Fast forward模式，但这种模式下，删除分支后，会丢掉分支信息，--no-ff参数，表示禁用Fast forward模式，git log分支历史上就可以看出合并的分支信息

删除分支

git branch -d dev

新版本还可以用switch切换分支

git switch -c dev

多人协作，对同一份内容同时修改，多分支合并等，难免会发生冲突：

Git用<<<<<<<，=======，>>>>>>>标记出冲突文件里不同分支的内容，修改冲突的文件内容后，再次提交，解决冲突

可以用git log查看分支合并情况

git log --graph --pretty=oneline --abbrev-commit

Bug分支

通常手工工作进行中时，会插入紧急bug任务需要修复，这时可以先保存开发现场，创建修复分支修复bug，然后在切回开发分支，保存dev分支修改，切换master分支后，创建issue分支，并在issue分支上进行bug修复，并合并到master分支

先在dev分支上保存现场

git stash

切换master分支后，创建issue分支

git checkout mastergit checkout -b issue

修复bug后，切回master分支，并将issue分支合并到master分支

git checkout mastergit merge --no-ff -m "merged bug fixed" issue

合并完后，切换回dev分支，恢复之前进行到一半的现场，可以继续开发啦

git stash listgit stash pop

dev分支是早期从master分支分出来的，这个bug在dev分支上也可能存在。我们可以快速复制一个特定的提交到当前分支来修复bug，复制指定commit id的修改

git cherry-pick a82f58c

操作时，由于dev分支修改的是同一份内容，发生冲突了，修改内容后重新提交

通常开发新特性，新功能，我们可以新建feature分支上开发

有时候分支还没合并就需要删除，提示删除不了，这时需要强制删除分支，-D 强制删除

git branch -D feature-one

推送分支

git push gitee dev

推送失败时可能你的小伙伴的最新提交和你试图推送的提交有冲突，可以先git pull 抓取最新分支，解决冲突，

git pull也失败了，原因是没有指定本地dev分支与远程gitee/dev分支的链接，关联链接

git branch --set-upstream-to=gitee/dev dev

标签管理

发布一个版本时，我们通常先在版本库中打一个标签（tag），标签也是版本库的一个快照。

git tag 就可以打一个新标签

git tag v1.0.0

查看所有标签

git tag

默认标签是打在最新提交的commit上的。有时候，如果忘了打标签，可以先找到历史提交的commit id，然后打上就可以

git tag v0.0.9 42dee2a

查看标签信息

git show v1.0.0

删除标签

git tag -d v0.0.9

推送标签到远程

git push gitee v1.0.0

推送所有标签到远程

git push origin --tags

删除远程标签，本地也需先删

git tag -d v1.0.0git push gitee :refs/tags/v1.0.0

查看远程分支

git ls-remote

忽略文件

忽略某些文件，不需要加入到版本控制时，需要编写.gitignore文件，.gitignore文件本身要放到版本库里，并且可以对.gitignore做版本管理！

可以查看别人整理的gitignore文件：https://github.com/github/gitignore

配置别名

对于git命令，有些难记的，可以偷懒取巧，取个别名

git config --global alias.st statusgit config --global alias.co checkoutgit config --global alias.ci commitgit config --global alias.br branchgit config --global alias.last 'log -1'git config --global alias.lg "log --color --graph --pretty=format:'%Cred%h%Creset -%C(yellow)%d%Creset %s %Cgreen(%cr) %C(bold blue)<%an>%Creset' --abbrev-commit"

配置Git的时候，加上--global是针对当前用户起作用的，如果不加，那只针对当前的仓库起作用

每个仓库的Git配置文件都放在.git/config文件中

我们学习了常用的Git命令，知道了查看状态和比较，版本的回退和撤销，关联远程库，对分支和标签进行管理，还编写了忽略版本的文件，配置命令别名等等。Git学习，需要深究可以查看官网手册。

参考

https://git-scm.com/docs 官方文档
https://www.liaoxuefeng.com/wiki/896043488029600 廖雪峰Git教程
https://www.runoob.com/git/git-tutorial.html 菜鸟教程
https://time.geekbang.org/course/intro/100021601 玩转Git三剑客（付费视频教程）
https://learngitbranching.js.org/ Git教学网
https://backlog.com/git-tutorial/cn/ 猴子都能懂的GIT入门

伤心总是难免的，你又何必一往情深

Tue, 01 Oct 2019 23:21:07 CST

网站是很久没维护的，这是事实，幸运的是，总有人提醒我，你曾经拥有自己网站。跟往常一样的夜晚，刷着视频，突然间，一条不速之短信消息弹了出来，抬头就是【万网】，心里顿时咯噔了下，难道阿里催着续费了？细细一看，"因超标消耗资源已关停，请及时处理"这消息显得格外的醒目和刺眼。访问量应该不大啊，网站是很久没更新了，没理由挂掉啊。访问下首页，心碎了一地：

算了，停了就停了，拖延症让我度过了一星期，让【小温之家】自身自灭了一星期。终于一星期后我登录了阿里云万网控制台，重新点亮了网站，稍微看了下访问页，资源异常当天，原来是我上传的jdk8 api访问量异常高，没想到还挺有用的，呵呵。没在意，闪人。

就这样云淡风轻的过了几天，然而该来的终究又还是来了，不速之客还是敲响了我的手机。"见鬼了，怎么又不行了，都想骂娘了都"。珊珊地又等到了周末，仔细看了些访问请求，原来，我是攻击了啊，还好没种码。这些都是异常的访问请求：

http://blog.wenqy.com/upload/2020/11/execption-access-request-ecf152659ed941a6afa620075533b8f5.png

这是另外一些：

再看下当时的访问请求日志：

还有其他的：

三番五次的被搞，我已无能为力。鄙人不才也无法深究，刨根问底。姑且认为你是南京小妹妹吧，不是肉鸡，真不愿相信自己是被殃及池鱼的那个，你成功的吸引了我的注意，让我写下这篇无聊的回忆，愿你被这个世界温柔以待，我是爱你的。发布的今天是举国同庆的节日，愿你与世界不可分割！

PS：who can help me（程序猿何苦为难程序猿）?

Elasticjob安装与入门

Sat, 30 Jun 2018 23:17:32 CST

Elasticjob是一个开源的分布式调度解决方案。Elasticjob由两个相互独立的子项目Elastic-Job-Lite和Elastic-Job-Cloud组成。Elastic-Job-Lite定位为轻量级无中心化解决方案，使用jar包的形式提供分布式任务的协调服务；Elastic-Job-Cloud采用自研Mesos Framework的解决方案，额外提供资源治理、应用分发以及进程隔离等功能。

值得八卦的是，github上Elasticjob的Title已经隐去了当当的商标，而author的Title也已转向了京东，难道跟当当的"卖身"有关？而github版本已由release版2.1.5大跃进成3.0.0.M1开发版，是要断舍离，再出发的节奏吗？

现在主要介绍Elastic-Job-Lite，它支持多种任务类型，支持任务分片，可以将任务拆分成多个子任务，像原先介绍的Quartz集群方案中可能存在的任务处理的单机极限问题，可以利用Elastic-Job-Lite解决，可以通过预先分配分片项参数，任务分片后，每个分片任务只处理跟自己相关的分片数据，这样就可以将单机处理的数据，分散成多机处理，缓解压力。Elastic-Job还支持分片级别的故障切换，具有容错性，一个分片任务故障后，可以被其他机器的任务接管，继续执行分片任务。

实现原理

作业启动

下面摘自官网链接的实现原理解析图。Elastic-Job-Lite依赖注册中心来感知作业节点间的关系，选举主节点来分配分片项。作业服务器启动后，会持久化作业任务到注册中心，作业任务的添加是由作业服务器启动来完成。它的控制台页面也没有作业添加的功能。

作业执行

Elastic-Job-Lite内核是quartz，它默认实现了quartz job接口的任务适配器，抓取分片后，从JobDataMap中取出不同的任务类型，进行分发处理。

下载安装

从github官网上https://github.com/elasticjob/elastic-job-lite下载源码，可以选择导入elastic-job-lite工程到IDE开发环境，子模块elastic-job-lite-console为控制台界面管理工程，用maven管理，mvn install在idea是可以直接编译成功的，但eclipse却提示了gpg plugin报错，可以选择去掉maven-gpg-plugin插件

也可以选择编译时跳过插件mvn install -Dgpg.skip

解压缩mvn install生成的elastic-job-lite-console-$.tar.gz并执行其中的启动脚本bin\start.bat。打开浏览器访问http://localhost:8899/即可访问控制台

默认提供了访问账号

类型	账号
管理员	root/root
访客	guest/guest

可以在elastic-job-lite-console的配置文件conf\auth.properties中修改账号

配置注册中心

配置注册中心地址，暂时只能是zookeeper。可以使用Elastic内置的zookeeper，也可以自己单独启动，这里的指向地址要与项目启动指向的注册中心地址一致。

配置数据源

事件追踪数据源配置，用于记录任务历史，只能是mysql类型数据库，向地址要与项目启动指向的事件追踪数据源地址一致

项目启动

下载https://github.com/elasticjob/elastic-job-example示例工程

elastic-job-example-lite-springboot工程，application.yml修改注册中心地址，事件追踪数据源地址，配置作业任务的分片项参数和分片总数以及Cron表达式等等，com.dangdang.ddframe.job.example.SpringBootMain 项目启动：

在控制台上可以查看已经注册的作业任务和作业服务器

作业详情

查看作业详情，可以查看分片项执行的情况

任务失效

可以将任务失效为暂停状态，已失效任务可以重新生效。

作业修改

作业修改，可以修改作业的cron表达式，作业分片数等等。

对于已失效或生效任务，可以选择触发任务，进行手动触发任务一次，而无需等待触发时间的到来，但对于终止任务，一旦终止，任务就完全作废了。

作业日志

可以查看任务触发的日志，查看任务执行结果。

可以查看任务的历史状态，是等待运行，还是运行中，还是已完成等待。

总之，Elasticjob解决了quartz的单机极限痛点，是对quartz的一种扩展和优化。

参考

官网：http://elasticjob.io/docs/elastic-job-lite/00-overview

Github地址：https://github.com/elasticjob

Quartz管中窥豹之集群高可用

Sat, 05 May 2018 23:40:35 CST

Quartz在集群模式下通过故障切换和任务负载均衡来实现任务的高可用（HA High Available）。而集群模式是通过争用数据库悲观锁来实现必须使用JdbcStore持久化存储任务。这个可以先阅读之前集群管理文章Quartz管中窥豹之集群管理

故障切换

当其中一个节点在执行一个或多个作业期间失败时发生故障切换（Fail Over）。当节点出现故障时，其他节点会检测到该状况并识别数据库中在故障节点内正在进行的作业。任何标记为恢复的作业（在JobDetail上都具有"请求恢复(requests recovery)"属性）将被剩余的节点重新执行，已达到失效任务转移。没有标记为恢复的作业将在下一次相关的Triggers触发时简单地被释放以执行。

1、每个节点Scheduler实例由集群管理线程ClusterManager周期性（配置文件中检测周期属性clusterCheckinInterval默认值是 15000 (即15 秒)）定时检测CHECKIN数据库，遍历集群各兄弟节点的实例状态，检测集群各个兄弟节点的健康情况。

2、当集群中一个节点的Scheduler实例执行CHECKIN时，它会查看是否有其他节点的Scheduler实例在到达它们所预期的时间还未CHECKIN。若检测到有节点在预期时间未CHECKIN，则认为该节点故障。判断节点是否故障与节点Scheduler实例最后CHECKIN的时间有关，而判断条件：

LAST_CHECKIN_TIME + Max(检测周期，检测节点现在距上次最后CHECKIN的时间) + 7500ms < currentTime。

3、集群管理线程检测到故障节点，就会更新触发器状态，状态更新如下。

故障节点触发器更新前状态	更新后状态
BLOCKED	WAITING
PAUSED_BLOCKED	PAUSED
ACQUIRED	WAITING
COMPLETE	无，删除Trigger

`org.quartz.impl.jdbcjobstore.Constants`常量类定义了触发器的几种状态

4、集群管理线程删除故障节点的实例状态（qrtz_scheduler_state表），即重置了所有故障节点触发任务一般。原先故障任务和正常任务一样就交由调度处理线程处理了。

代码参见

下图是集群管理线程CHECKIN时第一次CHECKIN或者发现故障节点后需获取实例状态访问行锁，才能更新触发器状态，删除故障节点实例状态等等。

下面两张图是查找故障节点时，会查找所有集群节点的实例状态，然后遍历判断是否故障。

查找集群状态语句

下图是根据节点实例最后CHECKIN时间判断是否节点故障的方法。

下图可知，集群管理线程是单独的线程实例。

下图可知，集群管理线程检测完后要更新最后检测时间

负载均衡

负载平衡自动发生，群集的每个节点都尽可能快地触发Jobs。当Triggers的触发时间发生时，获取它的第一个节点（通过在其上放置一个锁定）是将触发它的节点。

它不一定是每次相同的节点 - 哪个节点运行它或多或少是随机的。负载平衡机制对于繁忙的调度器（大量的Triggers）是近似随机的，但是对于非忙（例如，很少的Triggers）调度器而言，有利于同一个节点下执行（Why?）。

集群下任务的调度存在一定的随机性，谁先拥有触发器行锁TRIGGER_ACCESS，谁就先可能触发任务。当某一个机子的调度线程拿到该锁（别的机子只能等待）时，

1、 acquireNextTriggers获取待触发队列，查询Trigger表的判断条件：

NEXT_FIRE_TIME < now + idleWaitTime + timeWindow and TRIGGER_STATE = 'WAITING'

然后更新触发器状态为ACQUIRE

2、触发待触发队列，修改 Trigger 表中的 NEXT_FIRE_TIME 字段，也就是下次触发时间，计算下次触发时间的方法与具体的触发器实现有关，如Cron表达式触发器，计算触发时间与Cron表达式有关。参见：

org.quartz.impl.triggers.CronTriggerImpl.triggered(Calendar)

触发待触发队列后及时释放触发器行锁。

3、这样，别的机子拿到该锁，也查询 Trigger 表，但是由于任务触发器的下次触发时间或者状态已经修改，所以不会被查找出来。这时拿到的任务就可能是别的触发任务。这样就实现了多个节点的应用在某一时刻对任务只进行一次调度。对于重复任务每次都不一定是相同的节点,它或多或少会随机节点运行它。

代码参见

如下面，如果是集群，则会开启基于数据库行锁的集群任务调度机制。

org.quartz.impl.jdbcjobstore.JobStoreSupport.initialize(ClassLoadHelper, SchedulerSignaler)

获取待触发队列的方法

集群功能最适合扩展长时间运行或cpu密集型作业（通过多个节点分配工作负载）。如果需要扩展以支持数千个短期运行（例如1秒）作业，则可以考虑通过使用多个不同的调度程序（包括HA的多个群集调度程序）对作业集进行分区。调度程序使用集群范围的锁，这种模式会在添加更多节点（超过三个节点 - 取决于数据库的功能等）时降低性能。

注意：

Never run clustering on separate machines, unless their clocks are synchronized using some form of time-sync service (daemon) that runs very regularly (the clocks must be within a second of each other). See http://www.boulder.nist.gov/timefreq/service/its.htm if you are unfamiliar with how to do this.

Never start (scheduler.start()) a non-clustered instance against the same set of database tables that any other instance is running (start()ed) against. You may get serious data corruption, and will definitely experience erratic behavior.

参考

Quartz教程 https://www.w3cschool.cn/quartz_doc/quartz_doc-2put2clm.html

http://www.quartz-scheduler.org/documentation/quartz-2.2.x/configuration/ConfigJDBCJobStoreClustering.html

调度系统入门和调度高可用实现方案 https://www.jianshu.com/p/810400e6a274Quartz

Quartz管中窥豹之其他特性初识

Tue, 01 May 2018 23:13:49 CST

由先前的文章，我们已经验证了Quartz到集群模式、触发器优先级、任务错过触发处理和任务有状态与并发等场景特性。

删除正运行任务

测试结果

任务删除将删除还未触发的任务及触发器信息。但不会强行中断已经触发运行的任务。

测试步骤

1、定义一个任务为休眠10秒。

2、测试用例中，任务每2秒触发。等待6秒后删除任务。

查看结果，加入任务后，数据库保存了任务信息。

由于任务每2秒触发，而6秒后删除任务，共触发了4次，即6秒后删除任务，没有新的触发任务。删除任务也不会强行中断正在触发的任务。

最后，数据库任务信息也删除了。

代码参见

调度器根据JobKey删除任务及其相关触发器，并通知调度线程

org.quartz.core.QuartzScheduler.deleteJob(JobKey)

集群下调度实例ID生成

测试结果

集群模式下，调度实例ID可配置自动生成，生成方式为：当前主机名 + 当前时间毫秒数

测试步骤

1、配置文件将调度实例ID设为AUTO，并加入集群

org.quartz.scheduler.instanceId: AUTOorg.quartz.jobStore.isClustered=true

2、跟踪调度工厂org.quartz.impl.StdSchedulerFactory加载配置启动过程

3、实例ID生成器org.quartz.spi.InstanceIdGenerator.generateInstanceId()生成ID

可以看出默认生成器ID生成规则：HOSTNAME + CURRENT_TIME

打印日志可以看出实例ID

配置文件可以设置org.quartz.scheduler.instanceIdGenerator.class属性，指向自定义的ID生成器，自行实现ID生成算法。

优雅关机

测试结果

手动关闭Quartz调度，即调用Shutdown方法时，会停止正在运行的触发器和清除所有调度相关的资源。关闭调度线程、关闭错过触发线程、关闭集群管理线程、关闭连接池、关闭线程池，设为True时，关闭时会等待到所有任务线程执行结束。

测试步骤

定义一个任务休眠20s，任务触发后等待15s，关闭调度。发现调度关闭会等待正在执行的任务直到任务线程结束。

发现触发器还是持久化到数据库。

代码参见

调度器关闭方法，关闭线程、关闭触发器、关闭连接池、关闭线程池等等

org.quartz.core.QuartzScheduler.shutdown(boolean)

设计模式

quartz内部也应用了一些设计模式，贴下代码吧

工厂模式

quartz采用了工厂方法。调度工厂SchedulerFactory的实现类有两个标准调度工厂StdSchedulerFactory和直接调度工厂DirectSchedulerFactory，StdSchedulerFactory可通过quartz配置文件初始化调度器Scheduler，而DirectSchedulerFactory可通过创建调度器方法来获取不同类型调度器。

任务运行壳工厂JobRunShellFactory，主要有两种实现类，创建有JTA事务和没有事务的JobRunShell。JTAJobRunShellFactory会负责创建含有JTA事务的JTAJobRunShell线程，用来反射执行真正的Job任务，并包裹了一层JTA事务；而StdJobRunShellFactory负责创建简单的JobRunShell，不处理事务相关的东西

建造者模式

Quartz提供了不同触发器类型的触发器建造者，建造者支持属性设值的链式写法

触发器建造者，可以创建不同触发器类型的触发器

org.quartz.JobBuilder 任务建造者，负责创建JobDetail实例

org.quartz.DateBuilder 日期建造者，负责创建与任务相关的具体日期

观察者模式

org.quartz.JobListener 任务监听器，任务执行会通知改监听器

org.quartz.TriggerListener 触发器执行会通知触发器监听器

org.quartz.SchedulerListener 调度器监听器，调度器启动和关闭等动态变化、触发器动态变化、任务动态变化会通知调度器监听器

org.quartz.ListenerManager 监听器管理类，对任务监听器、触发器监听器和调度器监听器管理

QuartzScheduler任务调度后，会负责通知监听器

单例模式

DirectSchedulerFactory.getInstance()

验证了删除正在运行任务，集群模式下调度实例ID生成和优雅关机等场景，和贴了quartz应用到的一些设计模式。quartz作为一款比较成熟的定时调度开源框架，受到广泛的应用和扩展不是没有道理的。

Quartz管中窥豹之任务有状态与并发

Mon, 23 Apr 2018 22:27:18 CST

Quartz定时任务默认都是并发执行,不仅仅是不同任务Job，还可以是同个Job的不同实例（JobDetail），意味着一次任务并不会等待上一次任务执行完毕，只要触发时间到达就会执行, 如果定时任执行太长，会长时间占用线程资源，导致其它任务堵塞。

Quartz定时任务默认也是无状态的，也就是每个Job实例都是独立的，每个Job实例的JobDataMap都是独有的，数据的改变互不影响。

我们可以在自定义任务Job类加上类注解@DisallowConcurrentExecution来表示同个Job的不同实例（JobDetail）不允许并发（不同job还是可以并发），这样子，一次任务执行会等待上次任务执行完毕，才会继续执行，否则会阻塞。

我们还可以在自定义任务Job类加上类注解@PersistJobDataAfterExecution让同个Job的不同实例（JobDetail）是有状态的，他们的数据是共享的，已存在的数据可能会被新的数据覆盖掉。值得注意的是，让任务变成有状态，最好是同时不允许并发，在并发情况下，数据读写是不确定的，可能造成不一致，是不可靠的。加上@PersistJobDataAfterExecution的同时，最好加上@PersistJobDataAfterExecution。

单Server

测试结果

这里的有状态和并发是指同一个Job的不同JobDetail实例。在默认情况下多个JobDetail实例之间是相互独立，互不影响的，即便是同个JobDetail实例的不同时间触发也是互不干扰。是支持并发的。而JobDetail中JobDataMap的数据初始化后也不会更新，是无状态的。

在任务Job类中加入注解@DisallowConcurrentExecution，则表示同一个JobDetail实例前后触发是相互影响的，下次触发要等待上次触发执行完毕，不同实例间则不需等待。

在任务Job类中加入注解@PersistJobDataAfterExecution，则表示同一个JobDetail实例前后触发JobDataMap是共享的，数据会发生更新。上次触发更新到JobDataMap的数据可以在下次触发时取到，为了防止并发竞争造成的不确定性，往往和@DisallowConcurrentExecution并发控制注解一起使用。

测试步骤

1、配置文件设置线程池大小为5，在线程充足的情形测试

org.quartz.threadPool.threadCount: 5

2、定义任务类ColorJob，把执行次数累加到JobDataMap里，休眠12s。

3、定义两个任务实例，每个任务实例都是10s后开始运行，每10s重复执行，重复4次，总运行5次

默认job是无状态，JobDataMap的数据不会发生更新，如测试场景结果，任务执行次数一直为1。支持并发，也在线程充足的情况下，同个任务实例触发也是相互独立，互不影响。如测试场景结果，job1每10s执行，但任务执行需要12s，下次触发时间到了就立即执行，不会等待。

4、在任务类ColorJob加入注解@DisallowConcurrentExecution，不会并发执行同一个job定义（ColorJob）的多个实例（JobDetail）。

重复执行第3步的测试用例，发现同一个ColorJob的两个实例是可以并发的，但同一时刻只允许一个相同实例执行。如测试场景结果，job1每10s执行，但任务执行需要休眠12s，下次触发时间到了要等待上次触发执行结束。这里比较诡异，没有休眠完12s就结束了。

5、在任务类ColorJob的注解换成@PersistJobDataAfterExecution，成功执行了job类的execute方法后（没有发生任何异常），更新JobDetail中JobDataMap的数据下次触发时，JobDataMap中是更新后的数据，Job的状态就体现在持续的JobDataMap数据。

重复执行第3步的测试用例，发现打印的执行次数发生变化，即JobDetail实例的JobDataMap数据更新了。但在并发情形下，JobDataMap数据发生了不确定。

6、在任务类ColorJob加入注解@PersistJobDataAfterExecution和

@DisallowConcurrentExecution，如果需要JobDataMap状态更新，就应该变成同步，防止并发导致的竞争，造成数据脏乱。重复执行第3步的测试用例，发现打印的执行次数发生变化，禁止并发后，与测试场景，每10s重复执行，执行5次，发生吻合。

集群

测试结果

集群下任务实例间的并发控制与【单server】一致，但故障情况下，故障期间未完成任务丢失，状态更新可能会发生不确定，可设置为可恢复的任务，集群可以重跑某一节点故障期间丢失的任务。

测试步骤

1、与【单server】步骤6的测试用例，启用两个环境，构造集群测试。相继启动两个环境，发现会自动负载均衡任务实例。

2、手动关闭其中一个应用（job2此时执行第四次还未结束），集群节点会检测到其他节点的健康状况，如果某节点丢失了，则接管其节点的Job任务，等待下次触发，故障时间的任务却丢失了。而检测频率由配置org.quartz.jobStore.clusterCheckinInterval参数决定，默认15000ms。但JobDataMap的数据更新状态由于故障发生了不确定性（因为要任务执行结束才更新状态）。如下图，job2的最终状态保持在4，与实际的执行次数5不一致。

3、将job2设为可恢复的任务

重跑集群测试，关闭其中一个应用（job2此时执行第四次还未结束），但另外一个调度会接管恢复异常故障时间丢失的任务，重新执行。

跨集群

测试结果

不同集群的任务实例相互之间没有任何关联。

测试步骤

1、运行两个测试用例，启用不同的配置。用例采用【单server】步骤6的测试用例

其中，设置不同调度实例

用两个环境分别测试，发现两个实例互不影响。与【单server】步骤6测试结果一致。

代码参见

job_detail任务表结构定义可以看出有状态位标示是否可并发，是否有状态，是否可恢复等等，也就意味着任务的并发控制和是否有状态也会持久化，任务动态操纵也伴随着这些标志位的改变。

对于同个Job不允许同时并发的不同JobDetail实例，它会过滤掉其他JobDetail的触发器

org.quartz.impl.jdbcjobstore.JobStoreSupport.acquireNextTrigger(Connection, long, int, long)

任务触发完成后，根据会根据是否运行并发和是否有状态，进行触发器状态和Job数据更新

org.quartz.impl.jdbcjobstore.JobStoreSupport.triggeredJobComplete(Connection, OperableTrigger, JobDetail, CompletedExecutionInstruction)

org.quartz.impl.jdbcjobstore.JobStoreSupport.triggerFired(Connection, OperableTrigger)

总结

quartz定时任务默认是并发和无状态的，可通过使用类注解@DisallowConcurrentExecution和@PersistJobDataAfterExecution让同个Job的不同JobDetail实例可以进行控制并发执行和数据共享有状态，这种结果，在集群情况下也同样试用，只是默认故障期间未完成任务状态会丢失，可以设置为可恢复（requestRecovery），任务应用重启，可故障恢复。

Quartz管中窥豹之触发器优先级

Thu, 19 Apr 2018 23:30:53 CST

根据先前的概念简介可知，一个Job可以有多个相同或不同的Trigger触发，甚至是同时触发。不同的Job也可能同时触发。这时就出现了触发时间相同的触发器触发先后顺序问题，这就是触发器优先级要考虑的问题。这里直接上结果

测试结果：

默认情况是触发时间先后顺序排列，触发时间比较前的先执行任务，但如果一个或多个任务同时在相同时间触发下，触发器设置优先级越高越先执行。如果优先级相同，则跟任务的存储方式有关，RAMJobStore时与TriggerKey排序有关，即按触发器名的字母序；如果是JdbcStore则跟数据库查询的默认排序有关了。Trigger优先级默认为5，数值越大优先级越高。

测试步骤：

1、定义了3个任务，都是在17:12:00秒触发，优先级大小分别为10、100、1

测试结果为：SimpleJob数值最大，优先级最大，最先执行。

调换下优先级大小，FirstJob为1，SimpleJob为5，HelloJob为10。定点触发，结果是优先级最大的HelloJob最先执行。

2、优先级相同时，都设为5时，多测试几遍，FirstJob总是先执行。

代码参见

查看Quartz调度线程可知，与触发器的存储方式有关。QuartzSchedulerThread定义了获取下一个触发器队列的方法。

org.quartz.core.QuartzSchedulerThread#org.quartz.spi.JobStore.acquireNextTriggers(long, int, long)

如果是RAMJobStore，用TreeSet存储待触发的线程。Trigger类里定义了触发器时间比较器

可以看出，优先级按触发时间、优先级和TriggerKey（String的字母序）排序的。

而JdbcStore可以看下Jdbc委托类，查看触发器查询语句

org.quartz.impl.jdbcjobstore.StdJDBCDelegate

挑出触发器查询语句：

select * from qrtz_triggers ORDER BY NEXT_FIRE_TIME ASC, PRIORITY DESC

发现是按触发时间升序，优先级降序排列，如果都相同，采用数据库自己默认的排序了，跟具体的DB有关了。MySQL中SELECT 默认排序是按照物理存储顺序显示。

**Trigger可以定义一个优先级，默认为5。**当多个trigger同时触发job时，线程池可能不够用，此时根据优先级来决定谁先触发。数值越大优先级越高。这个可以考虑为配置项，为优先执行的Trigger设置较大的优先级数值。

所以所有获取待触发触发器列表，跟触发时间有关，其次是触发器优先级大小，最后是具体任务的存储方式有关。触发时间较前先触发，触发时间相同，触发器优先级大的先触发，如果触发器优先级相同，则看任务存储方式，若为内存存储，则与TriggerKey排序有关，即按触发器名的字母序，若为DB存储，则与DB默认排序规则有关。

Quartz管中窥豹之错过触发处理策略

Tue, 17 Apr 2018 23:21:03 CST

在应用运行中，任务错过触发的事情也是时有发生，比如，系统宕机重启，在关闭至重启的时间，任务可能Misfired；线程池线程满了，没有空闲线程执行任务，导致无法触发，等待超时造成Misfired；不允许并发任务（@DisallowConcurrentExecution）在下次触发时间到达时，上次执行还未结束，只能等待，可能造成Misfired；触发器Trigger被暂停suspend时间段里，有些任务可能被Misfired等等。当然Quartz提供了一定的容忍度。配置文件可配置容忍错过触发阈值：org.quartz.jobStore.misfireThreshold=60000，默认为1分钟。意味着本因触发的任务未能及时执行可以延迟1分钟执行。超过1分钟后，即认为任务"Misfired"。这时就需要有错过触发的调度策略来决定如何这些"Misfired"任务。

错过触发处理策略

不同的触发器类型有自己的"Misfired"错过触发处理策略。可以查看各个触发器实现策略。

org.quartz.impl.triggers.AbstractTrigger.updateAfterMisfire(Calendar)

每个类型触发器要实现上述抽象类方法，进行"Misfired"任务处理。错过触发处理策略由MisfireHandler错过触发处理线程处理错过触发任务。总结如下：

序号	策略	值	描述	适用触发类型
1	MISFIRE_INSTRUCTION _IGNORE_MISFIRE_POLICY	-1	这种策略会在资源适合的时候尽快的重新触发所有“Misfired”错过触发任务。不会影响现有的调度时间。例如，SimpleTrigger每15秒执行一次，而中间有5分钟时间它都“Misfired”了，一共错失了20个，5分钟后，假设资源充足了，并且任务允许并发，它会被一次性触发。	所有触发器
2	MISFIRE_INSTRUCTION _SMART_POLICY	0	触发器默认策略。如果当前触发器是CronTrigger则走序号【3】策略。如果当前触发器是SimpleTrigger，当重复次数为0时，走序号【5】策略；当重复次数为-1，即无限次数时，走序号【8】策略；否则走序号【6】策略。如果当前触发器是 CalendarIntervalTrigger，则走序号【3】策略。如果当前触发器是 DailyTimeIntervalTrigger，则走序号【3】策略。	所有触发器
3	MISFIRE_INSTRUCTION _FIRE_ONCE_NOW	1	立即触发“Misfired”错过触发任务。	CronTriggerCalendarIntervalTriggerDailyTimeIntervalTrigger
4	MISFIRE_INSTRUCTION _DO_NOTHING	2	不立即触发执行，等待下次触发时间到达时刻才触发执行，重新开始调度任务。	CronTriggerCalendarIntervalTriggerDailyTimeIntervalTrigger
5	MISFIRE_INSTRUCTION _FIRE_NOW	1	立即触发执行。此指令通常只适用于“一次性”（非重复）触发器。如果用于重复次数大于0的触发器，则走需要【7】策略	SimpleTrigger
6	MISFIRE_INSTRUCTION _RESCHEDULE_NOW_WITH _EXISTING_REPEAT_COUNT	2	以当前时间为开始触发时间，立即触发执行。重复时间间隔不变，重复次数更新为原先重复次数-已触发次数。然后已触发次数重置为0。如果当前时间是在结束时间之后，触发器将不会再次触发。该策略无法记住最初设置的“开始时间”和“重复次数”	SimpleTrigger
7	MISFIRE_INSTRUCTION _RESCHEDULE_NOW_WITH _REMAINING_REPEAT_COUNT	3	与序号【6】策略一致，区别在于重复次数的计算，重复次数更新为原先重复次数-已触发次数-下次触发时间到当前时间区间触发的次数。	SimpleTrigger
8	MISFIRE_INSTRUCTION _RESCHEDULE_NEXT_WITH _REMAINING_COUNT	4	等待下次触发时间到达时刻才触发执行，重新开始调度任务。会更新已触发次数为已触发次数+下个触发时间到当前时间的下个触发时间区间的次数。	SimpleTrigger
9	MISFIRE_INSTRUCTION _RESCHEDULE_NEXT_WITH _EXISTING_COUNT	5	等待下次触发时间到达时刻才触发执行，重新开始调度任务。	SimpleTrigger

错过触发处理策略测试

线程不足，相同时间同时触发多任务

测试结果：

当线程池满了，相同时间触发的任务只能等待有可用线程，或者非并发的任务上次触发执行太久，下次触发时间超过配置里设置的容忍错过触发阈值时，将被置为错过触发状态。由错过触发处理线程采用错过触发处理策略处理，或立即执行，或等待下一次触发等等，错过触发处理线程只会更新下次触发时间，并通知触发器监听器，最终还是由调度线程处理；如果没有超过阈值，则意味着已有可用线程可用，正常运行。因为线程池是按触发器的触发时间，然后才是触发器优先级来排任务队列的。一种错过触发任务一直等待的情形，只能是线程不足，而且线程都执行了长时间、甚至是死循环不会任务的这种情形。而线程饥饿是JVM进程调度的范畴，而Quartz调度处理线程中调度任务使用的线程池是SimpleThreadPool，默认的线程优先级是5，每个线程都是有机会参与CPU竞争的。而且Java优先级较高的线程不一定每一次都优先执行，有一定随机性。

测试步骤：

1、配置文件中设置任务线程池大小为1。改造FirstJob让它休眠60s。

2、还是定点相同时间触发多个任务。FistJob优先级最高优先执行。

3、SimpleJob和HelloJob处于等待状态。等待FirstJob线程结束时，另外两线程才相继触发。org.quartz.jobStore.misfireThreshold: 60000 设置容忍错过触发阈值为60s。如：SimpleJob本因55分触发的，如果56分还未触发，就会错过触发。由于线程池满了，SimpleJob只能等待FirstJob执行结束（即休眠60s）。60s后，FirstJob刚刚执行完毕，此时刚好在容忍错过触发阈值，错过触发。由MisfireHandler错过触发线程根据错过触发策略处理。如下图，处理了两个错过触发的任务。（这时候的策略是立即处理）

4、将容忍错过触发阈值加大为61s。即：org.quartz.jobStore.misfireThreshold: 61000

FirstJob线程结束后。其他两个任务此时未超过容忍错过触发阈值。按触发优先级争用线程池，正常处理。

CronTrigger处理策略

使用Cron表达式，创建的触发器为CronTrigger，他采用的默认策略：

MISFIRE_INSTRUCTION_SMART_POLICY。对于CronTrigger，采用策略即立即触发。

而CronTrigger暴露的错过触发策略：

即对应表格：

CronTrigger方法	对应策略
withMisfireHandlingInstructionIgnoreMisfires	MISFIRE_INSTRUCTION_IGNORE_MISFIRE_POLICY 序号【1】
withMisfireHandlingInstructionFireAndProceed	MISFIRE_INSTRUCTION_FIRE_ONCE_NOW 序号【3】
withMisfireHandlingInstructionDoNothing	MISFIRE_INSTRUCTION_DO_NOTHING 序号【4】

观察其实现类org.quartz.impl.triggers.CronTriggerImpl，默认策略就是立即触发。

1、测试withMisfireHandlingInstructionDoNothing 即序号【4】策略。

创建触发器，带有withMisfireHandlingInstructionDoNothing

2、设置容忍错过触发阈值为60s，让任务错过触发。改下触发时间，继续测试。

3、根据打印日志可知，错过触发处理线程已经处理错过触发任务。但此时错过触发任务没有立即执行，要等待下一次执行。（下次执行时间是下一天对于的时间点，无法重现）

SimpleTrigger处理策略

1、测试SimpleTrigger的错过触发策略，定义StatefulDumbJob任务类，使用有状态和并发控制的Job，【有状态和并发Job测试】。将容忍错过触发阈值设为7000ms。线程数为2。

2、定义两个任务，都是休眠10s，调度启动15s后，开始任务，后每3s触发，无限重复执行。Job1使用默认策略，因为定义的触发器SimpleTrigger及无限重复，由序号【1】策略，可知，最终走序号【8】策略

MISFIRE_INSTRUCTION_RESCHEDULE_NEXT_WITH_REMAINING_COUNT；job2使用序号【6】策略MISFIRE_INSTRUCTION_RESCHEDULE_NOW_WITH_EXISTING_REPEAT_COUNT

3、查看测试结果，05分15秒开始两个任务触发。下个触发时间按周期3s，本应18s触发，但任务休眠10s后才能执行，刚好超过容忍错过触发的阈值，变成"Misfired"。由错过触发处理线程检测处理，05分27秒处理错过触发任务。发现job2立即执行，但job1在05分30秒才执行。第二次处理错过触发任务时，job2立即执行，但job1在05分42秒才执行。05分30秒、05分42秒、05分57秒都落在05分15秒开始，每3秒的周期点上，即会等待检测当前时间的下个触发时间触发错过触发任务。验证了序号【8】和【6】策略。

代码参见

不同类型触发器定义了不同的公有静态常量来表示错过触发指令，用于错过触发任务处理，过触发指令可由以下接口找到

org.quartz.SimpleTrigger

org.quartz.CronTrigger

org.quartz.CalendarIntervalTrigger

org.quartz.DailyTimeIntervalTrigger

不同类型触发器实现AbstractTrigger抽象方法进行错过触发任务处理

org.quartz.impl.triggers.AbstractTrigger.updateAfterMisfire(Calendar)

总结

Quartz定义了容忍错过触发阈值和错过触发处理策略，不同类型的触发器可以有不同的触发策略，根据可能错过触发的场景，配置线程池大小也选的比较重要了，Quartz配置应该要能适应应用业务需要，动态调整，比如，可以上配置中心，等等。

Quartz管中窥豹之触发器状态

Sun, 15 Apr 2018 22:46:08 CST

Quartz随着任务的创建，触发和销毁，触发器状态也做出改变，流转成相应的变化。我们可以通过触发器状态变化观察到定时任务的生命周期。

触发器状态

我们可以看下Quartz org.quartz.impl.jdbcjobstore.Constants常量类中定义的触发器的几种状态:

Triggers表状态	描述
WAITING	创建任务触发器默认状态
ACQUIRED	当到达触发时间时，获得状态
EXECUTING	运行中，firedTrigger表中
COMPLETE	完成状态，任务结束
BLOCKED	阻塞状态
ERROR	错误状态
PAUSED	暂停状态
PAUSED_BLOCKED	暂停阻塞状态，非并发下
DELETED	删除状态

下图是**触发器状态图**：描述调度线程QuartzSchedulerThread自动状态切换和手动状态切换（动态调用定时任务CRUD方法）的过程。

1、在创建JobDetail和Trigger并schedueJob初始化调度后默认状态为等待WAITING状态

2、在调度线程QuartzSchedulerThread 获取下次触发队列acquireNextTriggers时更新为已获得ACQUIRED状态

3、 JobStoreSupport.triggerFired的时候会根据是否取得绑定的Job判断，如果无法取得直接进入错误ERROR状态，否则根据Job是否运行并发，Job体现为自定义Job实现类是否加类注解@DisallowConcurrentExecution。如果允许并发，则判断下次触发时间NextFireTime，如果为空，则意味着任务生命周期已经结束，状态标记为完成COMPLETE状态，如果下次触发时间NextFireTime不为空，则回到WAITING状态，等待下一次任务触发时间的到来；如果Job不允许并发，也会根据下次触发时间NextFireTime判断，如果下次触发时间NextFireTime不为空，不为空，则进入阻塞BLOCKED状态，同时也会更新绑定相同Job实例的其他触发器的状态

4、对于动态任务管理，如暂定任务pauseJob，则会将触发器状态置为PAUSED或PAUSED_BLOCKED，相应地，调用resumeJob恢复任务，则触发器状态重置成WAITING状态。

这些生命周期跟线程状态很像，熟悉线程生命周期，就很容易理解。

代码参见

1、常量类定义的触发器状态值

Quartz org.quartz.impl.jdbcjobstore.Constants

2、Quartz提供了定时任务动态改变的方法

org.quartz.core.QuartzScheduler

对于用可视化界面动态进行定时任务CRUD管理可以利用这些方法，可以在这基础上再统一封装一层定时任务管理的API

对于触发器生命周期的状态流转，并没有一一的跟进验证，只是看着源码画出自己理解的状态图，难免跟实际情况有些出入。

Quartz管中窥豹之集群管理

Tue, 03 Apr 2018 21:43:23 CST

Quartz是原生支持应用集群下的任务调度，查下摘自官网的架构图：

Quartz集群中的每个节点是一个独立的Quartz任务应用，它又管理着其他的节点。该集群需要分别对每个节点分别启动或停止，不像一些应用服务器的集群需要彼此通信，独立的Quartz节点并不与另一个节点或是管理节点通信。Quartz应用是通过共用相同数据库表来感知到另一应用。也就是说只有使用****持久化JobStore存储Job和Trigger才能完成Quartz集群。

数据库核心表

在Quartz源码的docs/dbTables目录下，存放了针对不同数据库Quartz所需要的数据库表。以Mysql为例，看下需要的表：

表名	描述
QRTZ_CALENDARS	存储Quartz的Calendar信息
QRTZ_CRON_TRIGGERS	存储CronTrigger，包括Cron表达式和时区信息
QRTZ_FIRED_TRIGGERS	存储与已触发的Trigger相关的状态信息，以及相联Job的执行信息
QRTZ_PAUSED_TRIGGER_GRPS	存储已暂停的Trigger组的信息
QRTZ_SCHEDULER_STATE	存储少量的有关Scheduler的状态信息，和别的Scheduler实例
QRTZ_LOCKS	存储程序的悲观锁的信息
QRTZ_JOB_DETAILS	存储每一个已配置的Job的详细信息
QRTZ_JOB_LISTENERS	存储有关已配置的JobListener的信息
QRTZ_SIMPLE_TRIGGERS	存储SimpleTrigger，包括重复次数、间隔、以及已触的次数
QRTZ_BLOG_TRIGGERS	Trigger作为Blob类型存储
QRTZ_TRIGGER_LISTENERS	存储已配置的TriggerListener的信息
QRTZ_TRIGGERS	存储已配置的Trigger的信息

Quartz的集群部署方案在架构上是分布式的，没有负责集中管理的节点，而是利用****数据库行锁****的方式来实现集群环境下进行并发控制。

一个调度器实例在集群模式下首先要获取 {0}LOCKS 表中对应的行级锁，

向MySQL获取行锁语句为

select * from {0}LOCKS where sched_name = ? and lock_name = ? for update

{0}会替换为配置文件默认配置的QRTZ_。sched_name为应用集群的实例名，lock_name就是行级锁名。Quartz主要由两个行级锁。

lock_name	desc
STATE_ACCESS	状态访问锁
TRIGGER_ACCESS	触发器访问锁

Quartz集群争用触发器行锁，锁被占用只能等待。获取触发器行锁后，先获取需要待触发的其他触发器信息。数据库更新触发器状态信息，及时释放触发器行锁，供其他调度实例获取，然后在进行触发器任务调度操作。对数据库操作就要先获取行锁。

集群配置

定义quartz.properties配置文件默认放在应用classpath路径下，其他路径只能自己手动加载properties。下面是集群配置参考

#集群中应用采用相同的Scheduler实例org.quartz.scheduler.instanceName: wenqyScheduler#集群节点的ID必须唯一，可由quartz自动生成org.quartz.scheduler.instanceId: AUTO#通知Scheduler实例要它参与到一个集群当中org.quartz.jobStore.isClustered: true#需持久化存储org.quartz.jobStore.class=org.quartz.impl.jdbcjobstore.JobStoreTXorg.quartz.jobStore.driverDelegateClass=org.quartz.impl.jdbcjobstore.StdJDBCDelegate#数据源org.quartz.jobStore.dataSource=myDS#quartz表前缀org.quartz.jobStore.tablePrefix=QRTZ_#数据源配置org.quartz.dataSource.myDS.driver: com.mysql.jdbc.Driverorg.quartz.dataSource.myDS.URL: jdbc:mysql://localhost:3306/ncdborg.quartz.dataSource.myDS.user: rootorg.quartz.dataSource.myDS.password: 123456org.quartz.dataSource.myDS.maxConnections: 5org.quartz.dataSource.myDS.validationQuery: select 0

集群测试

测试结果：Quartz集群管理可以避免应用在集群环境下重复执行相同的Job。

测试步骤：

在两个IDE环境下测试同一份demo应用，运行相同的任务。应用采用集群配置。

一个应用先添加任务，每秒触发任务。

集群自动分配实例ID，避免冲突，如看打印日志。

另外一个环境执行相同添加任务，则提示已经存在无法添加任务。

查看数据库，此时，任务信息持久化在表中

应用再次运行时会自动触发库中持久化的任务信息。模拟启动。

一个环境先启动，已经触发了任务。

另一个实例，没有触发任务就结束了。

验证了任务集群下是可以避免任务重复执行的。

总结

Quartz虽然强大，任务调度极其方便，易用，集群下也可以避免任务重复执行。但还是有些不足之处：节点任务调度会跟系统当前时间做比较，集群各个节点的系统时间尽可能一致，Quartz集群还发生争用数据库的情况，存在数据库单点故障，任务处理也存在应用集群下单机处理极限问题。Quartz原生也没有支持可视化监控的任务管理端。有不少分布式调度开源框架都是基于Quartz做了扩展。

参考

Quartz应用与集群原理分析 https://tech.meituan.com/mt-crm-quartz.html

基于 Quartz 开发企业级任务调度应用 https://www.ibm.com/developerworks/cn/opensource/os-cn-quartz/