> 在日常开发中用过的vue插件收集，并记录下来

### moment时间格式化

```
#安装 引用
npm install moment
import moment from "moment";
```

```
#常用方法
获取指定日期的时间戳：
moment('2020-07').startOf('day').format('x')
当前月：
moment().format('MM')
 
当前季度：
moment().quarter()
 
当前年：
moment().format("YYYY") 
moment().year(); // Number
 
上一年/下一年：
 1. 上一年 ： moment().add(-1,'Q').format("YYYY")
 2. 下一年 ： moment().add(1,'Q').format("YYYY")
 3.  上几年和下几年同理，做moment日期加减，月季度亦同理
 
上一季度/下一季度：
 1. 上一季度：moment().add(-1, 'Q').quarter()
 2. 下一季度：moment().add(1, 'Q').quarter()
 
上个月/下个月
 1. 上个月：momnet().add(-1,'M').format("MM")
 2. 下个月：moment().add(1,'M').format("MM")
 
年开始结束时间：
 1. moment().startOf('year')
 2. moment().endOf('year')
 
季度开始结束时间：
 
 1. 当前季度的开始结束时间：
  moment().startOf('quarter').format("YYYY-MM-DD")
  moment().endOf('quarter').format("YYYY-MM-DD")
 
 2. 指定年指定季度的开始结束时间：（某年某季度的开始结束时间）
 
  moment(moment().format("YYYY-02-        01")).startOf('quarter').format("YYYY-MM-DD")
  moment(moment().format("YYYY-02-01")).endOf('quarter').format("YYYY-MM-DD")
 
#当天0点的时间格式 ：
  moment().startOf('day').format('YYYY-MM-DD HH:mm:ss') 
 
#当天0点的时间缀，以10位Unix时间戳输出(秒）：
  moment().startOf('day').format('X') 
 
#当天23点59分59秒的时间格式：
  moment().endOf('day').format('YYYY-MM-DD HH:mm:ss')  
 
#当天23点59分59秒以13位Unix时间戳输出（毫秒）：
  moment().endOf('day').format('x')  
 
#2020-06-30当天0点的以13位Unix时间戳输出（毫秒）：
  moment('2020-06-30').startOf('day').format('x')  
 
#2020-06-30当天24点的以13位Unix时间戳输出（毫秒）：
  moment('2020-06-30').endOf('day').format('x') 
# 获取今天0时0分0秒
moment().startOf('day')
 
# 获取本周第一天(周日)0时0分0秒
moment().startOf('week')
 
# 获取本周周一0时0分0秒
moment().startOf('isoWeek')
 
# 获取当前月第一天0时0分0秒
moment().startOf('month')
 
# 获取指定日期的0时0分0秒
moment('2019-10-20').startOf('day')
 
# 获取今天23时59分59秒
moment().endOf('day')
 
# 获取本周最后一天(周六)23时59分59秒
moment().endOf('week')
 
# 获取本周周日23时59分59秒
moment().endOf('isoWeek')
 
# 获取当前月最后一天23时59分59秒
moment().endOf('month')
 
# 获取当月第一天是星期几（用于设置星期几，其中星期日为 0、星期六为 6）
moment().startOf('month').day()
 
获取前n天 / 后n天
moment().add(7, 'days');
moment().subtract(7, 'days')
 
比较两个时间的大小
 
# 第二个参数用于确定精度，且不仅仅是要检查的单个值，因此使用 day 将会检查年份、月份、日期。
 
moment('2010-10-31').isBefore('2010-12-31', 'day');
# true
 
moment('2010-10-20').isBefore('2010-12-31', 'year');
# false
 
moment('2010-10-20').isAfter('2009-12-31', 'year'); 
# true
 
moment('2010-10-20').isSame('2009-12-31', 'year'); 
# 判断两个时间是否相等
 
# 需要注意的是， isBefore与isAfter 都是开区间，如果想使用闭区间，应使用
isSameOrBefore
 
两个时间的相差几天
moment([2008, 2, 27]).diff([2007, 0, 28], 'day');
# 424
 
是否是闰年
 
moment().isLeapYear();
# true
 
moment([2001]).isLeapYear() 
# false
 
获取 月份和星期 枚举列表
moment.months()
 
# ["January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"]
 
moment.monthsShort()
# ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"]
 
moment.weekdays()
# ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"]
 
moment.weekdaysMin()
# ["Su", "Mo", "Tu", "We", "Th", "Fr", "Sa"]
 
格式化
moment().format();
# 2020-03-14T19:14:05+08:00
 
moment().format('YYYY-MM-DD HH:mm:ss');
# 2020-03-14 19:23:29
 
//获取当前时间
var now = moment().toDate();//Mon Jul 06 2020 13:50:51 GMT+0800 (中国标准时间)
console.log(now)
 
//格式化当前时间
now = moment().format('YYYY-MM-DD');//2020-07-06
console.log(now);
 
//获取这个月初时间
let startMonth = moment().startOf('month').toDate();
console.log(startMonth);
 
//获取今天开始的时间，
let dayOfStart = moment().startOf('day').toDate();
console.log(dayOfStart);
 
//获取今天结束的时间
let dayOfEnd = moment().endOf('day').toDate();
console.log(dayOfEnd);
 
 
//获取＋n小时
let lateHour = moment().add(2,'hour').toDate();
console.log(lateHour);
 
//获取＋n小时
console.log('//获取-n小时')
let beforeHour = moment().subtract(2,'hour').toDate();
console.log(beforeHour);
 
//获取＋n天
let lateDay = moment().add(+5,'day').toDate();
console.log(lateDay);
 
//获取-n天
let beforeDay = moment().add(-5,'day').toDate();
console.log(beforeDay);
//也可以表示为
beforeDay = moment().subtract(5,'day').toDate();
console.log(beforeDay);
 
console.log('//获取＋n月')
let lateMonth = moment().add(2,'month').toDate();
console.log(lateHour);
 
//获取＋n月
let beforeMonth = moment().subtract(2,'month').toDate();
console.log(lateHour); 
 
//获取星期
let week = moment().format('dddd');
console.log(week);
 
//获取到现在的年限 如果不满一年显示出具体几个月
let years = moment('2020-12-31').fromNow();
前三个月（自然月）：
moment().month(moment().month() - 3).startOf('month')
moment().month(moment().month() - 1).endOf('month')
 
上月：
moment().month(moment().month() - 1).startOf('month')
moment().month(moment().month() - 1).endOf('month')
 
本月：
[moment().startOf('month'), moment().endOf('month')]
 
7天：
[moment().subtract(7,'day'), moment()]
 
获取月份天数：
moment().daysInMonth()
 
判断日期大小
moment('2010-10-20').isAfter('2010-10-19'); // true
 
```

### MD5加密

```
#安装 引用
npm install --save js-md5
import md5 from 'js-md5';
Vue.prototype.$md5 = md5;

#使用
this.$md5('hello word!') 

#局部引用
import md5 from 'js-md5';
md5('hello word!')
```

### Base64加密解密

```
#安装 引用
import {Base64} from 'js-base64'
Vue.prototype.$Base64 = Base64;
或
import Base64 from 'js-base64'
Vue.use(Base64)

#使用
let encPass=this.$Base64.encode(password); // 加密
let decPass=this.$Base64.decode(encPass); // 解密
```

Vue件收集

SpringBoot整合TrueLicense

### 取余(remainder)

> 取余数是指整数除法中被除数未被除尽部分，且余数的取值范围为0到除数之间（不包括除数）的整数
>
> 公式: r = a-(a/b)*b


#### 1、求被除数与除数都为整数

```
例子: 
rem(10,8)=?;
10/8 = 1...2;
那么rem(10,8)=2;
```
#### 2、求被除数为负数，除数为负数

```
例子: 
rem(-10,-8)=?;
-10/-8 = 1...2;
那么rem(-10,-8)=-2;
```

#### 3、求被除数为负数，除数为整数

```
例子: 
rem(-10,8)=?;
c = (-10/8=-1.25);
如果商不为整数，取余为向0方向舍弃小数点，所以如下
r = -1;
套入公式
r = -10-(-1*8);
r = -2;
```

#### 4、求被除数为整数，除数为负数

```
例子: 
rem(10,-8)=?;
c = (10/-8=-1.25);
如果商不为整数，取余为向0方向舍弃小数点，所以如下
c = -1;
套入公式
r = 10-(-1*-8);
r = 2;
```

### 取模(modulo)

> 取模运算是求两个数相除的余数。

#### 1、求被除数与除数都为整数

```
例子: 
mod(10,8)=?;
10/8 = 1...2;
那么mod(10,8)=2;
```

#### 2、求被除数为负数，除数为负数

```
例子: 
mod(-10,-8)=?;
-10/-8 = 1...2;
那么mod(-10,-8)=-2;
```

#### 3、求被除数为负数，除数为整数

```
例子: 
mod(-10,8)=?;
c = (-10/8=-1.25);
如果商不为整数，取模向负无穷方向舍弃小数位，可以理解为舍弃小数点后+(-1)，所以如下
c = -1 + -1;
套入公式
m = -10-(-2*8);
m = 6;
```

#### 4、求被除数为整数，除数为负数

```
例子: 
mod(10,-8)=?;
c = (10/-8=-1.25);
如果商不为整数，取模向负无穷方向舍弃小数位，可以理解为舍弃小数点后+(-1)，所以如下
c = -1 + 1;
套入公式
m = 10-(-2*-8);
m = -6;
```

### ### 取余和取模的区别?

1、被除数和除数同号时，取余和取模无差别，结果无差异。

2、被除数和除数是异号时

取余:**取余运算在计算商值向0方向舍弃小数位**

取模:**取模运算在计算商值向负无穷方向舍弃,小数位可以理解为舍弃小数点后+(-1)**

取余和取模

Docker容器运行node,搭建hexo博客。


### 安装node容器环境

#### 1、拉取镜像

> docker pull node

#### 2、启动并运行

> docker run -it --name my-blog -p 4000:4000 -v /home/hexo:/mydata/blog -t node /bin/bash

### 初始化hexo

#### 1、进入挂载文件路径(放入博客文件)

> cd /mydata/blog 

#### 2、安装hexo

npm install -g hexo-cli

#### 3、创建hexo 初始化

> mkdir hexo && cd hexo &&  hexo init
>
> #如果自己本地没有hexo 博客,执行
>
> npm install
>
> hexo s
>
> #访问localhost:4000

**新建完成后，指定文件夹目录下有**：

- node_modules: 依赖包
- public：存放生成的页面
- scaffolds：生成文章的一些模板
- source：用来存放你的文章
- themes：主题
- ** _config.yml: 博客的配置文件**

#### 4、本地自己的blog放到Docker

> 用Xftp导入文件,下图其他文件导入到/mydata/blog/hexo下

![image-20220531210020516](https://chensh888.com:8090/file/blog/2022/20220531210022.png)

#### 5、初始化新的依赖包

>  npm install

### 后台启动hexo

官方给出的方法是`$ hexo s &`,试了一下进程还是莫名其妙中断了。于是百度出用 pm2 运行解决了。

#### 1、安装pm2

>```undefined
>npm install -g pm2
>```

#### 2、在博客根目录下创建一个文件 `start.js`

```
//start.js
const { exec } = require('child_process')
exec('hexo clean && hexo g && hexo s',(error, stdout, stderr) => {
  if(error){
    console.log(`exec error: ${error}`)
    return
  }
  console.log(`stdout: ${stdout}`);
  console.log(`stderr: ${stderr}`);
})
```

#### 3、运行脚本

>#--name 给项目起个名字
>
>pm2 start start.js --name my-hexo-blog

![image-20220531212630047](https://chensh888.com:8090/file/blog/2022/20220531212632.png)

#### 4、常用命令

```
pm2 examples 						#可以查看一些常用的例子，基本一看就知道什么意思
pm2 ls								#查看项目列表
pm2 stop appName 					#停止项目
pm2 delete appName				    #删除项目
pm2 info appName					#查看项目信息
pm2 logs appName [--lines 1000]		#查看日志
```

Docker部署hexo博客

业务:A系统需要把待办推送到B系统.
情况1:用了定时任务每分钟推送。
情况2:如果A系统在生成待办时调用定时任务的方法手动推送。
所以出现了多线程执行，导致方法重复执行。
使用同步锁解决问题!

### 问题复现!

```
# 定时任务代码
    @Scheduled(cron = "*/3 * * * * ?")
    public  void ceShi() {
        try {
            log.info(Thread.currentThread().getName());
            Thread.sleep(5000);
        } catch (Exception e) {
            log.error("待办portalWork表推送OA任务异常", e);
        }
    }
    
# 普通接口
    @RequestMapping("/ceShi")
    public void ceShi() {
        portalWorkTask.ceShi();
    }
```

> 游览器重复调用/ceShi 接口

http://127.0.0.1:8077/ceShi

> 查看idea控制台，在方法中睡眠5秒钟重复进入方法!

![image-20220531140528319](https://chensh888.com:8090/file/blog/2022/20220531140531.png)

### 解决问题

#### 1、使用synchronized

#### 2、ReentrantLock

```
private final ReentrantLock lock = new ReentrantLock();
 lock.lock();
        try {
            log.info(Thread.currentThread().getName());
            Thread.sleep(5000);
        } catch (Exception e) {
            log.error("待办portalWork表推送OA任务异常", e);
        } finally {
            lock.unlock();
        }
```

#### 3、验证

> 可以看到进入方法中,如果存在锁，必须等待，释放完锁后，再次进入方法!

![image-20220531140847769](https://chensh888.com:8090/file/blog/2022/20220531140849.png)

### 扩展
#### Synchronized 与 ReentrantLock 的区别!

synchronized 是和 if、else、for、while 一样的关键字，ReentrantLock 是类，这是二者的本质区别。既然 ReentrantLock 是类，那么它就提供了比synchronized 更多更灵活的特性，可以被继承、可以有方法、可以有各种各样的类变量

**相同点**：两者都是可重入锁

两者都是可重入锁。“可重入锁”概念是：自己可以再次获取自己的内部锁。比如一个线程获得了某个对象的锁，此时这个对象锁还没有释放，当其再次想要获取这个对象的锁的时候还是可以获取的，如果不可锁重入的话，就会造成死锁。同一个线程每次获取锁，锁的计数器都自增1，所以要等到锁的计数器下降为0时才能释放锁。

**主要区别如下**：

1. ReentrantLock 使用起来比较灵活，但是必须有释放锁的配合动作；
1. ReentrantLock 必须手动获取与释放锁，而 synchronized 不需要手动释放和开启锁；
1. ReentrantLock 只适用于代码块锁，而 synchronized 可以修饰类、方法、变量等。
1. 二者的锁机制其实也是不一样的。ReentrantLock 底层调用的是 Unsafe 的park 方法加锁，synchronized 操作的应该是对象头中 mark word

**Java中每一个对象都可以作为锁，这是synchronized实现同步的基础**：

1. 普通同步方法，锁是当前实例对象
1. 静态同步方法，锁是当前类的class对象
1. 同步方法块，锁是括号里面的对象

#### synchronized与Lock的区别及底层实现?

**答**:
1. synchronized属于JVM层面，属于java的关键字

- 	monitorenter（底层是通过monitor对象来完成，其实wait/notify等方法也依赖于monitor对象 只能在同步块或者方法中才能调用 wait/ notify等方法）
- Lock是具体类（java.util.concurrent.locks.Lock）是api层面的锁
2. Lock必须手动释放锁，否则会产生死锁，synchronized系统会自动释放锁，而且不可中断，lock方法中可以实现中断。
3. Lock默认是非公平锁，也可以是公平锁，synchronized非公平锁

**公平锁**：多个线程按照申请锁的顺序去获得锁，线程会直接进入队列去排队，永远都是队列的第一位才能得到锁。

- 优点：所有的线程都能得到资源，不会饿死在队列中。
- 缺点：吞吐量会下降很多，队列里面除了第一个线程，其他的线程都会阻塞，cpu唤醒阻塞线程的开销会很大。

**非公平锁**：多个线程去获取锁的时候，会直接去尝试获取，获取不到，再去进入等待队列，如果能获取到，就直接获取到锁。

- 优点：可以减少CPU唤醒线程的开销，整体的吞吐效率会高点，CPU也不必取唤醒所有线程，会减少唤起线程的数量。
- 缺点：你们可能也发现了，这样可能导致队列中间的线程一直获取不到锁或者长时间获取不到锁，导致饿死。


**使用方法：**
1. synchronized不需要用户手动释放锁，当synchronized代码块执行完成后，系统会自动让线程释放对锁的占用
1. ReentrantLock需要用户手动释放锁，若没有手动释放可能导致死锁现象。

**等待是否可中断：**
1. synchronized不可中断，除非抛出异常或者正常运行完成
1. ReentrantLock可中断

**加锁是否公平：**
1. synchronized非公平锁
1. ReentrantLock两者都可以，默认是非公平锁。

**锁绑定多个条件Condition：**
1. synchronized没有。
1. ReentrantLock可用来分组唤醒需要唤醒的线程。而不是像synchronized要么随机唤醒一个线程，要么唤醒所有线程。

多线程之间按顺序调用，实现A->B->C三个线程启动，要求如下：

* AA打印5次，BB打印10次，CC打印15次
* 紧接着
* AA打印5次，BB打印10次，CC打印15次
* 来10轮

``` java 
class ShareResource {
    private int number = 1;
    private Lock lock = new ReentrantLock();
    private Condition condition1 = lock.newCondition();
    private Condition condition2 = lock.newCondition();
    private Condition condition3 = lock.newCondition();
 
    public void print5() {
        lock.lock();
        try {
            while (number != 1) {
                condition1.await();
            }
            for (int i = 1; i <= 5; i++) {
                System.out.println(Thread.currentThread().getName() + " " + i);
            }
            number = 2;
            condition2.signal();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
 
 
    public void print10() {
        lock.lock();
        try {
            while (number != 2) {
                condition2.await();
            }
            for (int i = 1; i <= 10; i++) {
                System.out.println(Thread.currentThread().getName() + " " + i);
            }
            number = 3;
            condition3.signal();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
 
 
    public void print15() {
        lock.lock();
        try {
            while (number != 3) {
                condition3.await();
            }
            for (int i = 1; i <= 15; i++) {
                System.out.println(Thread.currentThread().getName() + " " + i);
            }
            number = 1;
            condition1.signal();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
}
 
public class SyncAndReentrantLockDemo {
 
    public static void main(String[] args) {
        ShareResource shareResource = new ShareResource();
        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                shareResource.print5();
            }
        }, "AAA").start();
 
        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                shareResource.print10();
            }
        }, "BBB").start();
 
        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                shareResource.print15();
            }
        }, "CCC").start();
    }
}
```

#### 公平锁、非公平锁、可重入锁、自旋锁、独占锁、共享锁

**公平锁：** 多个线程按照申请锁的顺序去获得锁，线程会直接进入队列去排队，永远都是队列的第一位才能得到锁。

- 优点：所有的线程都能得到资源，不会饿死在队列中。
- 缺点：吞吐量会下降很多，队列里面除了第一个线程，其他的线程都会阻塞，cpu唤醒阻塞线程的开销会很大。

**非公平锁：** 多个线程去获取锁的时候，会直接去尝试获取，获取不到，再去进入等待队列，如果能获取到，就直接获取到锁。

- 优点：可以减少CPU唤醒线程的开销，整体的吞吐效率会高点，CPU也不必取唤醒所有线程，会减少唤起线程的数量。
- 缺点：你们可能也发现了，这样可能导致队列中间的线程一直获取不到锁或者长时间获取不到锁，导致饿死。

**可重入锁(也叫递归锁)：**
线程可以进入任何一个它已经拥有的锁所同步的代码块(如：租房，门外面是一把门锁，进去之后厕所、厨房不会安装锁，直接可以用)

手写自旋锁
``` java

public class AtomicTest {
    AtomicReference<Thread> atomicReference = new AtomicReference<Thread>();

    public void myLock() {
        Thread thread = Thread.currentThread();
        System.out.println(thread.getName() + "^_^");
        while (!atomicReference.compareAndSet(null, thread)) {

        }
    }

    public void myOnLock() {
        Thread thread = Thread.currentThread();
        System.out.println(thread.getName() + "关闭");
        atomicReference.compareAndSet(thread,null);
    }

    public void test(Integer i){
        System.out.println(Thread.currentThread().getName()+"打印"+i);
    }

    public static void main(String[] args){
        AtomicTest atomicTest = new AtomicTest();

        new Thread(() -> {
            atomicTest.myLock();
            try {
                Thread.sleep(5);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            atomicTest.myOnLock();
        },"t1").start();
        new Thread(() -> {
            atomicTest.myLock();
            atomicTest.myOnLock();
        },"t2").start();

        AtomicInteger atomicReference1 = new AtomicInteger();
        AtomicInteger atomicReference2 = new AtomicInteger(5);
        System.out.println(1);

       }
}
```

**自旋锁：** 是指尝试获取锁的线程不会立即阻塞，而是采用循环的方式去尝试获取锁，这样的好处是减少线程上线文切换的消耗，缺点是循环会消耗CPU

**独占锁：** 该锁一直只能被一个线程所持有。lock和synchronized都是独占锁

**共享锁：** 该锁可被多个线程所持有。读写分离。

一、简介

取余(remainder)