### 取余(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都是独占锁

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

解决手动执行接口和定时任务冲突

突然想要升级IDEA，留下笔记安装带破解。

新版界面好看，代码提示比老版本更全，感觉接触了新idea一样！！！



> 2019.3.3 -> 2021.3.3

### 1、下载安装idea2021.3.3

官网慢,百度找一个云盘下载即可! ==安装最好不要有中文路径!==

[官网下载旧版本地址](https://www.jetbrains.com/idea/download/other.html)


### 2、下载破解jar包

放到固定位置，不要有中文目录名称。

[本人gitee下载](https://gitee.com/ChenShaoshao/blog-related/blob/master/IDEA/2021.3.3%E7%A0%B4%E8%A7%A3jar%E5%8C%85/ja-netfilter.jar)

### 3、破解

#### 1、进入到bin目录下

```
# 1、打开文件idea64.exe.vmoptions，添加内容(-javaagent:破解jar放的目录)
-javaagent:E:\exploitSoftWore\IntelliJ IDEA 2021.3.3\ja-netfilter-all\ja-netfilter.jar=jetbrains
# 2、创建idea.vmoptions
-Xms128m
-Xmx1024m
-XX:ReservedCodeCacheSize=512m
-XX:+IgnoreUnrecognizedVMOptions
-XX:+UseG1GC
-XX:SoftRefLRUPolicyMSPerMB=50
-XX:CICompilerCount=2
-XX:+HeapDumpOnOutOfMemoryError
-XX:-OmitStackTraceInFastThrow
-ea
-Dsun.io.useCanonCaches=false
-Djdk.http.auth.tunneling.disabledSchemes=""
-Djdk.attach.allowAttachSelf=true
-Djdk.module.illegalAccess.silent=true
-Dkotlinx.coroutines.debug=off
-XX:ErrorFile=$USER_HOME/java_error_in_idea_%p.log
-XX:HeapDumpPath=$USER_HOME/java_error_in_idea.hprof


```

#### 2、启动idea,输入code

```
4W9NP3KV9E-eyJsaWNlbnNlSWQiOiI0VzlOUDNLVjlFIiwibGljZW5zZWVOYW1lIjoic2NyaXAgd2FuZSIsImFzc2lnbmVlTmFtZSI6IiIsImFzc2lnbmVlRW1haWwiOiIiLCJsaWNlbnNlUmVzdHJpY3Rpb24iOiIiLCJjaGVja0NvbmN1cnJlbnRVc2UiOmZhbHNlLCJwcm9kdWN0cyI6W3siY29kZSI6IklJIiwiZmFsbGJhY2tEYXRlIjoiMjAyMy0wMS0yNCIsInBhaWRVcFRvIjoiMjAyMy0wMS0yNCIsImV4dGVuZGVkIjpmYWxzZX0seyJjb2RlIjoiUERCIiwiZmFsbGJhY2tEYXRlIjoiMjAyMy0wMS0yNCIsInBhaWRVcFRvIjoiMjAyMy0wMS0yNCIsImV4dGVuZGVkIjp0cnVlfSx7ImNvZGUiOiJQV1MiLCJmYWxsYmFja0RhdGUiOiIyMDIzLTAxLTI0IiwicGFpZFVwVG8iOiIyMDIzLTAxLTI0IiwiZXh0ZW5kZWQiOnRydWV9LHsiY29kZSI6IlBHTyIsImZhbGxiYWNrRGF0ZSI6IjIwMjMtMDEtMjQiLCJwYWlkVXBUbyI6IjIwMjMtMDEtMjQiLCJleHRlbmRlZCI6dHJ1ZX0seyJjb2RlIjoiUFBTIiwiZmFsbGJhY2tEYXRlIjoiMjAyMy0wMS0yNCIsInBhaWRVcFRvIjoiMjAyMy0wMS0yNCIsImV4dGVuZGVkIjp0cnVlfSx7ImNvZGUiOiJQUEMiLCJmYWxsYmFja0RhdGUiOiIyMDIzLTAxLTI0IiwicGFpZFVwVG8iOiIyMDIzLTAxLTI0IiwiZXh0ZW5kZWQiOnRydWV9LHsiY29kZSI6IlBSQiIsImZhbGxiYWNrRGF0ZSI6IjIwMjMtMDEtMjQiLCJwYWlkVXBUbyI6IjIwMjMtMDEtMjQiLCJleHRlbmRlZCI6dHJ1ZX0seyJjb2RlIjoiUFNXIiwiZmFsbGJhY2tEYXRlIjoiMjAyMy0wMS0yNCIsInBhaWRVcFRvIjoiMjAyMy0wMS0yNCIsImV4dGVuZGVkIjp0cnVlfSx7ImNvZGUiOiJQU0kiLCJmYWxsYmFja0RhdGUiOiIyMDIzLTAxLTI0IiwicGFpZFVwVG8iOiIyMDIzLTAxLTI0IiwiZXh0ZW5kZWQiOnRydWV9LHsiY29kZSI6IlBDV01QIiwiZmFsbGJhY2tEYXRlIjoiMjAyMy0wMS0yNCIsInBhaWRVcFRvIjoiMjAyMy0wMS0yNCIsImV4dGVuZGVkIjp0cnVlfV0sIm1ldGFkYXRhIjoiMDEyMDIyMDEyMVBTQU4wMDAwMDUiLCJoYXNoIjoiVFJJQUw6LTYyNTA2MDI4NyIsImdyYWNlUGVyaW9kRGF5cyI6NywiYXV0b1Byb2xvbmdhdGVkIjpmYWxzZSwiaXNBdXRvUHJvbG9uZ2F0ZWQiOmZhbHNlfQ==-WlwI3NBiapY7em4MmP7qdZcTK2wvAt5f7FNwaH65H6SBvWnFGpe8M2VrSWCEBIGFQpv+VFJLghJKLjaRUcVOY6ttC6G4uKTpuPzELgcckez+/9DPrYj+alvLYFpS6UWy4uqzsjC/sHgcbNiCQjZQMVhj8Wflv9ts8SfWUqTwtciG8eBrzbyipXOVrRn5Wpk3l6ifL71HZsMy3bDLU8Lkt3UQBNVFZhXWBcNyY/WB9CQGX+6aXtbFA9p/hjbTZL050UoeM30rz0UkzPmfiIupbb3KNPKPArQkU8gw6pF7AcRSLuU3HNqq8RDbrXDYSXY9vtoD3Oi18ijlagVANrhjpQ==-MIIETDCCAjSgAwIBAgIBDTANBgkqhkiG9w0BAQsFADAYMRYwFAYDVQQDDA1KZXRQcm9maWxlIENBMB4XDTIwMTAxOTA5MDU1M1oXDTIyMTAyMTA5MDU1M1owHzEdMBsGA1UEAwwUcHJvZDJ5LWZyb20tMjAyMDEwMTkwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQCUlaUFc1wf+CfY9wzFWEL2euKQ5nswqb57V8QZG7d7RoR6rwYUIXseTOAFq210oMEe++LCjzKDuqwDfsyhgDNTgZBPAaC4vUU2oy+XR+Fq8nBixWIsH668HeOnRK6RRhsr0rJzRB95aZ3EAPzBuQ2qPaNGm17pAX0Rd6MPRgjp75IWwI9eA6aMEdPQEVN7uyOtM5zSsjoj79Lbu1fjShOnQZuJcsV8tqnayeFkNzv2LTOlofU/Tbx502Ro073gGjoeRzNvrynAP03pL486P3KCAyiNPhDs2z8/COMrxRlZW5mfzo0xsK0dQGNH3UoG/9RVwHG4eS8LFpMTR9oetHZBAgMBAAGjgZkwgZYwCQYDVR0TBAIwADAdBgNVHQ4EFgQUJNoRIpb1hUHAk0foMSNM9MCEAv8wSAYDVR0jBEEwP4AUo562SGdCEjZBvW3gubSgUouX8bOhHKQaMBgxFjAUBgNVBAMMDUpldFByb2ZpbGUgQ0GCCQDSbLGDsoN54TATBgNVHSUEDDAKBggrBgEFBQcDATALBgNVHQ8EBAMCBaAwDQYJKoZIhvcNAQELBQADggIBAB2J1ysRudbkqmkUFK8xqhiZaYPd30TlmCmSAaGJ0eBpvkVeqA2jGYhAQRqFiAlFC63JKvWvRZO1iRuWCEfUMkdqQ9VQPXziE/BlsOIgrL6RlJfuFcEZ8TK3syIfIGQZNCxYhLLUuet2HE6LJYPQ5c0jH4kDooRpcVZ4rBxNwddpctUO2te9UU5/FjhioZQsPvd92qOTsV+8Cyl2fvNhNKD1Uu9ff5AkVIQn4JU23ozdB/R5oUlebwaTE6WZNBs+TA/qPj+5/we9NH71WRB0hqUoLI2AKKyiPw++FtN4Su1vsdDlrAzDj9ILjpjJKA1ImuVcG329/WTYIKysZ1CWK3zATg9BeCUPAV1pQy8ToXOq+RSYen6winZ2OO93eyHv2Iw5kbn1dqfBw1BuTE29V2FJKicJSu8iEOpfoafwJISXmz1wnnWL3V/0NxTulfWsXugOoLfv0ZIBP1xH9kmf22jjQ2JiHhQZP7ZDsreRrOeIQ/c4yR8IQvMLfC0WKQqrHu5ZzXTH4NO3CwGWSlTY74kE91zXB5mwWAx1jig+UXYc2w4RkVhy0//lOmVya/PEepuuTTI4+UJwC7qbVlh5zfhj8oTNUXgN0AOc+Q0/WFPl1aw5VV/VrO8FCoB15lFVlpKaQ1Yh+DVU8ke+rt9Th0BCHXe0uZOEmH0nOnH/0onD
```

![1653572056.png](/static/img/bd5b2b8561c7ff8cbfb110dc6afa5a16.1653572056.webp)

#### 3、激活成功

![1653572207.png](/static/img/37427349d0524b1cebd238b4b423a4d4.1653572207.webp)

安装Idea2021.3.3加破解

Docker Compose


# Docker Compose

## 1、简介   

Docker Compose来轻松高效的管理容器，定义运行多个容器。  
Compose是Docker官方的开源项目,需要安装  
DockerFile让程序在任何地方运行。web服务、redis、mysql多个容器。  
如果一个一个启动就需要run3个，而Compose只需要编写一个yml文件就可以启动多个。  

```
version: "3.9"  # optional since v1.27.0
services:
  web:
    build: .
    ports:
      - "8000:5000"
    volumes:
      - .:/code
      - logvolume01:/var/log
    links:
      - redis
  redis:
    image: redis
volumes:
  logvolume01: {}
```

docker-compose up 100个服务。  

**Compose**：重要的概念。  

- 服务services, 容器。应用。（web、redis、mysql.…)
- 项目project。一组关联的容器。博客。web

## 2、安装方式1(通过curl)

```
#下载地址
curl -L https://get.daocloud.io/docker/compose/releases/download/v2.5.0/docker-compose-`uname -s`-`uname -m` > /usr/local/bin/docker-compose
#赋权
sudo chmod +x /usr/local/bin/docker-compose
#验证
docker-compose version
```

## 3、安装方式2(推荐:手动安装)

- [docker-compose官网](https://github.com/docker/compose)下载匹配版本

- 下载docker-compose-linux-x86_64并上传linux

- 执行如下命令

  ```
  mv docker-compose-linux-x86_64 /usr/local/bin/docker-compose
  chmod +x docker-compose
  ```
- 验证docker-compose *--version*

## 4、测试示例

> 官网教程
>
> > 地址:https://docs.docker.com/compose/gettingstarted/
> > Docker Compose --> Getting started

### 1）为项目创建一个目录：

```
mkdir composetest
cd composetest
```

### 2）在项目目录中创建一个名为的文件app.py并将其粘贴到：

```
import time

import redis
from flask import Flask

app = Flask(__name__)
cache = redis.Redis(host='redis', port=6379)

def get_hit_count():
    retries = 5
    while True:
        try:
            return cache.incr('hits')
        except redis.exceptions.ConnectionError as exc:
            if retries == 0:
                raise exc
            retries -= 1
            time.sleep(0.5)

@app.route('/')
def hello():
    count = get_hit_count()
    return 'Hello World! I have been seen {} times.\n'.format(count)
```

### 3）在您的项目目录中创建另一个名为的文件requirements.txt并将其粘贴到:

```
flask
redis
```

### 4）创建 Dockerfile

```
# syntax=docker/dockerfile:1
FROM python:3.7-alpine
WORKDIR /code
ENV FLASK_APP=app.py
ENV FLASK_RUN_HOST=0.0.0.0
RUN apk add --no-cache gcc musl-dev linux-headers
COPY requirements.txt requirements.txt
RUN pip install -r requirements.txt
EXPOSE 5000
COPY . .
CMD ["flask", "run"]
```

这告诉 Docker：

- 从 Python 3.7 映像开始构建映像。
- 将工作目录设置为/code.
- 设置命令使用的环境变量flask。
- 安装 gcc 和其他依赖项
- 复制requirements.txt并安装 Python 依赖项。
- 向镜像添加元数据以描述容器正在侦听端口 5000
- 将项目中的当前目录复制.到镜像中的workdir .。
- 将容器的默认命令设置为flask run.

### 5）在 Compose 文件中定义服务  

这个 Compose 文件定义了两个服务：web和redis.

```
version: "3.9"
services:
  web:
    build: .
    ports:
      - "8000:5000"
  redis:
    image: "redis:alpine"
```

### 6）使用 Compose 构建并运行您的应用程序


```
docker-compose up
```

### 7）测试

```
http://localhost:8000
```

默认的服务名 文件名_服务名_num    
多个服务器。集群。AB_num副本数量    
服务redis服务=>4个副本。  
集群状态。服务都不可能只有一个运行实例。弹性、10HA高井发。    
kubectl service负载均衡。   

### 8）停止

```
#在/usr/local/bin/docker-compose目录下执行
docker-compose down
#暴力停止
ctrl+c
```

**docker-compose小结** 
以前都是单个docker run启动容器。  
docker-compose。通过 docker-compose   编写yaml配置文件、可以通过compose一键启动所有服务，停止。！