## 开门大吉

> 2023年1月22日，今天是中国农历癸卯年的新年第一天。
> 
> 在这里祝贺大家新年快乐！愿所有人在新的一年里：
> - 事业如新竹，气运似桃花
> - 家和诸事顺，亲友福满堂



## 生肖

中国十二生肖：鼠、牛、虎、兔、龙、蛇、马、羊、猴、鸡、狗、猪

对应十二时辰：子、丑、寅、某、辰、巳、午、未、申、酉、午、亥

2023年的生肖是兔。

## 癸卯年

> 来自[维基百科](https://zh.m.wikipedia.org/zh-hans/%E7%99%B8%E5%8D%AF)，如有错误，欢迎指正！

中国传统纪年的干支纪年中一个循环的第40年称“癸卯年”。以下各个公元年份，年份数除以60余43，或年份数减3，除以10的馀数是0，除以12的余数是4，农历自正月初一至除夕，干支历自当年立春起至次年立春（不含）止的岁次内，均为“癸卯年”：

|第1个千年|第2个千年|第3个千年|
|--|--|--|
|43年|1003年|2023年|
|103年|1063年|2083年|
|163年|1123年|2143年|
|223年|1183年|2203年|
|283年|1243年|2263年|
|343年|1303年|2323年|
|403年|1363年|2383年|
|463年|1423年|2443年|
|523年|1483年|2503年|
|583年|1543年|2563年|
|643年|1603年|2623年|
|703年|1663年|2683年|
|763年|1723年|2743年|
|823年|1783年|2803年|
|883年|1843年|2863年|
|943年|1903年|2923年|
||1963年|2983年|

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

2023年1月22日癸卯年新年快乐

## 简介

> Nginx作为时下最流行的代理服务器，对于开发者而言，其安装和使用是比不可少的技能。
> 
> 本文主要介绍`Ubuntu`和`Centos`两种`Linux`系统安装Nginx的方法。



## Ubuntu

相对与Ubuntu系统来说，我更习惯使用Centos系统，但两种都会也没啥坏处。


### 一键安装

Ubuntu提供很多软件的一键安装工具：apt。

Ubuntu运行如下命令一键安装Nginx：

```sh
sudo apt install nginx
```

安装完成后，可运行如下命令检查Nginx服务状态：

```sh
sudo systemctl status nginx
```

如输出如下相似信息，说明安装成功了，但未启动：

```sh
● nginx.service - A high performance web server and a reverse proxy server
     Loaded: loaded (/lib/systemd/system/nginx.service; enabled; vendor preset: enabled)
     Active: active (running) since Sat 2020-05-02 20:25:43 UTC; 13s ago
...
```

### 自定义配置运行nginx

由于该nginx是一键安装的，所以很多文件安装的较为散乱，而且我没找到他默认的配置文件在哪。。。想修改都找不到地方，所以我就想：还是自己找到可执行文件，然后自己指定配置文件启动吧。

可以运行如下命令大致了解全局的叫nginx的文件或文件夹：

```sh
sudo find -name nginx
```

如果你没有自己创建nginx文件夹的话，可能会输出如下信息：

```
./etc/nginx
./etc/logrotate.d/nginx
./etc/default/nginx
./etc/ufw/applications.d/nginx
./etc/init.d/nginx
./var/lib/nginx
./var/log/nginx
./usr/lib/nginx
./usr/sbin/nginx
./usr/share/doc/nginx
./usr/share/nginx
```

**此时，根据经验，大概可以猜到nginx的可执行文件是`/usr/sbin/nginx`，因为其在`sbin`文件夹下！**

知道可执行文件位置，就可以自己启停服务了，运行如下命令，指定使用我自定义的配置文件启动：

```sh
sudo /usr/sbin/nginx -c /usr/local/nginx/nginx.conf
```

其中`-c`为固定参数，不可修改。`/usr/local/nginx/nginx.conf`是我自定义配置文件的绝对路径，按需修改。


## Centos

Centos系统没有提供Nginx的一件安装工具，所以需要手动安装，在安装Nginx前，需要先安装一些Nginx所需的依赖、环境。

### 安装依赖

- 安装gcc-c++编译工具和openssl环境

```sh
yum install gcc-c++
yum install -y openssl openssl-devel
```

- 安装pcre工具

```sh
yum install -y pcre pcre-devel
```

- 安装zlib工具

```sh
yum install -y zlib zlib-devel
```

### 安装nginx

- 一般建议创建如下nginx文件夹

```sh
mkdir /usr/local/nginx
cd /usr/local/nginx
```

- 下载nginx

> 其中`1.19.9`为版本号，可自行更改，具体版本号自行去官网查看即可：[Nginx下载](http://nginx.org/en/download.html)。

```sh
wget https://nginx.org/download/nginx-1.19.9.tar.gz
```

- 解压文件（解压后自动生成`nginx-1.19.9`文件夹并进入）

```sh
tar -zxvf nginx-1.19.9.tar.gz
cd nginx-1.19.9
```

- 初始化配置（执行`nginx-1.19.9`文件夹下的`configure`可执行文件）

```sh
./configure
```

- 编译

```sh
make && make install
```

### 运行

- 说明

> 使用本文的Centos安装方式，安装完成后，会在安装目录生成一些文件和文件夹，本文的安装目录前面创建的`/usr/local/nginx`。
> 
> 其中需要重点关注的是`sbin`、`conf`、`html`三个文件夹，作用分别如下：
> - sbin：nginx的可执行文件存放的文件夹
> - conf：nginx默认配置文件存放的文件夹
> - html：nginx默认的静态页面存放的文件夹

- 回到安装目录，运行nginx

```sh
cd /usr/local/nginx
sbin/nginx
```

Linux安装Nginx

## 简介
> ubuntu系统权限与centos系统权限不太一样。
> 
> ubuntu系统没有root用户，但某些命令没有root权限又无法执行，如删除、新增文件或文件夹时，要想获得root权限需要在命令前增加`sudo`命令符。
> 
> ubuntu系统文件夹上传文件一样有限制，需要增加文件夹的权限才能上传。

Ubuntu增加文件夹权限：

```sh
sudo chmod 777 /usr/local/nginx
```



## 介绍： 

可以使用命令chmod来为文件或目录赋予权限。Linux/Unix 的文件存取权限分为三级 : 文件拥有者、群组、其他。利用 chmod 可以藉以控制文件如何被他人所存取 

## 详解 

此命令有两种使用方法，一种是chmod后加数字，后接文件名 

```sh
sudo chmod abc file 
```

其中 `a,b,c` 各为一个数字，分别表示`User`、`Group`、及`Other`的权限。

每一个权限又分为读、写、执行三种，对应的数字分别是：

- 读-r：4
- 写-w：2
- 执行-x：1 

主要使用场景：

- 需要读、写、执行（`rwx`）权限：4+2+1=7
- 需要读、写（`rw-`）权限：4+2=6
- 需要读、执行（`r-x`）权限：4+1=5

一般为了省事，可以直接赋予全部权限，即`777`，如：

```sh
sudo chmod 777 /usr/local/nginx
```

但要注意，这在 Linux 系统当中是一种不安全的、不负责任的操作！

## 拓展示例

- 关于文件拥有者修改的操作，可以参考：【[ubuntu文件拥有者/权限变更](https://oldmoon.top/post/175)】

### 赋予所有用户所有权限

```sh
sudo chmod a=rwx file 
```
和 
```sh
sudo chmod 777 file 
```
效果相同 

### 赋予用户、分区权限全部权限，其他用户只有执行权限

```sh
chmod ug=rwx,o=x file 
```
和 
```sh
chmod 771 file 
```
效果相同 

### 赋予root权限

若用`chmod 4755 filename`可使此程序具有root的权限

Ubuntu设置文件夹权限

SimpleDateFormat部分源码阅读

## 简介

> 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关键字使用

twitter:card

twitter:title

https://images.oldmoon.top/images/dingdangdog/oldmoon.png

twitter:image

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

twitter:description

开门大吉

简介

简介

简介

有趣发现

简介