## 简介

> Java中的`synchronized`关键字是同步锁，在并发编程中比较常见。
> 
> 本文以一些测试实例演示，帮助初学者体会`synchronized`的作用。
> 
> 如果你对面向对象的编程思想不太理解，本篇文章也会帮助你理解。





## 锁普通方法

### 错误测试

- 线程类

```java
import java.util.Random;

public class MyThread implements Runnable {

    public MyThread(Integer id) {
        this.threadId = id;
    }

    private final Integer threadId;

    public synchronized void runMethod(Integer threadId) throws InterruptedException {
        long time = new Random().nextInt(10) * 200L;
        time = time == 0 ? 2000L : time;
        System.out.println("Thread：" + threadId + "----sleep----" + time);
        Thread.sleep(time);
        System.out.println("Thread：" + threadId + "----running----");
    }

    @Override
    public void run() {
        System.out.println("Thread：" + threadId + "----begin----");
        try {
            this.runMethod(threadId);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("Thread：" + threadId + "----end----");
    }
}
```

- 测试类

```java
public class SynchronizedTest {

    public static void main(String[] args) {
        for (int i = 0; i < 3; i++) {
            Thread myThread = new Thread(new MyThread(i));
            myThread.start();
        }
    }
}
```

#### 输出结果

```
Thread：0----begin----
Thread：2----begin----
Thread：1----begin----
Thread：0----sleep----1200
Thread：2----sleep----1000
Thread：1----sleep----1800
Thread：2----running----
Thread：2----end----
Thread：0----running----
Thread：0----end----
Thread：1----running----
Thread：1----end----
```

#### 现象分析

- **现象1**：多个线程同时调用``runMethod()``方法时，最先所有``begin``一起执行，然后所有``sleep``又一起执行，且都在``running``前边。

- **结论1**：``runMethod()``方法没有被锁上。``sleep``和``running``都在``runMethod()``方法内部，如果被锁了，应该前一个线程``sleep``和``running``都输出完，才能到下一个线程的``sleep``。

> 然而，结论1是错误的，我们看完正确测试一起分析这个结论为啥错误。

### 正确测试

- 线程类

```java
public class MyThread implements Runnable {
    public MyThread(Integer id) {
        this.threadId = id;
    }

    private final Integer threadId;

    private static SynchronizedTest synchronizedTest = new SynchronizedTest();

    @Override
    public void run() {
        System.out.println("Thread：" + threadId + "----begin----" + System.currentTimeMillis());
        try {
            synchronizedTest.runMethod(threadId);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("Thread：" + threadId + "----end----" + System.currentTimeMillis());
    }
 }
```

- 测试类

```java
public class SynchronizedTest {

    public static void main(String[] args) {
        for (int i = 0; i < 3; i++) {
            Thread myThread = new Thread(new MyThread(i));
            myThread.start();
        }
    }

    public synchronized void runMethod(Integer threadId) throws InterruptedException {
        long time = new Random().nextInt(10) * 200L;
        time = time == 0 ? 2000L : time;
        System.out.println("Thread：" + threadId + "----sleep----" + time);
        Thread.sleep(time);
        System.out.println("Thread：" + threadId + "----running----" + System.currentTimeMillis());
    }
}
```

#### 输出结果

```
Thread：0----begin----
Thread：2----begin----
Thread：1----begin----
Thread：0----sleep----1800
Thread：0----running----
Thread：0----end----
Thread：1----sleep----1400
Thread：1----running----
Thread：1----end----
Thread：2----sleep----2000
Thread：2----running----
Thread：2----end----
```

#### 现象分析

- **现象2**：三个``begin``最先一起执行，然后各个线程的``sleep``和``running``依次执行。

- **结论2**：``runMethod``方法被锁住了，只能被一个线程同时执行。

### 解析

- 首先我们分析一下错误测试和正确测试代码上的区别：
    1. ``runMethod()``方法位置不同，一个在线程类内部，一个在测试类（执行类）内部
    2. ``runMethod()``方法调用方式不同，一个通过直接自己的内部方法，一个创建测试类实例，通过实例调用其方法。

- 其实区别1和区别2，本质上就是一种区别：方法位置不同。而这种区别在对代码理解不深的人来说，感觉就是没有区别，我刚开始也是这样，自然而然的认为这两种写法应该是一样的。但对面向对象思想有一定理解的人来说，一眼就看出来实际的区别所在，那就是``static``关键字：

```java
private static SynchronizedTest synchronizedTest = new SynchronizedTest();
```

- 有没有``static``关键字，就是正确与错误的差别。感兴趣的你可以试一下，把正确测试代码中的``static``关键字删掉，再运行看看结果，相信你会发现它的结果和错误测试的结果是一样的。
- 如果你还不理解，那往下看看最终结论，希望你能理解。

#### 结论

- ``synchronized``作用于普通方法时，相当于给该对象实例中的该方法加锁。当多个线程同时调用该实例中的加锁方法时，才会出现加锁行为。

> 详解：注意结论中的关键词``对象实例``！拓展开来讲，只有多个线程同时调用``同一个``加锁方法时，才会体现出``锁``的行为，在错误实例中，看起来调用的是'同一个方法'，其实他都不是在同一个对象实例中。
> 
> 举个例子，你和朋友网吧五连坐，5个人玩同一个电脑，只能一人玩一会，如果5个人玩5个电脑，那就是互不干扰同时玩。如果你还没明白继续往下读。
> 
> 再回去思考下错误测试中，为什么会出现错误，我又为什么说得出的结论1也是错误的。
> - 问题1：为什么会出现错误？
> - 答案1：因为多个线程调用的不是``同一个``方法。有人可能会问为什么不是``同一个``方法？方法名明明是一样的！好，那你思考一个问题，你们网吧五连坐，玩的都是电脑，那么玩的就是同一个电脑吗？这里同理，每个线程调用的，都是它这个线程独有的那份``runMethod()``方法。在错误测试中，多个线程执行的是``同一个``方法的``多个``实例罢了。
> 
> - 问题2：``结论1``为什么是错误的？
> - 答案2：如果你理解了``问题1``的答案，那你应该能想明白``问题2``了。因为在错误测试中，每个线程调用的，都是它这个线程独有的那份``runMethod()``方法，每一份都是一个独立的个体，就比如你们网吧五连坐，总不可能只出一份钱吧。

- 注意：``static``关键字很重要，可以看我以前的一篇文章[《Java静态变量到底能不能变》](https://blog.csdn.net/hu18315778112/article/details/79143365)，我对``static``也是随着工作经验的积累才完全理解的。

## 锁静态方法

### 测试

- 线程类

```java
import java.util.Random;

public class MyThread implements Runnable {
    public MyThread(Integer id) {
        this.threadId = id;
    }

    private final Integer threadId;

    public synchronized static void runMethod(Integer threadId) throws InterruptedException {
        long time = new Random().nextInt(10) * 200L;
        time = time == 0 ? 2000L : time;
        System.out.println("Thread：" + threadId + "----sleep----" + time);
        Thread.sleep(time);
        System.out.println("Thread：" + threadId + "----running----");
    }

    @Override
    public void run() {
        System.out.println("Thread：" + threadId + "----begin----" + System.currentTimeMillis());
        try {
            runMethod(threadId);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("Thread：" + threadId + "----end----" + System.currentTimeMillis());
    }
}
```

- 测试类

```java
public class SynchronizedTest {

    public static void main(String[] args) {
        for (int i = 0; i < 3; i++) {
            Thread myThread = new Thread(new MyThread(i));
            myThread.start();
        }
    }
}
```

#### 输出结果

```
Thread：0----begin----
Thread：2----begin----
Thread：1----begin----
Thread：0----sleep----1600
Thread：0----running----
Thread：0----end----
Thread：1----sleep----400
Thread：1----running----
Thread：1----end----
Thread：2----sleep----200
Thread：2----running----
Thread：2----end----
```

### 结论

- 如果锁普通方法里的【错误测试】你看懂了，那么这种方式直接上结论就好了。其实关键就在于``static``关键字.

- 锁``static``修饰的方法，无论哪个实例对象调用该方法，都会被同步锁住，因为本质上他们调用的是同一个方法（内存中只有一份）。

## 锁代码块

- 首先我们知道锁代码块时，需要传入一个实例对象作为加锁对象，那么传入的参数就有好多种情况了，所以咱们只上正确测试。

### 正确测试1

> 锁对象实例，这种方式要给对象示例加``static``，保证多个线程调用的是同一个实例（锁的是同一个实例）。

- 线程类

```java
public class MyThread implements Runnable {
    public MyThread(Integer id) {
        this.threadId = id;
    }

    private final Integer threadId;

    private static SynchronizedTest synchronizedTest = new SynchronizedTest();

    @Override
    public void run() {
        System.out.println("Thread：" + threadId + "----begin----");
        try {
            synchronized (synchronizedTest) {
                synchronizedTest.runMethod(threadId);
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("Thread：" + threadId + "----end----");
    }
}
```

- 测试类

```java
import java.util.Random;

public class SynchronizedTest {

    public static void main(String[] args) {
        for (int i = 0; i < 3; i++) {
            Thread myThread = new Thread(new MyThread(i));
            myThread.start();
        }
    }

    public void runMethod(Integer threadId) throws InterruptedException {
        long time = new Random().nextInt(10) * 200L;
        time = time == 0 ? 2000L : time;
        System.out.println("Thread：" + threadId + "----sleep----" + time);
        Thread.sleep(time);
        System.out.println("Thread：" + threadId + "----running----");
    }
}
```

### 正确测试2

> 锁类的字节码，这种写法需要理解一下，后边写结论

- 线程类

```java
public class MyThread implements Runnable {
    public MyThread(Integer id) {
        this.threadId = id;
    }

    private final Integer threadId;

    private SynchronizedTest synchronizedTest = new SynchronizedTest();

    @Override
    public void run() {
        System.out.println("Thread：" + threadId + "----begin----");
        try {
            synchronized (SynchronizedTest.class) {
                synchronizedTest.runMethod(threadId);
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("Thread：" + threadId + "----end----");
    }
}
```

- 测试类与【正确测试1】中相同，不再冗余

#### 结论（错）

首先在本次测试中，多个线程调用的是``SynchronizedTest``类，这个应该毋容置疑，知道了这点，咱们就可以大胆的下结论：
- 锁类的字节码这种写法，是锁住了所有该类的实例。如：在本次测试中，只要有任意一个线程运行到该加锁的代码，就会锁住``SynchronizedTest``类的所有实例，只有一个实例能运行，其他实例必须等待。

### 正确测试3

> 为了验证【正确测试2】的结论，我进行了测试3，发现也是可以的。

这里就不放代码了，只改一个单词，就是加锁的那个参数：
``synchronized (SynchronizedTest.class)``改为``synchronized (MyThread.class)``

#### 结论（错）
- 锁代码块时，加锁对象可以是调用类，也可以是被调用类，道理是一样的，锁住了传入``class``的所有对象实例。

### 正确测试4

> 经过【正确测试2】和【正确测试3】，不知道你有没有对我的结论产生怀疑，有没有想试一下锁一个不相关的字节码？
这次一样不放代码，只是改动一下加锁参数：
``synchronized (MyThread.class)``改为``synchronized (Boolean.class)``
测试发现，这么写也是可以实现同步锁的，这就推翻了上边结论里的一句话：“锁住了传入``class``的所有对象实例”，因为这次我们传入的是不相关的``class``，他锁不锁实例按理说不会影响到我们的运行，为什么还是锁成功了呢？

#### 结论（个人理解）

- 加锁参数只是一个钥匙，如果你多个线程执行一段代码块，无论这段代码块是不是同一份（内存中只有一个），只要你们持有相同的钥匙，就会实现同步锁。

> 不知道你有没有理解这个结论，以上边的【正确测试4】举例说明：
> - 当传入一个``Boolean.class``时，其实是把``Boolean.class``的字节码对象当做钥匙，而``Boolean.class``在内存中只会有一个字节码对象实例，所以当任意一个线程执行到这个加锁代码块时，就会锁住``Boolean.class``的字节码对象，其他线程必须等待``Boolean.class``的字节码对象释放后，再次竞争，然后再锁住。

> ps：``synchronized (Boolean.class)``中，你可以把``Boolean.class``认为是钥匙，也可以认为是锁，只要你理解的对就好了。

## 感悟
1. 不要急于下结论，多验证多实践，尤其是对于一个新技术。
2. 个人认为：尽量少用``synchronized (Boolean.class)``这种锁字节码的形式，因为我认为，如果多个不同的地方这样加锁，万一传入的是同一个参数，如``Boolean.class``，那么可能这些不同的地方会产生同步锁的效果，当然这只是我的个人猜测，具体效果需要再做测试验证。
3. 然后就是我有个疑问是，``synchronized (Boolean.class)``这种锁字节码的方式是否会消耗更多资源？有知道的大佬可以解答一下。

synchronized关键字使用

## 简介

- `本文是从我的CSDN迁移过来，不是抄袭哦！`[CSDN原文](https://blog.csdn.net/hu18315778112/article/details/124099865)
- 注意：本文是建立在Nacos安装成功的基础上讲解。建议安装Nacos后，对照系统页面学习此文章。
- 1、本文采取``Nacos 2.0.3``单例形式、服务单例形式来讲解，不涉及集群相关特定知识点。
- 2、本文分为三部分来讲解Nacos的基本使用：
	- 一、Nacos页面；
	- 二、Nacos作为注册中心使用；
	- 三、Nacos作为配置中心使用。
- 3、如有错误，请务必指出，感谢！

<div class="article-ads"></div>



## 一、Nacos页面
- 主要讲解Nacos的一些通用性配置，如用户、角色配置等。
### 命名空间（namespace）
- 【重要】：Nacos所有配置的最顶层分组，项目中需要用到该字段值。
- 默认的``namespace``是``public``。
![在这里插入图片描述](https://images.oldmoon.top/images/dingdangdog/dingdangdog-1683250768948.png)
- 命名空间ID：可以不填，会自动生成一个不规则值，也可以自定义，不能重复。
- 命名空间名：自定义一个名称，帮助识别分组。
- 描述：字面意思
#### 新增后检查
![在这里插入图片描述](https://images.oldmoon.top/images/dingdangdog/dingdangdog-1683250817930.png)

- 命名空间新增后，随便点点页面，你会在很多地方可以找到该分组，如上图【配置管理】--【配置列表】中。
### Nacos用户相关配置
#### 创建用户
![在这里插入图片描述](https://images.oldmoon.top/images/dingdangdog/dingdangdog-1683250855779.png)

- 上图为Nacos系统页面，启动Nacos成功后，访问Nacos页面，默认的登录用户账号密码都是``nacos``。
- 进入页面后，找到【权限控制】--【用户列表】，在该页面可以创建用户，只需要输入账号和密码即可创建。
#### 创建角色
![在这里插入图片描述](https://images.oldmoon.top/images/dingdangdog/dingdangdog-1683250881475.png)
- 如图进入【权限控制】–【角色管理】，点击绑定角色弹出图中窗口，可以自定义一个新的角色名，也可以填已经存在的角色名，用户名必须是已存在的用户。
- 注意：之所以说``可以自定义一个新的角色名，也可以填已经存在的角色名``的，因为这里即可以视为角色和用户的关系维护，也可以视为新增角色。
- 一般我们对角色、用户的理解可能是：先有用户和角色，再给用户指定相应的角色。但是在这里不太一样，可以理解为角色创建时，即绑定了用户：必须先有用户，创建角色时，必须指定一个已存在的用户。
#### 权限管理
![在这里插入图片描述](https://images.oldmoon.top/images/dingdangdog/dingdangdog-1683250892260.png)
- 如图进入【权限控制】–【权限管理】，即角色权限的维护页面。
- 角色名：已存在的一个角色名
- 资源：命名空间（namespace）
- 动作：只读、只写、读写

<div class="article-ads"></div>

## 二、Nacos作为注册中心使用

### 创建项目
1. 创建一个普通的SpringCloud项目，引入如下Nacos的maven依赖：
```xml
        <dependency>
            <groupId>com.alibaba.cloud</groupId>
            <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
        </dependency>
```
2. 项目中创建``bootstrap.yml``配置文件，添加如下Yml配置：
```yml
spring:
  cloud:
    nacos:
      # 【注册中心】相关配置
      discovery:
        # 命名空间（大分组）
        namespace: cjbgd_nacos
        # 分组名称，默认为【DEFAULT_GROUP】
        group: CJBGD_DEV
        # 注册中心地址
        server-addr: localhost:8848
```
3. 启动类上增加注解：``@EnableDiscoveryClient``
### 启动项目
- 项目启动成功后，可以到Nacos页面中看到如下图的结果
![在这里插入图片描述](https://images.oldmoon.top/images/dingdangdog/dingdangdog-1683250909346.png)

<div class="article-ads"></div>

## 三、Nacos作为配置中心使用

> - nacos作为配置中心，主要分两部分：1、配置管理；2、配置引用。
> - 配置管理：使用Nacos页面管理配置文件。
> - 配置引用：在项目中引用想要的配置。
### 配置管理
#### 新增配置文件
- Nacos作为配置中心，必须先在Nacos管理页面新增一些配置。
1. 在【配置管理】--【配置列表】页面中，点击右侧加号，进入配置新增页面 
![在这里插入图片描述](https://images.oldmoon.top/images/dingdangdog/dingdangdog-1683250934187.png)
![在这里插入图片描述](https://images.oldmoon.top/images/dingdangdog/dingdangdog-1683250945425.png)
2. 在新增页面中填写相应信息。
	- Data ID：配置文件名。【如果在引用时，想要某个项目缺省式的引用到该配置文件，``Data ID``应该与服务的``spring.application.name``保持一致】
	- Group：配置分组，默认为``DEFAULT_GROUP``
	- 描述：描述
	- 配置格式：按需选择，现在一般都用``yaml``，即``yml``
	- 配置内容：配置内容
3. 填写示例
![在这里插入图片描述](https://images.oldmoon.top/images/dingdangdog/dingdangdog-1683250956141.png)
##### 注意
- Nacos配置新增保存成功后，新增页面不会自动关闭，只会弹出成功提示框。即这个新增页面不会主动关闭，而且不会清空已填写的内容，会一直开着，直到你手动返回。
- 如果你以为你新增失败了，再次点击保存，会弹出已存在同名配置的错误提示。
- 且新增页面只能用来新增配置，新增后想要修改必须返回列表，点击对应配置后边的【编辑】按钮。
- 这是个使用习惯的问题，对我来说刚使用的时候不是很友好，用多了也就无所谓了。

#### 配置导出
- 在微服务时代，微服务越多吗，配置文件也就越多，在开发环境、正式环境中，总不能每次改动都是都在Nacos的编辑页面修改配置吧，所以配置导入导出就很有必要。
![在这里插入图片描述](https://images.oldmoon.top/images/dingdangdog/dingdangdog-1683250969238.png)
- 如上图，主要就是两种选择：
	- 导出查询结果：根据查询条件，把查出的所有配置一起导出。
	- 导出选中的配置：导出选中的配置。
- 至于有个【新版】，我猜测是分页数据导出的优化？由于我的配置文件较少，没有做测试，有想法的可以试试。
- 导出的是一个zip压缩包，打开可以看到导出文件如下图：
![在这里插入图片描述](https://images.oldmoon.top/images/dingdangdog/dingdangdog-1683250978540.png)
![在这里插入图片描述](https://images.oldmoon.top/images/dingdangdog/dingdangdog-1683250987710.png)

#### 配置导入
- 细心地同学看导出文件时候，会发现没有导出命名空间（namespace）的信息，这也意味着，导出的配置可以导入到任意的命名空间中，导入前点到想要导入的命名空间即可。
- 如下图，先进入``cjbgd_nacos``的命名空间中，再点击【``导入配置``】，弹出的窗口会自动显示导入的空间信息，且不能更改。
- 上传的文件，直接选中导出的压缩包即可。
![在这里插入图片描述](https://images.oldmoon.top/images/dingdangdog/dingdangdog-1683250998273.png)
### 配置引用
#### 引用配置
- 项目中想用配置中心，还要写相应配置，告诉项目我要用哪个配置中心、哪个配置文件。【没有希洛克打啥希洛克！？没有奥兹玛打啥奥兹玛！？突然感觉有点道理。。。】
- 配置示例：
```yml
spring:
  cloud:
    nacos:
      # 【配置中心】相关配置
      config:
        # 命名空间（大分组）
        namespace: cjbgd_nacos
        # 配置中心地址
        server-addr: 127.0.0.1:8848
        # 配置文件的data-id，默认使用服务名（spring.application.name）
        #name: gateway.yaml
        # 配置文件类型：test/json/xml/yaml/properties
        file-extension: yaml
        # 分组名称，默认为【DEFAULT_GROUP】
        group: CJBGD_PRO
        # 自动刷新配置，默认为true
        refresh-enabled: true
        # 共享配置引用
        shared-configs:
          # 配置ID
          - data-id: shared-datasource-dbcp2-pro.yaml
            # 配置组名称，默认为【DEFAULT_GROUP】
            group: SHARED_PRO
            refresh: true
          - data-id: shared-redis-pro.yaml
            group: SHARED_PRO
            refresh: true
          - data-id: shared-info-pro.yaml
            group: SHARED_PRO
            refresh: true
```
- 上边我把我用到的所有配置全部贴出来了，注释也都写的很明白，不做太细的讲解，只说几个个人理解：
1. ``config.name``：应该填写配置中心中对应配置的``data-id``，可以缺省，缺省时默认使用本服务的``spring.application.name``的值。
2. ``config.file-extension``：配置文件拓展名，会自动和``config.name``组合，用``.``拼接为一个``data-id``到配置中心查找配置。
3. ``config.shared-configs``：声明引用哪些公共的配置。下边可以显式引用多个配置中心的配置文件。
4. ``group``：默认值为``DEFAULT_GROUP``，当配置文件较多时，建议自定义一些``group``，对配置文件进行分组管理，使用起来也更加清晰明了。
#### 项目启动日志
```shell
2022-04-12 11:54:14.224  INFO 65808 --- [           main] c.a.n.client.config.impl.ClientWorker    : [fixed-localhost_8848-cjbgd_nacos] [subscribe] gateway+CJBGD_DEV+cjbgd_nacos
2022-04-12 11:54:14.224  INFO 65808 --- [           main] c.a.nacos.client.config.impl.CacheData   : [fixed-localhost_8848-cjbgd_nacos] [add-listener] ok, tenant=cjbgd_nacos, dataId=gateway, group=CJBGD_DEV, cnt=1
2022-04-12 11:54:14.225  INFO 65808 --- [           main] c.a.n.client.config.impl.ClientWorker    : [fixed-localhost_8848-cjbgd_nacos] [subscribe] gateway.yaml+CJBGD_DEV+cjbgd_nacos
2022-04-12 11:54:14.225  INFO 65808 --- [           main] c.a.nacos.client.config.impl.CacheData   : [fixed-localhost_8848-cjbgd_nacos] [add-listener] ok, tenant=cjbgd_nacos, dataId=gateway.yaml, group=CJBGD_DEV, cnt=1
2022-04-12 11:54:14.225  INFO 65808 --- [           main] c.a.n.client.config.impl.ClientWorker    : [fixed-localhost_8848-cjbgd_nacos] [subscribe] gateway-dev.yaml+CJBGD_DEV+cjbgd_nacos
2022-04-12 11:54:14.225  INFO 65808 --- [           main] c.a.nacos.client.config.impl.CacheData   : [fixed-localhost_8848-cjbgd_nacos] [add-listener] ok, tenant=cjbgd_nacos, dataId=gateway-dev.yaml, group=CJBGD_DEV, cnt=1
```
- debug模式启动项目，观察启动日志会发现上面的日志，可以看到他在从配置中心加载哪些配置。
- 但是没有发现``shared-configs``引用的相关日志，可能开发者任务缺省的形式才有必要打印日志，而``shared-configs``都是显式的将各种信息填写到配置文件中了，所以没必要打印日志。

<div class="article-ads"></div>

Nacos基本使用：注册中心、配置中心

## 简介

> Java程序运行经常有中文乱码，尤其是自己定义的普通Main方法，此时需要配置Java编译的编码。
> 
> 现在一般通用编码是`UTF8`，所以可以设置环境变量：`JAVA_TOOL_OPTIONS`，值为`-Dfile.encoding=UTF-8`。




## 配置Java环境变量

- 普通Java运行Main方法，编译运行都是Java原生的，理所当然需要配置JDK默认编译运行的字符集，这种情况建议通过配置环境变量来设置字符集，如下图`Windows`系统配置配置环境变量（配置成功后建议重启软件或电脑，否则可能不生效）

![jdk编码utf8](https://images.oldmoon.top/images/dingdangdog/dingdangdog-1673856754.jpg)

配置成功后，在Idea中运行普通Main方法，会出现如图所示提示

![成功提示](https://images.oldmoon.top/images/dingdangdog/dingdangdog-1673856814.jpg)

Java编译运行字符集设置UTF8

## 简介

> 有时觉得录制视频很麻烦，所以想要简单的录制gif即可，但是如果用其他工具把视频转成gif有觉得太麻烦。
> 
> 这里推荐一个小巧的Gif录制工具（Windows系统使用）：[GifCam](https://blog.bahraniapps.com/gifcam)
> 
> 该工具是个人开发着开发的，工具完全免费无广告，下载即用，无需安装。如果你下载的不是这样，可能是被某个为谋私利的人夹带私货了。




## 官方下载

点击即可下载：[GifCam-7.0](https://www.bahraniapps.com/apps/gifcam/gifcam.php)

或者到自己去寻找下载地址：[GifCam-download](https://blog.bahraniapps.com/gifcam/#download)


## 使用方法

下载后解压即用。运行后GifCam窗口会始终置于窗口最顶层。
具体操作主要分3步：选择录制区、开始录制、保存录制。

- 选择录制区

GifCam运行后，会有一个录制区，录制区看起来是透明的，可以通过放大、缩小、调整GifCam的整个窗口来调整录制区的位置和大小，也可以点击`Rec`下拉选中的`Draw selection`，通过拖拽鼠标的防止来选中录制区。


- 开始录制

选好录制区后，点击`Rec`按钮即可开始录制，并且`Rec`按钮会变成`Stop`按钮。

> PS：小技巧，录制过程中通过`Stop`按钮暂停录制，点击`Frame`录制单个帧（可以提交为截图），再点击`Rec`继续录制，可以实现在录制内容中插入单帧的操作。

- 保存录制

当录制完毕后，点击`Stop`按钮，然后点击`Save`按钮即可保存。

保存前可以通过`Save`按钮旁边的下拉选，修改一些保存结果的设置，比如设置颜色黑白等等，对这方面不是很了解，有兴趣的可自行测试。


## 常见问题

### 录制时间

GifCam录制内容无固定时间限制，且暂未提供时间设置。GifCam目前采用内存存储录制内容的方式，会根据录制内容（像素大小）和时间长短，来决定其占用的内存大小，如果其录制内容占用的内存超过了你的可用内存，GifCam就会自动停止录制。

根据官方博客上的讨论，作者再考虑可使用硬盘来保存录制内容，以此来增加可录制时间，后续可以关注官方是否实现该功能。

### 内存变化

![内存变化](https://images.oldmoon.top/images/dingdangdog/dingdangdog-1673500500.gif)

Gif录制工具GifCam

## 简介

`Docker Compose` 的作用是简化和管理一个或多个 `Docker` 容器的应用程序的开发、部署和管理过程。它可以让开发者通过一个简单的配置文件来定义整个应用程序的环境，包括服务之间的依赖关系、容器的配置选项以及网络设置等，然后使用一条命令就可以轻松地启动、停止、重新启动或销毁整个应用程序。

> PS：想要更简单的使用docker，docker-compose是一个最基础的工具。

官方文档：[Docker Compose overview](https://docs.docker.com/compose/)



## 安装

### 官方推荐安装方式

官方文档：[Install the Compose](https://docs.docker.com/compose/install/other/)

运行下方命令一键安装：
```sh
# 注意版本号，可以前往官方文档查看最新版本。
curl -SL https://github.com/docker/compose/releases/download/v2.17.0/docker-compose-linux-x86_64 -o /usr/local/bin/docker-compose
```

安装完成后，如果使用 `docker-compose` 报错：`-bash: /usr/local/bin/docker-compose: Permission denied`，则需要给`docker-compose`授权：

```sh
chmod +x /usr/local/bin/docker-compose
```

### pip（推荐）

```shell
sudo pip install docker-compose
```

### curl

- 直接从github下载

```shell
sudo curl -L https://github.com/docker/compose/releases/download/1.16.1/docker-compose-`uname -s`-`uname -m` -o /usr/local/bin/docker-compose
```

- daocloud下载

```shell
sudo curl -L https://get.daocloud.io/docker/compose/releases/download/1.25.1/docker-compose-`uname -s`-`uname -m` -o /usr/local/bin/docker-compose
```

- 下载后授权

```shell
sudo chmod +x /usr/local/bin/docker-compose
```

## 使用

### 基础理解

`docker-compose` 的最基础原理，可以认为是将 `docker run` 命令的相关参数持久化，当运行 `docker-compose` 指令时，会自动根据持久化的配置内容生成并运行 `docker run` 命令。

PS：多个容器编排为高级用法。

### 配置文件

使用 `docker-compose` 指令前，需要编写相应的 `yaml` 配置文件。可以命名为 `docker-compose.yaml` 或 `docker-compose.yml`。下面是一个简单的内容示例：

```yaml
version: '3'

services:
  web:
    image: nginx:latest
    ports:
      - "80:80"
  db:
    image: mysql:latest
    environment:
      MYSQL_ROOT_PASSWORD: example
```

### 相关操作

**重点：`docker-compose` 指令执行时，请保证处在待执行配置文件目录中。**

- 运行

```bash
# 前台运行，首次运行将会自动下载相应镜像资源
docker-compose up

# 后台运行
# docker-compose up -d
```

- 停止

```bash
docker-compose stop
```

- 重启

```bash
docker-compose restart
```

- 删除容器

```bash
# 停止相应容器并自动删除
docker-compose down
```

- 删除镜像

镜像需要手动删除，就是 `Dokcer` 基础操作，没有新方式。

### 配置详解

```yaml
version: '3.8'  # 使用的 Docker Compose 版本号

services:  # 定义服务

  # Web 应用服务
  web:
    image: nginx:latest  # 使用的 Docker 镜像
    ports:  # 端口映射
      - "80:80"  # 将容器的 80 端口映射到宿主机的 80 端口
    volumes:  # 挂载卷
      - ./web:/usr/share/nginx/html  # 将宿主机的 ./web 目录挂载到容器的 /usr/share/nginx/html 目录，用于存放静态文件
    networks:  # 定义网络
      - app-network  # 与名为 app-network 的网络进行连接

  # 数据库服务
  db:
    image: mysql:latest  # 使用的 Docker 镜像
    environment:  # 环境变量
      MYSQL_ROOT_PASSWORD: example  # 设置 MySQL 的 root 密码为 example
    volumes:  # 挂载卷
      - mysql-data:/var/lib/mysql  # 将 mysql-data 卷挂载到容器的 /var/lib/mysql 目录，用于持久化存储数据库数据
    networks:  # 定义网络
      - app-network  # 与名为 app-network 的网络进行连接
    depends_on:  # 依赖关系
      - db  # web 服务依赖于 db 服务

volumes:  # 定义卷
  mysql-data:  # 定义名为 mysql-data 的卷，用于持久化存储数据库数据

networks:  # 定义网络
  app-network:  # 定义名为 app-network 的网络

```

## 赞助请求V3

**建站因为热爱，生活需要Money，请屏幕前的大佬动动您发财的小手，点击一次以示鼓励，祝您生活愉快！**


<div class="article-ads"></div>

> PS：就目前的访问量，即便每个访客都点一次广告，收入也不足以支付运营成本。`如果看不到广告，可能是网络原因或被拦截了，那就算了吧。再次祝您生活愉快~~`

docker-compose安装与使用

twitter:card

twitter:title

twitter:site

twitter:image

努力做一只帅气、有才、豁达的老狗！

twitter:description

程序员,笔记,Bug记录,编程技术,AI,Java,Node,Golang,个人博客,资源分享,月上老狗,dingdangdog