场景：
一个 Spring Boot + Quartz 的工程，做电水气能的计算定时任务。希望电水气的计算任务执行日志，分成不同文件输出。



实现 logback-spring.xml 如下：
```xml
<?xml version="1.0" encoding="UTF-8"?>
<configuration scan="true" scanPeriod="60 seconds">
    
    
    <contextName>etl-demo</contextName>
    
    
    <conversionRule conversionWord="clr" converterClass="org.springframework.boot.logging.logback.ColorConverter"/>
    <conversionRule conversionWord="wex" converterClass="org.springframework.boot.logging.logback.WhitespaceThrowableProxyConverter"/>
    <conversionRule conversionWord="wEx" converterClass="org.springframework.boot.logging.logback.ExtendedWhitespaceThrowableProxyConverter"/>
    
    
    <property name="SOUT_LOG_PATTERN" value="%clr(%d{yyyy-MM-dd HH:mm:ss.SSS}){faint} %clr(%5level) %clr(${PID:- }){magenta} %clr([%15.15t]){faint} %clr(%-40.40logger{39}){cyan} %clr(:){faint} %m%n%wEx"/>
    <property name="FILE_LOG_PATTERN" value="%d{yyyy-MM-dd HH:mm:ss.SSS} %5level ${PID:- } [%15.15t] %-40.40logger{39} : %m%n%wEx"/>
    <property name="SOUT_LOG_CHARSET" value="UTF-8"/>
    <property name="FILE_LOG_CHARSET" value="UTF-8"/>
    
    <appender name="SOUT" class="ch.qos.logback.core.ConsoleAppender">
        <encoder>
            <pattern>${SOUT_LOG_PATTERN}</pattern>
            <charset>${SOUT_LOG_CHARSET}</charset>
        </encoder>
    </appender>
    
    <appender name="SIFT" class="ch.qos.logback.classic.sift.SiftingAppender">
        
        <discriminator>
            <key>taskName</key>
            <defaultValue>default</defaultValue>
        </discriminator>
        <sift>
            
            <appender name="FILE-${taskName}" class="ch.qos.logback.core.rolling.RollingFileAppender">
                <encoder>
                    <pattern>${FILE_LOG_PATTERN}</pattern>
                    <charset>${FILE_LOG_CHARSET}</charset>
                </encoder>
                <file>D:\gitsrd\gsta-ems\ems-etl-plus\etl-demo\logs\etl-demo-${taskName}.log</file>
                <rollingPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedRollingPolicy">
                    <fileNamePattern>etl-demo-${taskName}-%d{yyyy-MM-dd}-%i.gz</fileNamePattern>
                    <cleanHistoryOnStart>false</cleanHistoryOnStart>
                    <maxFileSize>10MB</maxFileSize>
                    <totalSizeCap>0</totalSizeCap>
                    <maxHistory>7</maxHistory>
                </rollingPolicy>
            </appender>
        </sift>
    </appender>
    
    <logger name="org.apache.catalina.startup.DigesterFactory" level="ERROR"/>
    <logger name="org.apache.catalina.util.LifecycleBase" level="ERROR"/>
    <logger name="org.apache.coyote.http11.Http11NioProtocol" level="WARN"/>
    <logger name="org.apache.sshd.common.util.SecurityUtils" level="WARN"/>
    <logger name="org.apache.tomcat.util.net.NioSelectorPool" level="WARN"/>
    <logger name="org.eclipse.jetty.util.component.AbstractLifeCycle" level="ERROR"/>
    <logger name="org.hibernate.validator.internal.util.Version" level="WARN"/>
    <logger name="org.springframework.boot.actuate.endpoint.jmx" level="WARN"/>
    
    <root level="INFO">
        <appender-ref ref="SOUT"/>
        <appender-ref ref="SIFT"/>
    </root>
    
</configuration>
```

在代码中使用 MDC 写入任务名称：
```java linenos
package com.gsta.ems.etl.plus.demo.job;  
  
import com.gsta.ems.etl.plus.core.calc.ECalcService;  
import com.gsta.ems.etl.plus.core.clean.ECleanService;  
import lombok.RequiredArgsConstructor;  
import lombok.extern.slf4j.Slf4j;  
import org.quartz.DisallowConcurrentExecution;  
import org.quartz.JobExecutionContext;  
import org.quartz.JobExecutionException;  
import org.slf4j.MDC;  
import org.springframework.scheduling.quartz.QuartzJobBean;  
import org.springframework.stereotype.Component;  
  
  
@Slf4j  
@Component  
@RequiredArgsConstructor  
@DisallowConcurrentExecution  
public class ECalcJob extends QuartzJobBean {  
  
    public static final String NAME = "ECalcJob";  
    public static final String DESCRIPTION = "负责计算电能数据（15min、hour、day、month、year）";  
  
    private final ECleanService eCleanService;  
    private final ECalcService eCalcService;  
  
    @Override  
    protected void executeInternal(JobExecutionContext context) throws JobExecutionException {  
        MDC.put("taskName","ecalc");  
        log.info("------------------------------ 模拟 清洗电表数据 ------------------------------");  
        log.info("------------------------------ 模拟 电能数据 ------------------------------");  
        MDC.remove("taskName");  
    }  
  
}
```


参考：
- [Logback实现不同任务输出到不同日志文件 – Heart.Think.Do](http://www.heartthinkdo.com/?p=2945)
- [logback每天生成日志失败，TimeBasedRollingPolicy和SizeBasedTriggeringPolicy冲突_ch.qos.logback.core.rolling.timebasedrollingpolicy-CSDN博客](https://blog.csdn.net/bluestarjava/article/details/82722033)
- [Logback - SiftingAppender - 简书](https://www.jianshu.com/p/a33902d58530)
- [看完这个不会配置 logback ，请你吃瓜！之前在 日志？聊一聊slf4j吧 这篇文章中聊了下slf4j。本文也从实际 - 掘金](https://juejin.cn/post/6844903641535479821)
- [Logback 快速入门 / 使用详解 - SimpleIto - 博客园](https://www.cnblogs.com/simpleito/p/15133654.html)

Spring Boot Logback 配置日志输出到不同文件

遇到过维护的项目是以逗号分隔子表的id的，查询等操作比较麻烦。所以记录一下对应的解决方法。



### 案例1：查询系统用户(993318396439445506)关联的产品关联的应用

~~~
 [sys_user]      [sys_user_prod]     [product]   [app]
 
  uid-------------user_id         /---id----------products
                                 /
                  prod_id-------/
~~~

**难点：** app表通过一个字段products维护所有关联的产品id的集合。如：2 或  4,11,12

**实现：**

~~~sql
SELECT `id`,`uuid`,`name`,`token`,`time`,`products` FROM app
where CONCAT(',',products,',') REGEXP
(
  SELECT CONCAT(
      ',{1}(',
      GROUP_CONCAT(prod_id SEPARATOR '|') ,
      '),{1}'
  )
  FROM sys_user_prod WHERE user_id = '993318396439445506'
)
order by id;
~~~

** 片段理解1：**
假设products=1,17    -->    CONCAT(',',products,',')    -->    ,1,17,

**片段理解2：**
~~~sql
 SELECT CONCAT(
     ',{1}(',
     GROUP_CONCAT(prod_id SEPARATOR '|') ,
     '),{1}'
 )
 FROM sys_user_prod WHERE user_id = '993318396439445506'
~~~

**拆分来理解：**
~~~
SELECT prod_id FROM sys_user_prod WHERE user_id = '993318396439445506';
~~~

以上sql会产生多行，所以使用group_concat函数将多上拼接起来：1|17|19

~~~sql
SELECT group_concat(prod_id SEPARATOR '|') FROM sys_user_prod WHERE user_id = '993318396439445506';
~~~


最后使用concat拼接处正则表达式：,{1}(1|17|19),{1}
~~~
SELECT concat(',{1}(',   group_concat(prod_id SEPARATOR '|')    ,'),{1}') FROM sys_user_prod WHERE user_id = '993318396439445506';
~~~

所以，where子句后面的，实际内容是这样的：
~~~
SELECT `id`,`uuid`,`name`,`token`,`time`,`products` FROM app
where CONCAT(',',products,',') REGEXP ',{1}(1|17|19),{1}' order by id;
~~~

### 案例2：查询终端用户(36)关联的设备
**场景：“点击某个终端用户，显示该用户所有设备**
~~~
 [user]             [device]

 id---------\ /-----id
             x
 devices----/ \-----users
~~~

**难点：多对多**

**实现1（不推荐）：**
~~~
SELECT * FROM device WHERE concat(',',id,',') REGEXP
(SELECT CONCAT(',{1}(', REPLACE(devices,',','|'), '),{1}') FROM `user` WHERE id = 36);
~~~

首先看看用户表的devices, result --> 3,6
~~~
select * from user where id = 36;
~~~

逐步拼接正则匹配条件, result --> 3|6
~~~
SELECT REPLACE(devices,',','|') FROM `user` WHERE id = 38;
~~~

逐步拼接正则匹配条件, result --> ,{1}(3|6),{1}
~~~
SELECT CONCAT(',{1}(', REPLACE(devices,',','|'), '),{1}') FROM `user` WHERE id = 36;
~~~

所以，where子句后面的，实际内容是这样的：
~~~
SELECT * FROM device WHERE concat(',',id,',') REGEXP ',{1}(3|6),{1}';
~~~

**实现2（推荐）：**
~~~
SELECT * FROM device WHERE id REGEXP
(SELECT CONCAT('^(', REPLACE(devices,',','|'), ')$') FROM `user` WHERE id = 36);
~~~

实际内容是这样的：
~~~
SELECT * FROM device WHERE id REGEXP '^(3|6)$';
~~~



**实现3（强烈推荐）：**
~~~
SELECT * FROM device WHERE FIND_IN_SET(id, (SELECT devices FROM `user` WHERE id = 36) );
~~~

### 案例3：查询设备(3)下面所有终端用户
** 场景：显示某个设备下关联的所有终端用户的信息**

~~~
 [user]             [device]

 id---------\ /-----id
             x
 devices----/ \-----users
~~~


** 实现1（不推荐）：**
~~~
SELECT
  d.id as device_id,
  d.name as device_name,
  d.users as device_users,
  u.`id` AS user_id,
  u.`name` AS user_name,
  u.`phone` AS user_phone,
  u.`wechat` AS user_wechat,
  u.`devices` AS user_devices
FROM device d, `user` u
WHERE d.`id` = 3
AND u.`id` REGEXP CONCAT('^(',REPLACE(d.`users`, ',', '|'),')$');
~~~

**实现2（推荐）：**

~~~
SELECT
  d.id as device_id,
  d.name as device_name,
  d.users as device_users,
  u.`id` AS user_id,
  u.`name` AS user_name,
  u.`phone` AS user_phone,
  u.`wechat` AS user_wechat,
  u.`devices` AS user_devices
FROM device d, `user` u
WHERE d.`id` = 3 AND FIND_IN_SET(u.`id`,d.`users`);
~~~






### 案例4：删除产品(7)下面关联的服务(25)
**场景：删除产品下面某个服务，需要在产品表中删除对应的服务id**

~~~
 [product]       [service]           [service_property]

 id           /--id              /----id
             /                  /
 services---/    properties----/
~~~

** 实现：**
~~~
UPDATE product SET services =
SUBSTR(
    REPLACE(
        CONCAT(',',services), CONCAT(',',25), ''
        ), 2
    )
    WHERE id = 7;
~~~

理解，从查询开始理解，避免删除错了：
~~~
select id,name,services from product where id = 7;
~~~
现在知道services的值是24,25,26,27

思路是先用concat将  "24,25,26,27"  变成  ",24,25,26,27"

再用replace将 ",24,25,26,27" 中的 ",25" 替换成空字符串  ''，处理后字符串变成",24,26,27"

由于最前面多了一个逗号，所以最后用substr来去掉那个多余的逗号
~~~
select substr(
    replace(
        concat(',',services),concat(',',25),''
    ),2
) from product where id = 7;
~~~





###案例5：产品(7)下面添加关联的服务(33)
**场景：添加产品下面某个服务，需要在产品表中添加对应的服务id**

~~~
 [product]       [service]           [service_property]

 id           /--id              /----id
             /                  /
 services---/    properties----/
~~~

** 实现：**
~~~
UPDATE product SET services = CONCAT(services,',',33) WHERE id = 7;
~~~

 理解，从查询开始理解，避免添加错了：
~~~
select CONCAT(services,',',33) from product WHERE id = 7;
~~~






### 案例6：删除服务(5)下面所有关联的属性
**场景：删除产品下面某个服务，需要先删除服务下面关联的属性**

~~~
 [product]       [service]           [service_property]

 id           /--id              /----id
             /                  /
 services---/    properties----/
~~~

** 实现1（不推荐）：**
~~~
DELETE FROM service_property WHERE id
REGEXP CONCAT( '^(', REPLACE( (SELECT properties FROM service WHERE id = 5),  ',',  '|' ), ')$');
~~~

理解：从查询开始理解，避免删除错了：

result --> 13,14,15
~~~
select properties from service where id = 5;
~~~

替换 result --> 13|14|15
~~~
select REPLACE( (SELECT properties FROM service WHERE id = 5),  ',',  '|' );
~~~

拼接成正则 result -->  ^(13|14|15)$
~~~
select CONCAT( '^(', REPLACE( (SELECT properties FROM service WHERE id = 5),  ',',  '|' ), ')$');
~~~

最后就可以用来匹配属性id：
~~~
select id,name from service_property where id
REGEXP CONCAT( '^(',
                REPLACE( (SELECT properties FROM service WHERE id = 2),  ',',  '|' ),
               ')$');
~~~


** 实现2（强烈推荐）：**
~~~
select id,name from service_property where
FIND_IN_SET(id,(SELECT properties FROM service WHERE id = 6));
~~~

MySQL以逗号分隔id时的增删改查操作

## 答案

先说结论：JDK 8 默认的垃圾回收器，是【Parallel Scavenge + Parallel Old】组合（并行新生代收集器 + 并行老年代收集器），也被统称为「Parallel GC（并行垃圾回收器）」



## 书本中的线索
周志明的《深入理解Java虚拟机 第3版》3.7.4章节 提及到：

| 参数 | 描述 |
| --- | --- |
| UseParallel GC | JDK 9 之前虚拟机运行在Server模式下的默认值，打开此开关后，使用 Parallel Scavenge + Serial Old (PS MarkSweep) 的收集器组合进行内存回收 |

> 需要说明一下， Parallel Scavenge 收集器架构中本身有 PS MarkSweep 收集器来进行老年代收集， 并非直接调用 Serial Old 收集器， 但是这个 PS MarkSweep 收集器与 Serial Old 的实现几乎是一样的， 所以在官方的许多资料中都是直接以 Serial Old 代替 PS MarkSweep 进行讲解， 这里笔者（周志明）也采用这种方式。

## 打印命令行默认参数
这个问题可以通过打印 Java 默认参数来得到一些线索：
```powershell
PS C:\Users\caibh> java -XX:+PrintCommandLineFlags -version

-XX:InitialHeapSize=1068324736 
-XX:MaxHeapSize=17093195776 
-XX:+PrintCommandLineFlags 
-XX:+UseCompressedClassPointers 
-XX:+UseCompressedOops 
-XX:-UseLargePagesIndividualAllocation 
-XX:+UseParallelGC
java version "1.8.0_202"
Java(TM) SE Runtime Environment (build 1.8.0_202-b08)
Java HotSpot(TM) 64-Bit Server VM (build 25.202-b08, mixed mode)
```

可以看到打印的默认参数中有一项是 `-XX:+UseParallelGC`，可以通过下面表格得知该参数对应使用的垃圾回收器（`Parallel Scavenge + Serial Old`）：

| JVM参数 | 垃圾回收器 |
| --- | --- |
| -XX:+UseSerialGC | Serial + Serial Old |
| -XX:+UseParNewGC | ParNew + Serial Old |
| -XX:+UseParallelGC | Parallel Scavenge + Serial Old |
| -XX:+UseParallelOldGC | Parallel Scavenge + Parallel Old |
| -XX:+UseConcMarkSweepGC | CMS + ParNew |
| -XX:+UseG1GC | G1 |

## 细节

周志明的书中有一段备注信息：

> 需要说明一下， Parallel Scavenge 收集器架构中本身有 PS MarkSweep 收集器来进行老年代收集， 并非直接调用 Serial Old 收集器， 但是这个 PS MarkSweep 收集器与 Serial Old 的实现几乎是一样的， 所以在官方的许多资料中都是直接以 Serial Old 代替 PS MarkSweep 进行讲解， 这里笔者（周志明）也采用这种方式。

这段话其实是这个意思：
1. PS MarkSweep 只是回收器的别名，他可以指代 Serial Old 和 Parallel Old。
2. `-XX:+UseParallelGC` 和 `-XX:+UseParallelOldGC` 都是用 Parallel Old

参考这个 [JDK commit 信息](https://bugs.openjdk.org/browse/JDK-6679764)：

![image.png](/static/img/c81f65547e9a7e3d7f6af0ebe031775c.image.webp)

在 JDK 7U4 之前确实 UserParallelGC 用的就是 Serial，在这个版本之后 Parallel 已经很成熟了，所以直接替换了旧的收集器，所以 JDK 7u4 以后的 7 和 JDK 8 老年代默认使用的都是 Parallel 收集器，只是周志明的书中没有更新这个细节。