业务: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都是独占锁

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

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

因为需要C语言完成某些作业，学习并且安装C语言。

helloWord!



### 1、安装C/C++语言

> 官网地址:https://www.mingw-w64.org/

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

> 找到这个SourceForge



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



> 点击File > mingw-w64

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

> 下载x86_64-win32-seh安装包(注:下载其他的安装报错了)

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

> 解压并配置环境变量

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

> 验证

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

### 2、VSCODE运行第一个HelloWord

#### 1、下载C语言插件

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

#### 2、配置GCC

> 输入CTRL+SHIFT+P

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

> 设置压缩包路径

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

### 3、运行HelloWord

> 创建HelloWord.c

```
#include <stdio.h>
 
int main()
{
    /* 我的第一个 C 程序 */
    printf("Hello, World! \n");
 
    return 0;
}
```

> 运行

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

使用vscode运行和调试c/c++第一个HelloWord!

突然想要升级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一键启动所有服务，停止。！

Docker Compose

Docker网络

### Docker网络

#### 理解Docker网络

```
# 创建tomacat容器 启动 并执行 ip addr
docker run --name tomcat01 -p 8080:8080 tomcat
docker exec -it tomcat01 ip addr 
# 查询宿主机 docker网络 与tomcat容器网络ping
```

 **原理**  
1、我们每启动一个docker容器，docker就会给docker容器分配一个ip，我们只要安装了docker，就会有一介网卡dockero桥接模式，使用的技术是==veth-pair==技术！

2、veth-pair

```
#我们发现这个容器带来网卡，都是一对的
#evth-pair就是一对的虚拟设备接口，他们都是成对出现的，一段连着协议，一段彼此相连
#、正因为有这个特性，evth-pair充当一个桥梁，连接各种虚拟网络设备的
#openstac,Docker容器之间的连接，ovs的连接，都是使用 veth-pair技术
```

3、容器之间测试

![pasted-8.png](/static/img/844a2184e1cad6a3a0fb3d24de4aaaef.pasted-8.webp)

结论: tomcat01、tomcat02是共用一个路由器
所有容器不指定网络的情况下,都是docker0路由分配一个默认可用的ip

核心网络原理图  

![pasted-7.png](/static/img/e41dbb0007c1ce82f897d09a0f00975d.pasted-7.webp)

Docker中的所有网络接口都是虚拟的，虚拟的转发效率高!(内网传递文件!)  
只要容器删除，对应网络桥接一对就消失了!

#### --Link

思考一个场景，我们编写了一个微服务，database url=ip：，项目不重启，数据库ip换掉了，我们希望可以处理这个问题，可以名字来进行访问容器

```
# 启动2个tomcat 01 02
# 通过容器名尝试ping
[root@MiWiFi-RA81-srv ~]# docker exec -it tomcat02 ping tomcat01
ping: tomcat01: No address associated with hostname

# 如何解决呢?
## --link可以解决(注:单向的)
[root@MiWiFi-RA81-srv ~]# docker run -d --name tomcat03 --link tomcat02 mytomcat:1.0
80475d4b31170527c2e4a88c8c53ca9b43ee0657e3e9a65814c4e669f38cfb16
[root@MiWiFi-RA81-srv ~]# docker exec -it tomcat03 ping tomcat02
PING tomcat02 (172.17.0.5) 56(84) bytes of data.
64 bytes from tomcat02 (172.17.0.5): icmp_seq=1 ttl=64 time=0.073 ms
64 bytes from tomcat02 (172.17.0.5): icmp_seq=2 ttl=64 time=0.059 ms
64 bytes from tomcat02 (172.17.0.5): icmp_seq=3 ttl=64 time=0.045 ms
## 原理
### 查看docker网络
docker network ls
docker network inspect id
### 查看容器绑定link(找link)
### --link就是在hosts假如了映射 
1、docker inspect 容器id
2、docker inspect 97ec4ba0656d|grep tomcat02 -n
3、进入容器查看 /etc/hosts
172.17.0.5	tomcat02 fd273a7550ee
```

我们现在玩Doker不建议使用--link  
现在使用自定义网络!  
docker0不支持容器名连接访问!  

#### 自定义网络

查看所有的dcoker网络

```
docker network ls
```

**网络模式**

- bridge:桥接 docker(默认，自己创建也使用bridge模式）
- none:不配置网络
- host:和宿主机共享网络
- container:容器网络连通！（用的少！局限很大）

**测试**

```
# 直接启动run 默认就是带--net bridge
docker run -d -P --name tomcat01 tomcat
docker run -d -P --name tomcat01 --net bridge tomcat

# 创建网络
## --driver bridge   #指定bridge驱动程序来管理网络
## --subnet 192.168.0.0/16 #指定网段的CIDR格式的子网
## --gateway 192.168.0.1 	#指定主子网的IPv4或IPv6网关
docker network create --driver bridge --subnet 192.168.0.0/16 --gateway 192.168.0.1 mybridge
# 查看网络
docker network ls
docker network inspect 网络id
# 启动2个容器 指定创建的网络
docker run -d -P --name tomcat-net01 --net mynet mytomcat:1.0
docker run -d -P --name tomcat-net02 --net mynet mytomcat:1.0
# 测试2个容器网络
docker network inspect 网络id
docker exec -it tomcat-net01 ping 192.168.0.3
docker exec -it tomcat-net01 ping tomcat-net02
```

可以发现，在我们的自定义网络下，容器之间既可以通过容器名也可以通过ip地址进行网络通信。 我们自定义的网络默认已经帮我们维护了容器间的网络通信问题，这是实现网络互联的推荐方式。

**好处**:
redis:不同的集群使用不同的网络,保证集群是安全和健康的
mysql:不同的集群使用不同的网络,保证集群是安全和健康的

#### 网络连通

把不同的网络打通(自定义网络与默认网络打通)

```
# 测试打通
docker network connect mybridge tomcat03
# 连通之后就是讲tomcat03放到mybridge网络下
# 一个容器两个ip地址(阿里云公网ip私网ip)
docker network inspect 5bd453665e69
# 测试
[root@MiWiFi-RA81-srv ~]# docker exec -it tomcat-net01 ping tomcat03
PING tomcat03 (192.168.0.4) 56(84) bytes of data.
64 bytes from tomcat03.mynet (192.168.0.4): icmp_seq=1 ttl=64 time=0.259 ms
64 bytes from tomcat03.mynet (192.168.0.4): icmp_seq=2 ttl=64 time=0.075 ms
```

结论:假设要跨网络操作别人,就需要使用docker network connect连通!

#### 实战:部署Redis集群

三主三从的Redis集群

```
# 创建redis网络
docker network create redis --subnet 172.38.0.0/16
# 通过shell脚本创建6个redis配置文件信息
for port in $(seq 1 6); \
do \
mkdir -p /mydata/redis/node-${port}/conf
touch /mydata/redis/node-${port}/conf/redis.conf
cat << EOF >/mydata/redis/node-${port}/conf/redis.conf
port 6379 
bind 0.0.0.0
cluster-enabled yes 
cluster-config-file nodes.conf
cluster-node-timeout 5000
cluster-announce-ip 172.38.0.1${port}
cluster-announce-port 6379
cluster-announce-bus-port 16379
appendonly yes
EOF
done
# 通过shell脚本创建并运行6级redis
for port in $(seq 1 6); \
do
docker run -p 637${port}:6379 -p 1637${port}:16379 --name redis-${port} \
-v /mydata/redis/node-${port}/data:/data \
-v /mydata/redis/node-${port}/conf/redis.conf:/etc/redis/redis.conf \
-d --net redis --ip 172.38.0.1${port} redis:5.0.9-alpine3.11 redis-server /etc/redis/redis.conf; \
done
# 进入redis01创建集群
docker exec -it redis01 /bin/sh
redis-cli --cluster create 172.38.0.11:6379 172.38.0.12:6379 172.38.0.13:6379 172.38.0.14:6379 172.38.0.15:6379 172.38.0.16:6379 --cluster-replicas 1
# 查看集群信息
redis-cli -c
cluster info
cluster nodes # 集群节点信息
```

#### 实战:SpringBoot项目打包镜像

```
# 构建SpringBoot项目
# 打包jar
# 编写dockerFile
FROM java:8
COPY *.jar /app.jar
CMD ["--server.port=8080"]
EXPOSE 8080
ENTRYPOINT ["java","-jar","/app.jar"]
# 上传到服务器(jar、dockeFile)
# 构建镜像
docker build -t demo .
# 发布运行
docker run
```