Runnable 线程创建

1

1
2
3
4
5
6
7
8
9
10
11
12
13
14

public class Main {
    public static void main(String[] args) {
       MyRunnable myRunnable = new MyRunnable()
       Thread thread = new Thread(myRunnable);
       thread.start(); // 启动新线程
    }
}

class MyRunnable implements Runnable {
    @Override
    public void run() {
       System.out.println("start new thread!");
    }
}

2

1
2
3
4
5
6
7
8
9
10
11
12
13

public class Main {
    public static void main(String[] args) {
       MyRunnable myRunnable = new MyRunnable()
       new Thread(myRunnable).start(); // 启动新线程
    }
}

class MyRunnable implements Runnable {
    @Override
    public void run() {
       System.out.println("start new thread!");
    }
}

3

1
2
3
4

Thread t = new Thread(() -> {
    System.out.println("start new thread!");
});
t.start(); // 启动新线程

4

1
2
3

new Thread(()-> {
   System.out.println("start new thread!");
}).start();

Note

要想给每个实例不一样的参数：用构造函数

Thread 创建线程

1
2
3
4
5
6
7
8
9
10
11
12
13

public class Main {
   public static void main(String[] args) {
      Thread t = new MyThread();
      t.start(); // 启动新线程
   }
}

class MyThread extends Thread {
   @Override
   public void run() {
      System.out.println("start new thread!");
   }
}

Maven 介绍

在了解 Maven 之前，我们先来看看一个 Java 项目需要的东西。首先，我们需要确定引入哪些依赖包。例如，如果我们需要用到 commons logging，我们就必须把 commons logging 的 jar 包放入 classpath。如果我们还需要 log4j，就需要把 log4j 相关的 jar 包都放到 classpath 中。这些就是依赖包的管理。
其次，我们要确定项目的目录结构。例如，src 目录存放 Java源码，resources 目录存放 配置文件，bin 目录存放编译生成的 .class 文件。
此外，我们还需要配置环境，例如 JDK 的版本，编译打包的流程，当前代码的版本号。
最后，除了使用 Eclipse 这样的 IDE 进行编译外，我们还必须能通过命令行工具进行编译，才能够让项目在一个独立的服务器上编译、测试、部署。
这些工作难度不大，但是非常琐碎且耗时。如果每一个项目都自己搞一套配置，肯定会一团糟。我们需要的是一个标准化的 Java 项目管理和构建工具。

Maven 就是是专门为 Java 项目打造的管理和构建工具，它的主要功能有：

• 提供了一套标准化的项目结构；
• 提供了一套标准化的构建流程（编译，测试，打包，发布……）；
• 提供了一套依赖管理机制。

Maven 项目结构

一个使用Maven管理的普通的Java项目，它的目录结构默认如下：

1
2
3
4
5
6
7
8
9
10

a-maven-project
├── pom.xml
├── src
│   ├── main
│   │   ├── java
│   │   └── resources
│   └── test
│       ├── java
│       └── resources
└── target

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

<project ...>
   <modelVersion>4.0.0</modelVersion>
   <groupId>com.itranswarp.learnjava</groupId>
   <artifactId>hello</artifactId>
   <version>1.0</version>
   <packaging>jar</packaging>
   <properties>
      ...
   </properties>
   <dependencies>
      <dependency>
            <groupId>commons-logging</groupId>
            <artifactId>commons-logging</artifactId>
            <version>1.2</version>
      </dependency>
   </dependencies>
</project>

1
2
3
4
5

<dependency>
   <groupId>commons-logging</groupId>
   <artifactId>commons-logging</artifactId>
   <version>1.2</version>
</dependency>

安装Maven

要安装Maven，可以从Maven官网下载最新的Maven 3.6.x，然后在本地解压，设置几个环境变量：

1
2

M2_HOME=/path/to/maven-3.6.x
PATH=$PATH:$M2_HOME/bin

1
2
3
4
5

Apache Maven 3.6.3 (cecedd343002696d0abb50b32b541b8a6ba2883f)
Maven home: D:\maven\bin\..
Java version: 1.8.0_271, vendor: Oracle Corporation, runtime: D:\Program Files\Java\jdk1.8.0_271\jre
Default locale: zh_CN, platform encoding: GBK
os name: "windows 10", version: "10.0", arch: "amd64", family: "windows"

小结

Maven是一个Java项目的管理和构建工具：

• Maven使用pom.xml定义项目内容，并使用预设的目录结构；
• 在Maven中声明一个依赖项可以自动下载并导入classpath；
• Maven使用groupId，artifactId和version唯一定位一个依赖。

依赖管理

如果我们的项目依赖第三方的jar包，例如commons logging，那么问题来了：commons logging发布的jar包在哪下载？
如果我们还希望依赖log4j，那么使用log4j需要哪些jar包？
类似的依赖还包括：JUnit，JavaMail，MySQL驱动等等，一个可行的方法是通过搜索引擎搜索到项目的官网，然后手动下载zip包，解压，放入classpath。但是，这个过程非常繁琐。
Maven解决了依赖管理问题。例如，我们的项目依赖abc这个jar包，而abc又依赖xyz这个jar包：

1
2
3
4
5
6
7
8
9
10
11
12
13

┌──────────────┐
│Sample Project│
└──────────────┘
       │  
       ▼
┌──────────────┐
│     abc      │
└──────────────┘
       │
       ▼
┌──────────────┐
│     xyz      │
└──────────────┘

我们来看一个复杂依赖示例：

1
2
3
4
5

<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-web</artifactId>
   <version>1.4.2.RELEASE</version>
</dependency>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

spring-boot-starter-web
spring-boot-starter
   spring-boot
   sprint-boot-autoconfigure
   spring-boot-starter-logging
      logback-classic
      logback-core
      slf4j-api
      jcl-over-slf4j
      slf4j-api
      jul-to-slf4j
      slf4j-api
      log4j-over-slf4j
      slf4j-api
   spring-core
   snakeyaml
spring-boot-starter-tomcat
   tomcat-embed-core
   tomcat-embed-el
   tomcat-embed-websocket
      tomcat-embed-core
jackson-databind
...

依赖关系

Maven定义了几种依赖关系，分别是 compile、test、runtime 和 provided：

其中，默认的 compile 是最常用的，Maven 会把这种类型的依赖直接放入 classpath。
test 依赖表示仅在测试时使用，正常运行时并不需要。最常用的 test 依赖就是 JUnit：

1
2
3
4
5
6

<dependency>
   <groupId>org.junit.jupiter</groupId>
   <artifactId>junit-jupiter-api</artifactId>
   <version>5.3.2</version>
   <scope>test</scope>
</dependency>

1
2
3
4
5
6

<dependency>
   <groupId>mysql</groupId>
   <artifactId>mysql-connector-java</artifactId>
   <version>5.1.48</version>
   <scope>runtime</scope>
</dependency>

1
2
3
4
5
6

<dependency>
   <groupId>javax.servlet</groupId>
   <artifactId>javax.servlet-api</artifactId>
   <version>4.0.0</version>
   <scope>provided</scope>
</dependency>

唯一ID

对于某个依赖，Maven只需要3个变量即可唯一确定某个jar包：

• groupId：属于组织的名称，类似Java的包名；
• artifactId：该jar包自身的名称，类似Java的类名；
• version：该jar包的版本。

通过上述3个变量，即可唯一确定某个jar包。Maven通过对jar包进行PGP签名确保任何一个jar包一经发布就无法修改。修改已发布jar包的唯一方法是发布一个新版本。
因此，某个jar包一旦被Maven下载过，即可永久地安全缓存在本地。

注：只有以 -SNAPSHOT 结尾的版本号会被 Maven 视为开发版本，开发版本每次都会重复下载，这种 SNAPSHOT 版本只能用于内部私有的 Maven repo，公开发布的版本不允许出现 SNAPSHOT。

Maven镜像

除了可以从Maven的中央仓库下载外，还可以从Maven的镜像仓库下载。如果访问Maven的中央仓库非常慢，我们可以选择一个速度较快的Maven的镜像仓库。Maven镜像仓库定期从中央仓库同步：

1
2
3
4
5
6
7
8
9

          slow    ┌───────────────────┐
   ┌─────────────>│Maven Central Repo.│
   │              └───────────────────┘
   │                        │
   │                        │sync
   │                        ▼
┌───────┐  fast    ┌───────────────────┐
│ User  │─────────>│Maven Mirror Repo. │
└───────┘          └───────────────────┘

1
2
3
4
5
6
7
8
9
10
11

<settings>
   <mirrors>
      <mirror>
            <id>aliyun</id>
            <name>aliyun</name>
            <mirrorOf>central</mirrorOf>
            <!-- 国内推荐阿里云的Maven镜像 -->
            <url>https://maven.aliyun.com/repository/public</url>
      </mirror>
   </mirrors>
</settings>

搜索第三方组件

最后一个问题：如果我们要引用一个第三方组件，比如 okhttp，如何确切地获得它的 groupId、artifactId 和 version？方法是通过 search.maven.org 搜索关键字，找到对应的组件后，直接复制。

命令行编译

在命令中，进入到pom.xml所在目录，输入以下命令：

1

mvn clean packages

小结

• Maven 通过解析依赖关系确定项目所需的 jar 包，常用的 4 种 scope 有：compile（默认），test，runtime 和 provided；
• Maven 从中央仓库下载所需的 jar 包并缓存在本地；
• 可以通过镜像仓库加速下载。

构建流程

构建流程

Maven不但有标准化的项目结构，而且还有一套标准化的构建流程，可以自动化实现编译，打包，发布，等等。

Lifecycle和Phase

使用Maven时，我们首先要了解什么是Maven的生命周期（lifecycle）。
Maven的生命周期由一系列阶段（phase）构成，以内置的生命周期default为例，它包含以下phase：

• validate
• initialize
• generate-sources
• process-sources
• generate-resources
• process-resources
• compile
• process-classes
• generate-test-sources
• process-test-sources
• generate-test-resources
• process-test-resources
• test-compile
• process-test-classes
• test
• prepare-package
• package
• pre-integration-test
• integration-test
• post-integration-test
• verify
• install
• deploy

如果我们运行 mvn package，Maven 就会执行 default 生命周期，它会从开始一直运行到 package 这个 phase 为止：

• validate
• …
• package

如果我们运行 mvn compile，Maven 也会执行 default 生命周期，但这次它只会运行到 compile，即以下几个 phase：

• validate
• …
• compile

Maven 另一个常用的生命周期是 clean，它会执行 3 个 phase：

• pre-clean
• clean （注意这个clean不是lifecycle而是phase）
• post-clean

所以，我们使用mvn这个命令时，后面的参数是phase，Maven自动根据生命周期运行到指定的phase。
更复杂的例子是指定多个phase，例如，运行mvn clean package，Maven先执行clean生命周期并运行到clean这个phase，然后执行default生命周期并运行到package这个phase，实际执行的phase如下：

• pre-clean
• clean （注意这个clean是phase）
• validate
• …
• package

在实际开发过程中，经常使用的命令有：
mvn clean：清理所有生成的class和jar；
mvn clean compile：先清理，再执行到compile；
mvn clean test：先清理，再执行到test，因为执行test前必须执行compile，所以这里不必指定compile；
mvn clean package：先清理，再执行到package。

大多数phase在执行过程中，因为我们通常没有在pom.xml中配置相关的设置，所以这些phase什么事情都不做。
经常用到的phase其实只有几个：
clean：清理
compile：编译
test：运行测试
package：打包

Goal

执行一个phase又会触发一个或多个goal：

其实我们类比一下就明白了：

• lifecycle相当于Java的package，它包含一个或多个phase；
• phase相当于Java的class，它包含一个或多个goal；
• goal相当于class的method，它其实才是真正干活的。

大多数情况，我们只要指定phase，就默认执行这些phase默认绑定的goal，只有少数情况，我们可以直接指定运行一个goal，例如，启动Tomcat服务器：

1

mvn tomcat:run

小结

Maven通过lifecycle、phase和goal来提供标准的构建流程。
最常用的构建命令是指定phase，然后让Maven执行到指定的phase：

• mvn clean
• mvn clean compile
• mvn clean test
• mvn clean package

通常情况，我们总是执行phase默认绑定的goal，因此不必指定goal。

使用插件

我们在前面介绍了 Maven 的 lifecycle，phase 和 goal：使用 Maven 构建项目就是执行 lifecycle，执行到指定的 phase 为止。每个 phase 会执行自己默认的一个或多个 goal。goal 是最小任务单元。
我们以compile这个phase为例，如果执行：

1

mvn compile

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

<project>
   ...
   <build>
      <plugins>
         <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-shade-plugin</artifactId>
               <version>3.2.1</version>
            <executions>
               <execution>
                  <phase>package</phase>
                  <goals>
                     <goal>shade</goal>
                  </goals>
                  <configuration>
                           ...
                  </configuration>
               </execution>
            </executions>
         </plugin>
      </plugins>
   </build>
</project>

1
2
3
4
5
6
7

<configuration>
   <transformers>
      <transformer implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
            <mainClass>com.itranswarp.learnjava.Main</mainClass>
      </transformer>
   </transformers>
</configuration>

• maven-shade-plugin：打包所有依赖包并生成可执行jar；
• cobertura-maven-plugin：生成单元测试覆盖率报告；
• findbugs-maven-plugin：对Java源码进行静态分析以找出潜在问题。

小结

• Maven通过自定义插件可以执行项目构建时需要的额外功能，使用自定义插件必须在pom.xml中声明插件及配置；
• 插件会在某个phase被执行时执行；
• 插件的配置和用法需参考插件的官方文档。

模块管理

在软件开发中，把一个大项目分拆为多个模块是降低软件复杂度的有效方法：

1
2
3
4
5
6
7
8
9
10
11

                        ┌ ─ ─ ─ ─ ─ ─ ┐
                          ┌─────────┐
                        │ │Module A │ │
                          └─────────┘
┌──────────────┐ split  │ ┌─────────┐ │
│Single Project│───────>  │Module B │
└──────────────┘        │ └─────────┘ │
                          ┌─────────┐
                        │ │Module C │ │
                          └─────────┘
                        └ ─ ─ ─ ─ ─ ─ ┘

1
2
3

single-project
├── pom.xml
└── src

1
2
3
4
5
6
7
8
9
10

mutiple-project
├── module-a
│   ├── pom.xml
│   └── src
├── module-b
│   ├── pom.xml
│   └── src
└── module-c
   ├── pom.xml
   └── src

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

<project xmlns="http://maven.apache.org/POM/4.0.0"
   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
   xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
   <modelVersion>4.0.0</modelVersion>

   <groupId>com.itranswarp.learnjava</groupId>
   <artifactId>module-a</artifactId>
   <version>1.0</version>
   <packaging>jar</packaging>

   <name>module-a</name>

   <properties>
      <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
      <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
      <maven.compiler.source>11</maven.compiler.source>
      <maven.compiler.target>11</maven.compiler.target>
      <java.version>11</java.version>
   </properties>

   <dependencies>
      <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-api</artifactId>
            <version>1.7.28</version>
      </dependency>
      <dependency>
            <groupId>ch.qos.logback</groupId>
            <artifactId>logback-classic</artifactId>
            <version>1.2.3</version>
            <scope>runtime</scope>
      </dependency>
      <dependency>
            <groupId>org.junit.jupiter</groupId>
            <artifactId>junit-jupiter-engine</artifactId>
            <version>5.5.2</version>
            <scope>test</scope>
      </dependency>
   </dependencies>
</project>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

<project xmlns="http://maven.apache.org/POM/4.0.0"
   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
   xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
   <modelVersion>4.0.0</modelVersion>

   <groupId>com.itranswarp.learnjava</groupId>
   <artifactId>module-b</artifactId>
   <version>1.0</version>
   <packaging>jar</packaging>

   <name>module-b</name>

   <properties>
      <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
      <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
      <maven.compiler.source>11</maven.compiler.source>
      <maven.compiler.target>11</maven.compiler.target>
      <java.version>11</java.version>
   </properties>

   <dependencies>
      <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-api</artifactId>
            <version>1.7.28</version>
      </dependency>
      <dependency>
            <groupId>ch.qos.logback</groupId>
            <artifactId>logback-classic</artifactId>
            <version>1.2.3</version>
            <scope>runtime</scope>
      </dependency>
      <dependency>
            <groupId>org.junit.jupiter</groupId>
            <artifactId>junit-jupiter-engine</artifactId>
            <version>5.5.2</version>
            <scope>test</scope>
      </dependency>
   </dependencies>
</project>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

<project xmlns="http://maven.apache.org/POM/4.0.0"
   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
   xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
   <modelVersion>4.0.0</modelVersion>

   <groupId>com.itranswarp.learnjava</groupId>
   <artifactId>parent</artifactId>
   <version>1.0</version>
   <packaging>pom</packaging>

   <name>parent</name>

   <properties>
      <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
      <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
      <maven.compiler.source>11</maven.compiler.source>
      <maven.compiler.target>11</maven.compiler.target>
      <java.version>11</java.version>
   </properties>

   <dependencies>
      <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-api</artifactId>
            <version>1.7.28</version>
      </dependency>
      <dependency>
            <groupId>ch.qos.logback</groupId>
            <artifactId>logback-classic</artifactId>
            <version>1.2.3</version>
            <scope>runtime</scope>
      </dependency>
      <dependency>
            <groupId>org.junit.jupiter</groupId>
            <artifactId>junit-jupiter-engine</artifactId>
            <version>5.5.2</version>
            <scope>test</scope>
      </dependency>
   </dependencies>
</project>

1
2
3
4
5
6
7
8
9
10
11
12
13

multiple-project
├── pom.xml
├── parent
│   └── pom.xml
├── module-a
│   ├── pom.xml
│   └── src
├── module-b
│   ├── pom.xml
│   └── src
└── module-c
   ├── pom.xml
   └── src

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

<project xmlns="http://maven.apache.org/POM/4.0.0"
   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
   xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
   <modelVersion>4.0.0</modelVersion>

   <parent>
      <groupId>com.itranswarp.learnjava</groupId>
      <artifactId>parent</artifactId>
      <version>1.0</version>
      <relativePath>../parent/pom.xml</relativePath>
   </parent>

   <artifactId>module-a</artifactId>
   <packaging>jar</packaging>
   <name>module-a</name>
</project>

1
2
3
4
5
6
7
8

   ...
<dependencies>
   <dependency>
         <groupId>com.itranswarp.learnjava</groupId>
         <artifactId>module-b</artifactId>
         <version>1.0</version>
   </dependency>
</dependencies>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

<project xmlns="http://maven.apache.org/POM/4.0.0"
   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
   xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">

   <modelVersion>4.0.0</modelVersion>
   <groupId>com.itranswarp.learnjava</groupId>
   <artifactId>build</artifactId>
   <version>1.0</version>
   <packaging>pom</packaging>
   <name>build</name>

   <modules>
      <module>parent</module>
      <module>module-a</module>
      <module>module-b</module>
      <module>module-c</module>
   </modules>
</project>

中央仓库

其实我们使用的大多数第三方模块都是这个用法，例如，我们使用commons logging、log4j这些第三方模块，就是第三方模块的开发者自己把编译好的jar包发布到Maven的中央仓库中。

私有仓库

私有仓库是指公司内部如果不希望把源码和jar包放到公网上，那么可以搭建私有仓库。私有仓库总是在公司内部使用，它只需要在本地的~/.m2/settings.xml中配置好，使用方式和中央仓位没有任何区别。

本地仓库

本地仓库是指把本地开发的项目“发布”在本地，这样其他项目可以通过本地仓库引用它。但是我们不推荐把自己的模块安装到Maven的本地仓库，因为每次修改某个模块的源码，都需要重新安装，非常容易出现版本不一致的情况。更好的方法是使用模块化编译，在编译的时候，告诉Maven几个模块之间存在依赖关系，需要一块编译，Maven就会自动按依赖顺序编译这些模块。

小结

Maven支持模块化管理，可以把一个大项目拆成几个模块：

• 可以通过继承在parent的pom.xml统一定义重复配置；
• 可以通过<modules>编译多个模块。

使用mvnw

我们使用Maven时，基本上只会用到mvn这一个命令。有些童鞋可能听说过mvnw，这个是啥？
mvnw是Maven Wrapper的缩写。因为我们安装Maven时，默认情况下，系统所有项目都会使用全局安装的这个Maven版本。但是，对于某些项目来说，它可能必须使用某个特定的Maven版本，这个时候，就可以使用Maven Wrapper，它可以负责给这个特定的项目安装指定版本的Maven，而其他项目不受影响。
简单地说，Maven Wrapper就是给一个项目提供一个独立的，指定版本的Maven给它使用。

安装Maven Wrapper

安装Maven Wrapper最简单的方式是在项目的根目录（即pom.xml所在的目录）下运行安装命令：

1

mvn -N io.takari:maven:0.7.6:wrapper

1

mvn -N io.takari:maven:0.7.6:wrapper -Dmaven=3.3.3

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

my-project
├── .mvn
│   └── wrapper
│       ├── MavenWrapperDownloader.java
│       ├── maven-wrapper.jar
│       └── maven-wrapper.properties
├── mvnw
├── mvnw.cmd
├── pom.xml
└── src
   ├── main
   │   ├── java
   │   └── resources
   └── test
      ├── java
      └── resources

1

mvnw clean package

1

./mvnw clean package

多线程基础

现代操作系统（Windows，macOS，Linux）都可以执行多任务。多任务就是同时运行多个任务，例如： IE、 QQ、网易云音乐
CPU执行代码都是一条一条顺序执行的，但是，即使是单核cpu，也可以同时运行多个任务。因为操作系统执行多任务实际上就是让CPU对多个任务轮流交替执行。
例如，假设我们有语文、数学、英语3门作业要做，每个作业需要30分钟。我们把这3门作业看成是3个任务，可以做1分钟语文作业，再做1分钟数学作业，再做1分钟英语作业。
这样轮流做下去，在某些人眼里看来，做作业的速度就非常快，看上去就像同时在做3门作业一样。
类似的，操作系统轮流让多个任务交替执行，例如，让浏览器执行0.001秒，让QQ执行0.001秒，再让音乐播放器执行0.001秒，在人看来，CPU就是在同时执行多个任务。
即使是多核CPU，因为通常任务的数量远远多于CPU的核数，所以任务也是交替执行的。

进程

在计算机中，我们把一个任务称为一个进程，浏览器就是一个进程，视频播放器是另一个进程，类似的，音乐播放器和Word都是进程。
某些进程内部还需要同时执行多个子任务。例如，我们在使用Word时，Word可以让我们一边打字，一边进行拼写检查，同时还可以在后台进行打印，我们把子任务称为线程。
进程和线程的关系就是：一个进程可以包含一个或多个线程，但至少会有一个线程。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

                        ┌──────────┐
                        │Process   │
                        │┌────────┐│
            ┌──────────┐││ Thread ││┌──────────┐
            │Process   ││└────────┘││Process   │
            │┌────────┐││┌────────┐││┌────────┐│
┌──────────┐││ Thread ││││ Thread ││││ Thread ││
│Process   ││└────────┘││└────────┘││└────────┘│
│┌────────┐││┌────────┐││┌────────┐││┌────────┐│
││ Thread ││││ Thread ││││ Thread ││││ Thread ││
│└────────┘││└────────┘││└────────┘││└────────┘│
└──────────┘└──────────┘└──────────┘└──────────┘
┌──────────────────────────────────────────────┐
│               Operating System               │
└──────────────────────────────────────────────┘

1. 多进程模式（每个进程只有一个线程）：

   1 2 3 4 5 6

   ┌──────────┐ ┌──────────┐ ┌──────────┐ │Process │ │Process │ │Process │ │┌────────┐│ │┌────────┐│ │┌────────┐│ ││ Thread ││ ││ Thread ││ ││ Thread ││ │└────────┘│ │└────────┘│ │└────────┘│ └──────────┘ └──────────┘ └──────────┘

2. 多线程模式（一个进程有多个线程）：

   1 2 3 4 5 6 7 8 9

   ┌────────────────────┐ │Process │ │┌────────┐┌────────┐│ ││ Thread ││ Thread ││ │└────────┘└────────┘│ │┌────────┐┌────────┐│ ││ Thread ││ Thread ││ │└────────┘└────────┘│ └────────────────────┘

3. 多进程＋多线程模式（复杂度最高）：

   1 2 3 4 5 6 7 8 9

   ┌──────────┐┌──────────┐┌──────────┐ │Process ││Process ││Process │ │┌────────┐││┌────────┐││┌────────┐│ ││ Thread ││││ Thread ││││ Thread ││ │└────────┘││└────────┘││└────────┘│ │┌────────┐││┌────────┐││┌────────┐│ ││ Thread ││││ Thread ││││ Thread ││ │└────────┘││└────────┘││└────────┘│ └──────────┘└──────────┘└──────────┘

进程 vs 线程

进程和线程是包含关系，但是多任务既可以由多进程实现，也可以由单进程内的多线程实现，还可以混合多进程＋多线程。
具体采用哪种方式，要考虑到进程和线程的特点。
和多线程相比，多进程的缺点在于：

• 创建进程比创建线程开销大，尤其是在Windows系统上；
• 进程间通信比线程间通信要慢，因为线程间通信就是读写同一个变量，速度很快。

而多进程的优点在于：

多进程稳定性比多线程高，因为在多进程的情况下，一个进程崩溃不会影响其他进程，而在多线程的情况下，任何一个线程崩溃会直接导致整个进程崩溃。

多线程

Java语言内置了多线程支持：一个Java程序实际上是一个JVM进程，JVM进程用一个主线程来执行main()方法，在main()方法内部，我们又可以启动多个线程。此外，JVM还有负责垃圾回收的其他工作线程等。

因此，对于大多数Java程序来说，我们说多任务，实际上是说如何使用多线程实现多任务。

和单线程相比，多线程编程的特点在于：多线程经常需要读写共享数据，并且需要同步。例如，播放电影时，就必须由一个线程播放视频，另一个线程播放音频，两个线程需要协调运行，否则画面和声音就不同步。因此，多线程编程的复杂度高，调试更困难。

Java多线程编程的特点又在于：

• 多线程模型是Java程序最基本的并发模型；
• 后续读写网络、数据库、Web开发等都依赖Java多线程模型。

因此，必须掌握Java多线程编程才能继续深入学习其他内容。

创建新线程

Java语言内置了多线程支持。当Java程序启动的时候，实际上是启动了一个JVM进程，然后，JVM启动主线程来执行main()方法。在main()方法中，我们又可以启动其他线程。
要创建一个新线程非常容易，我们需要实例化一个Thread实例，然后调用它的start()方法：

1
2
3
4
5
6

public class Main {
   public static void main(String[] args) {
      Thread t = new Thread();
      t.start(); // 启动新线程
   }
}

1. 方法一：从Thread派生一个自定义类，然后覆写run()方法：

   1 2 3 4 5 6 7 8 9 10 11 12 13

   public class Main { public static void main(String[] args) { Thread t = new MyThread(); t.start(); // 启动新线程 } } class MyThread extends Thread { @Override public void run() { System.out.println("start new thread!"); } }

   输出

   1	start new thread!

   执行上述代码，注意到 start() 方法会在内部自动调用实例的 run() 方法。

   三步走：

   1. 继承 Thread 类
   2. 重写 run() 方法
   3. 调用 start() 开启线程

2. 方法二：创建 Thread 实例时，传入一个 Runnable 实例：

   1 2 3 4 5 6 7 8 9 10 11 12 13

   public class Main { public static void main(String[] args) { Thread t = new Thread(new MyRunnable()); t.start(); // 启动新线程 } } class MyRunnable implements Runnable { @Override public void run() { System.out.println("start new thread!"); } }

   输出

   1	start new thread!

   三步走：

   1. 实现 Runbable 接口
   2. 重写 run() 方法
   3. 执行进程需要丢入 Runnable接口实现类，调用 start() 方法

3. 方法三：用 Java8 引入的 lambda 语法进一步简写为：

   1 2 3 4 5 6 7 8

   public class Main { public static void main(String[] args) { Thread t = new Thread(() -> { System.out.println("start new thread!"); }); t.start(); // 启动新线程 } }

   使用 lambda简化，其实 lambda 也相当于实现类

使用线程执行的打印语句，和直接在main()方法执行有区别吗？
区别大了去了。我们看以下代码：

1
2
3
4
5
6
7
8
9
10
11
12
13

public class Main {
   public static void main(String[] args) {
      System.out.println("main start..."); // main
      Thread t = new Thread() { // main
            public void run() {
               System.out.println("thread run...");
               System.out.println("thread end.");
            }
      };
      t.start(); // main
      System.out.println("main end..."); // main
   }
}

当 run() 方法结束时，新线程就结束了。而 main() 方法结束时，主线程也结束了。
我们再来看线程的执行顺序：

1. main 线程肯定是先打印 main start，再打印 main end；
2. t 线程肯定是先打印 thread run，再打印 thread end。

但是，除了可以肯定，main start 会先打印外，main end 打印在 thread run 之前、thread end 之后或者之间，都无法确定。因为从 t 线程开始运行以后，两个线程就开始同时运行了，并且由操作系统调度，程序本身无法确定线程的调度顺序。

要模拟并发执行的效果，我们可以在线程中调用Thread.sleep()，强迫当前线程暂停一段时间：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

public class Main { public static void main(String[] args) { System.out.println("main start..."); Thread t = new Thread() { public void run() { System.out.println("thread run..."); try { Thread.sleep(10); } catch (InterruptedException e) {} System.out.println("thread end."); } }; t.start(); try { Thread.sleep(20); } catch (InterruptedException e) {} System.out.println("main end..."); } }

sleep() 传入的参数是毫秒。调整暂停时间的大小，我们可以看到 main 线程和 t 线程执行的先后顺序。

要特别注意：直接调用Thread实例的run()方法是无效的：

1 2 3 4 5 6 7 8 9 10 11 12

public class Main { public static void main(String[] args) { Thread t = new MyThread(); t.run(); } } class MyThread extends Thread { public void run() { System.out.println("hello"); } }

直接调用 run() 方法，相当于调用了一个普通的 Java 方法，当前线程并没有任何改变，也不会启动新线程。上述代码实际上是在 main() 方法内部又调用了 run() 方法，打印 hello 语句是在 main 线程中执行的，没有任何新线程被创建。
必须调用 Thread 实例的 start() 方法才能启动新线程，如果我们查看 Thread 类的源代码，会看到 start() 方法内部调用了一个 private native void start0() 方法，native 修饰符表示这个方法是由 JVM 虚拟机内部的 C 代码实现的，不是由 Java 代码实现的。

线程的优先级

可以对线程设定优先级，设定优先级的方法是：

1

Thread.setPriority(int n) // 1~10, 默认值5

1

Thread.getPriority()

Note:

• 优先级高的线程被操作系统调度的优先级较高，操作系统对高优先级线程可能调度更频繁，但我们决不能通过设置优先级来确保高优先级的线程一定会先执行。
• 先设置优先级，再启动

小结

• Java 用 Thread 对象表示一个线程，通过调用 start() 启动一个新线程；
• 一个线程对象只能调用一次 start() 方法；
• 线程的执行代码写在 run() 方法中；
• 线程调度由操作系统决定，程序本身无法决定调度顺序；
• Thread.sleep() 可以把当前线程暂停一段时间；
• 线程开启不一定立即执行，由 CPU 调度执行
• 推荐使用 Runnable 接口，因为 Java 单继承的局限性

静态代理模式

1. 真实对象（目标对象）和代理对象都要实现同一个接口
2. 代理对象要代理真实角色

好处：

• 代理对象可以做很多真实对象做不了的事情
• 真实对象专注做自己的事情

Lambda表达式

• 函数式接口定义: 任何接口，如果只包含唯一一个抽象方法，那么它就是一个函数式接口
• 对于函数式接口，我们可以通过 lambda 表达式来创建该接口的对象。

小结

• lambda 表达式只有一行代码的情况下才能简化为一行，如果有多行就用代码块包裹
• 前提是：接口是函数式接口
• 多个参数也可以去掉参数类型，若去掉就都去掉，必须加上括号

线程的状态

线程方法

停止线程

• 不推荐使用JDK提供的 stop()、destroy()方法。【已废弃】
• 推荐线程自己停止下来—> 利用次数，不建议死循环
• 建议使用一个标志位进行终止遍历，当 flag==false，则终止线程运行

线程休眠

• sleep(时间) 置顶当前线程阻塞的毫秒数；
• sleep 存在 异常 InterruptedException;
• sleep 时间达到后线程进入就去状态；
• sleep 可以模拟网络延时，倒计时等；
• 每一个对象都有一个锁，sleep不会释放锁；

问题

模拟网络延时：放大问题的发生性

线程礼让

• 礼让线程：让当期那正在执行的线程暂停，但不阻塞
• 让线程从运行状态转为就绪状态
• 让CPU重新调度，礼让不一定成功！看CPU心情

线程强制执行（join）

• join 合并线程，待此线程执行完成后，再执行其他线程
• 可以想象成插队
• 记住：插的队的是对当前的线程插队，对其他线程并没有影响，只有插队的线程执行完成后，被插队的线程才可以执行

线程状态观测

Thread.State
在 Java 程序中，一个线程对象只能调用一次 start() 方法启动新线程，并在新线程中执行 run() 方法。一旦 run() 方法执行完毕，线程就结束了。因此，Java 线程的状态有以下几种：

• New：新创建的线程，尚未执行；
• Runnable：运行中的线程，正在执行 run() 方法的 Java 代码；
• Blocked：运行中的线程，因为某些操作被阻塞而挂起；
• Waiting：运行中的线程，因为某些操作在等待中；
• Timed Waiting：运行中的线程，因为执行 sleep() 方法正在计时等待；
• Terminated：线程已终止，因为 run() 方法执行完毕。

用一个状态转移图表示如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

          ┌─────────────┐
          │     New     │
          └─────────────┘
                │
                ▼
┌ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ┐
 ┌─────────────┐ ┌─────────────┐
││  Runnable   │ │   Blocked   ││
 └─────────────┘ └─────────────┘
│┌─────────────┐ ┌─────────────┐│
 │   Waiting   │ │Timed Waiting│
│└─────────────┘ └─────────────┘│
 ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─
                │
                ▼
         ┌─────────────┐
         │ Terminated  │
         └─────────────┘

线程终止的原因有：

• 线程正常终止：run() 方法执行到 return 语句返回；
• 线程意外终止：run() 方法因为未捕获的异常导致线程终止；
• 对某个线程的 Thread 实例调用 stop() 方法强制终止（强烈不推荐使用）。

一个线程还可以等待另一个线程直到其运行结束。例如，main 线程在启动 t 线程后，可以通过 t.join() 等待 t 线程结束后再继续运行：

1
2
3
4
5
6
7
8
9
10
11

public class Main {
   public static void main(String[] args) throws InterruptedException {
      Thread t = new Thread(() -> {
            System.out.println("hello");
      });
      System.out.println("start");
      t.start();
      t.join();
      System.out.println("end");
   }
}

小结

• Java线程对象Thread的状态包括：New、Runnable、Blocked、Waiting、Timed Waiting和Terminated；
• 通过对另一个线程对象调用join()方法可以等待其执行结束；
• 可以指定等待时间，超过等待时间线程仍然没有结束就不再等待；
• 对已经运行结束的线程调用join()方法会立刻返回。

中断线程

如果线程需要执行一个长时间任务，就可能需要能中断线程。中断线程就是其他线程给该线程发一个信号，该线程收到信号后结束执行 run() 方法，使得自身线程能立刻结束运行。
我们举个栗子：假设从网络下载一个 100M 的文件，如果网速很慢，用户等得不耐烦，就可能在下载过程中点 “取消”，这时，程序就需要中断下载线程的执行。
中断一个线程非常简单，只需要在其他线程中对目标线程调用 interrupt() 方法，目标线程需要反复检测自身状态是否是 interrupted 状态，如果是，就立刻结束运行。
我们还是看示例代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

public class Main {
   public static void main(String[] args) throws InterruptedException {
      Thread t = new MyThread();
      t.start();
      Thread.sleep(1); // 暂停1毫秒
      t.interrupt(); // 中断t线程
      t.join(); // 等待t线程结束
      System.out.println("end");
   }
}

class MyThread extends Thread {
   public void run() {
      int n = 0;
      while (! isInterrupted()) {
            n ++;
            System.out.println(n + " hello!");
      }
   }
}

如果线程处于等待状态，例如，t.join()会让 main 线程进入等待状态，此时，如果对 main 线程调用 interrupt()，join()方法会立刻抛出 InterruptedException，因此，目标线程只要捕获到 join()方法抛出的 InterruptedException，就说明有其他线程对其调用了 interrupt()方法，通常情况下该线程应该立刻结束运行。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

public class Main {
   public static void main(String[] args) throws InterruptedException {
      Thread t = new MyThread();
      t.start();
      Thread.sleep(1000);
      t.interrupt(); // 中断t线程
      t.join(); // 等待t线程结束
      System.out.println("end");
   }
}

class MyThread extends Thread {
   public void run() {
      Thread hello = new HelloThread();
      hello.start(); // 启动hello线程
      try {
            hello.join(); // 等待hello线程结束
      } catch (InterruptedException e) {
            System.out.println("interrupted!");
      }
      hello.interrupt();
   }
}

class HelloThread extends Thread {
   public void run() {
      int n = 0;
      while (!isInterrupted()) {
            n++;
            System.out.println(n + " hello!");
            try {
               Thread.sleep(100);
            } catch (InterruptedException e) {
               System.out.println("InterruptedException");
               break;
            }
      }
   }
}

另一个常用的中断线程的方法是设置标志位。我们通常会用一个 running 标志位来标识线程是否应该继续运行，在外部线程中，通过把 HelloThread.running 置为 false，就可以让线程结束：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

public class Main {
   public static void main(String[] args)  throws InterruptedException {
      HelloThread t = new HelloThread();
      t.start();
      Thread.sleep(1);
      t.running = false; // 标志位置为false
   }
}

class HelloThread extends Thread {
   public volatile boolean running = true;
   public void run() {
      int n = 0;
      while (running) {
            n ++;
            System.out.println(n + " hello!");
      }
      System.out.println("end!");
   }
}

为什么要对线程间共享的变量用关键字 volatile 声明？这涉及到 Java 的内存模型。在 Java 虚拟机中，变量的值保存在主内存中，但是，当线程访问变量时，它会先获取一个副本，并保存在自己的工作内存中。如果线程修改了变量的值，虚拟机会在某个时刻把修改后的值回写到主内存，但是，这个时间是不确定的！

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

┌ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ┐
         Main Memory
│                               │
   ┌───────┐┌───────┐┌───────┐
│  │ var A ││ var B ││ var C │  │
   └───────┘└───────┘└───────┘
│     │ ▲               │ ▲     │
 ─ ─ ─│─│─ ─ ─ ─ ─ ─ ─ ─│─│─ ─ ─
      │ │               │ │
┌ ─ ─ ┼ ┼ ─ ─ ┐   ┌ ─ ─ ┼ ┼ ─ ─ ┐
      ▼ │               ▼ │
│  ┌───────┐  │   │  ┌───────┐  │
   │ var A │         │ var C │
│  └───────┘  │   │  └───────┘  │
   Thread 1          Thread 2
└ ─ ─ ─ ─ ─ ─ ┘   └ ─ ─ ─ ─ ─ ─ ┘

因此，volatile 关键字的目的是告诉虚拟机：

• 每次访问变量时，总是获取主内存的最新值；
• 每次修改变量后，立刻回写到主内存。

volatile关键字解决的是可见性问题：当一个线程修改了某个共享变量的值，其他线程能够立刻看到修改后的值。
如果我们去掉volatile关键字，运行上述程序，发现效果和带volatile差不多，这是因为在x86的架构下，JVM回写主内存的速度非常快，但是，换成ARM的架构，就会有显著的延迟。

小结

• 对目标线程调用interrupt()方法可以请求中断一个线程，目标线程通过检测isInterrupted()标志获取自身是否已中断。如果目标线程处于等待状态，该线程会捕获到InterruptedException；
• 目标线程检测到isInterrupted()为true或者捕获了InterruptedException都应该立刻结束自身线程；
• 通过标志位判断需要正确使用volatile关键字；
• volatile关键字解决了共享变量在线程间的可见性问题。

守护线程

• 线程分为用户线程和守护线程
• 虚拟机必须确保用户线程执行完毕
• 虚拟机不用等待守护线程执行完毕
• 如：后台记录操作日志、监控内存、垃圾回收等

Java程序入口就是由JVM启动main线程，main线程又可以启动其他线程。当所有线程都运行结束时，JVM退出，进程结束。
如果有一个线程没有退出，JVM进程就不会退出。所以，必须保证所有线程都能及时结束。
但是有一种线程的目的就是无限循环，例如，一个定时触发任务的线程：

1
2
3
4
5
6
7
8
9
10
11
12
13

class TimerThread extends Thread {
   @Override
   public void run() {
      while (true) {
            System.out.println(LocalTime.now());
            try {
               Thread.sleep(1000);
            } catch (InterruptedException e) {
               break;
            }
      }
   }
}

1
2
3

Thread t = new MyThread();
t.setDaemon(true); // 默认是false：表示是用户线程，正常的线程都是用户线程
t.start();

线程同步

简单定义： 多个线程操作同一个资源
当多个线程同时运行时，线程的调度由操作系统决定，程序本身无法决定。因此，任何一个线程都有可能在任何指令处被操作系统暂停，然后在某个时间段后继续执行。
这个时候，有个单线程模型下不存在的问题就来了：如果多个线程同时读写共享变量，会出现数据不一致的问题。
我们来看一个例子：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

public class Main {
   public static void main(String[] args) throws Exception {
      var add = new AddThread();
      var dec = new DecThread();
      add.start();
      dec.start();
      add.join();
      dec.join();
      System.out.println(Counter.count);
   }
}

class Counter {
   public static int count = 0;
}

class AddThread extends Thread {
   public void run() {
      for (int i=0; i<10000; i++) { Counter.count += 1; }
   }
}

class DecThread extends Thread {
   public void run() {
      for (int i=0; i<10000; i++) { Counter.count -= 1; }
   }
}

为何会不安全：由于CPU会使线程进入阻塞状态，使修改资源的操作中断了，但是在这个时候，其他线程开始运行，也修改了这个资源，因此，会造成数据不一致。

例如，对于语句：

1

n = n + 1;

1
2
3

ILOAD
IADD
ISTORE

1
2
3
4
5
6
7
8
9
10
11

┌───────┐    ┌───────┐
│Thread1│    │Thread2│
└───┬───┘    └───┬───┘
    │            │
    │ILOAD (100) │
    │            │ILOAD (100)
    │            │IADD
    │            │ISTORE (101)
    │IADD        │
    │ISTORE (101)│
    ▼            ▼

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

┌───────┐     ┌───────┐
│Thread1│     │Thread2│
└───┬───┘     └───┬───┘
    │             │
    │-- lock --   │
    │ILOAD (100)  │
    │IADD         │
    │ISTORE (101) │
    │-- unlock -- │
    │             │-- lock --
    │             │ILOAD (101)
    │             │IADD
    │             │ISTORE (102)
    │             │-- unlock --
    ▼             ▼

可见，保证一段代码的原子性就是通过加锁和解锁实现的。Java程序使用synchronized关键字对一个对象进行加锁：

1
2
3

synchronized(lock) {
   n = n + 1;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

public class Main {
   public static void main(String[] args) throws Exception {
      var add = new AddThread();
      var dec = new DecThread();
      add.start();
      dec.start();
      add.join();
      dec.join();
      System.out.println(Counter.count);
   }
}

class Counter {
   public static final Object lock = new Object();
   public static int count = 0;
}

class AddThread extends Thread {
   public void run() {
      for (int i=0; i<10000; i++) {
            synchronized(Counter.lock) {
               Counter.count += 1;
            }
      }
   }
}

class DecThread extends Thread {
   public void run() {
      for (int i=0; i<10000; i++) {
            synchronized(Counter.lock) {
               Counter.count -= 1;
            }
      }
   }
}

1
2
3

synchronized(Counter.lock) { // 获取锁
   ...
} // 释放锁

我们来概括一下如何使用 synchronized：

• 找出修改共享变量的线程代码块；
• 选择一个共享实例作为锁；
• 使用 synchronized(lockObject) { … }。
  在使用 synchronized 的时候，不必担心抛出异常。因为无论是否有异常，都会在 synchronized 结束处正确释放锁：

  1 2 3 4 5 6 7 8

  public void add(int m) { synchronized (obj) { if (m < 0) { throw new RuntimeException(); } this.value += m; } // 无论有无异常，都会在此释放锁 }

  我们再来看一个错误使用synchronized的例子：

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37

  public class Main { public static void main(String[] args) throws Exception { var add = new AddThread(); var dec = new DecThread(); add.start(); dec.start(); add.join(); dec.join(); System.out.println(Counter.count); } } class Counter { public static final Object lock1 = new Object(); public static final Object lock2 = new Object(); public static int count = 0; } class AddThread extends Thread { public void run() { for (int i=0; i<10000; i++) { synchronized(Counter.lock1) { Counter.count += 1; } } } } class DecThread extends Thread { public void run() { for (int i=0; i<10000; i++) { synchronized(Counter.lock2) { Counter.count -= 1; } } } }

  结果并不是 0，这是因为两个线程各自的 synchronized 锁住的不是同一个对象！这使得两个线程各自都可以同时获得锁：因为 JVM 只保证同一个锁在任意时刻只能被一个线程获取，但两个不同的锁在同一时刻可以被两个线程分别获取。
  因此，使用synchronized的时候，获取到的是哪个锁非常重要。锁对象如果不对，代码逻辑就不对。
  我们再看一个例子：

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59

  public class Main { public static void main(String[] args) throws Exception { var ts = new Thread[] { new AddStudentThread(), new DecStudentThread(), new AddTeacherThread(), new DecTeacherThread() }; for (var t : ts) { t.start(); } for (var t : ts) { t.join(); } System.out.println(Counter.studentCount); System.out.println(Counter.teacherCount); } } class Counter { public static final Object lock = new Object(); public static int studentCount = 0; public static int teacherCount = 0; } class AddStudentThread extends Thread { public void run() { for (int i=0; i<10000; i++) { synchronized(Counter.lock) { Counter.studentCount += 1; } } } } class DecStudentThread extends Thread { public void run() { for (int i=0; i<10000; i++) { synchronized(Counter.lock) { Counter.studentCount -= 1; } } } } class AddTeacherThread extends Thread { public void run() { for (int i=0; i<10000; i++) { synchronized(Counter.lock) { Counter.teacherCount += 1; } } } } class DecTeacherThread extends Thread { public void run() { for (int i=0; i<10000; i++) { synchronized(Counter.lock) { Counter.teacherCount -= 1; } } } }

  上述代码的 4 个线程对两个共享变量分别进行读写操作，但是使用的锁都是 Counter.lock 这一个对象，这就造成了原本可以并发执行的 Counter.studentCount += 1 和 Counter.teacherCount += 1，现在无法并发执行了，执行效率大大降低。实际上，需要同步的线程可以分成两组：AddStudentThread 和 DecStudentThread，AddTeacherThread 和 DecTeacherThread，组之间不存在竞争，因此，应该使用两个不同的锁，即：
  AddStudentThread和DecStudentThread使用lockStudent锁：

  1 2 3

  synchronized(Counter.lockStudent) { ... }

  AddTeacherThread和DecTeacherThread使用lockTeacher锁：

  1 2 3

  synchronized(Counter.lockTeacher) { ... }

  这样才能最大化地提高执行效率。

不需要synchronized的操作

JVM规范定义了几种原子操作：

• 基本类型（long和double除外）赋值，例如：int n = m；
• 引用类型赋值，例如：List list = anotherList。

long 和 double 是 64 位数据，JVM 没有明确规定 64 位赋值操作是不是一个原子操作，不过在 x64 平台的 JVM 是把 long 和 double 的赋值作为原子操作实现的。
单条原子操作的语句不需要同步。例如：

1
2
3
4
5

public void set(int m) {
   synchronized(lock) {
      this.value = m;
   }
}

对引用也是类似。例如：

1
2
3

public void set(String s) {
   this.value = s;
}

但是，如果是多行赋值语句，就必须保证是同步操作，例如：

1
2
3
4
5
6
7
8
9
10

class Pair {
   int first;
   int last;
   public void set(int first, int last) {
      synchronized(this) {
            this.first = first;
            this.last = last;
      }
   }
}

1
2
3
4
5
6
7

class Pair {
   int[] pair;
   public void set(int first, int last) {
      int[] ps = new int[] { first, last };
      this.pair = ps;
   }
}

1

int[] ps = new int[] { first, last };

小结

• 多线程同时读写共享变量时，会造成逻辑错误，因此需要通过 synchronized 同步；
• 同步的本质就是给指定对象加锁，加锁后才能继续执行后续代码；
• 注意加锁对象必须是同一个实例；
• 对 JVM 定义的单个原子操作不需要同步；
• 方法里面需要修改的内容才需要锁，锁的太多，浪费资源；
• 锁的对象就是变化的量：需要增删改的对象

同步方法

我们知道Java程序依靠synchronized对线程进行同步，使用synchronized的时候，锁住的是哪个对象非常重要。

让线程自己选择锁对象往往会使得代码逻辑混乱，也不利于封装。更好的方法是把synchronized逻辑封装起来。例如，我们编写一个计数器如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

public class Counter {
   private int count = 0;

   public void add(int n) {
      synchronized(this) {
            count += n;
      }
   }

   public void dec(int n) {
      synchronized(this) {
            count -= n;
      }
   }

   public int get() {
      return count;
   }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

var c1 = Counter();
var c2 = Counter();

// 对c1进行操作的线程:
new Thread(() -> {
   c1.add();
}).start();
new Thread(() -> {
   c1.dec();
}).start();

// 对c2进行操作的线程:
new Thread(() -> {
   c2.add();
}).start();
new Thread(() -> {
   c2.dec();
}).start();

没有特殊说明时，一个类默认是非线程安全的。

我们再观察Counter的代码：

1
2
3
4
5
6
7
8

public class Counter {
   public void add(int n) {
      synchronized(this) {
            count += n;
      }
   }
   ...
}

1
2
3
4
5

public void add(int n) {
   synchronized(this) { // 锁住this
      count += n;
   } // 解锁
}

1
2
3

public synchronized void add(int n) { // 锁住this
   count += n;
} // 解锁

1
2
3

public synchronized static void test(int n) {
   ...
}

1
2
3
4
5
6
7

public class Counter {
   public static void test(int n) {
      synchronized(Counter.class) {
            ...
      }
   }
}

1
2
3
4
5
6
7
8

public class Counter {
   private int count;

   public int get() {
      return count;
   }
   ...
}

1
2
3
4
5
6
7
8
9
10
11
12

public class Counter {
   private int first;
   private int last;

   public Pair get() {
      Pair p = new Pair();
      p.first = first;
      p.last = last;
      return p;
   }
   ...
}

小结

• 用synchronized修饰方法可以把整个方法变为同步代码块，synchronized方法加锁对象是this；
• 通过合理的设计和数据封装可以让一个类变为“线程安全”；
• 一个类没有特殊说明，默认不是thread-safe；
• 多线程能否安全访问某个非线程安全的实例，需要具体问题具体分析。

死锁

Java的线程锁是可重入的锁。
什么是可重入的锁？我们还是来看例子：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

public class Counter {
   private int count = 0;

   public synchronized void add(int n) {
      if (n < 0) {
            dec(-n);
      } else {
            count += n;
      }
   }

   public synchronized void dec(int n) {
      count += n;
   }
}

字符串和编码

String

在 Java 中，String 是一个引用类型，它本身也是一个 class。但是，Java 编译器对 String 有特殊处理，即可以直接用 “…” 来表示一个字符串：

1

String s1 = "Hello!";

1

String s2 = new String(new char[] {'H', 'e', 'l', 'l', 'o', '!'});

Java 字符串的一个重要特点就是字符串不可变。这种不可变性是通过内部的 private final char[] 字段，以及没有任何修改 char[] 的方法实现的。看下例：

1
2
3
4
5
6
7
8

public class Main {
   public static void main(String[] args) {
      String s = "Hello";
      System.out.println(s);
      s = s.toUpperCase();
      System.out.println(s);
   }
}

输出

1 2	Hello HELLO

个人认为：字符串内容没有改变，因为字符串是引用类型，而 s.toUpperCase() 是创建了一个新的字符串，再用 s 指向它。只是原来的字符串无法通过 s 访问罢了。

字符串比较

当我们想要比较两个字符串是否相同时，要特别注意，我们实际上是想比较字符串的内容是否相同。必须使用 equals() 方法而不能用 ==。
看下例：

1
2
3
4
5
6
7
8

public class Main {
   public static void main(String[] args) {
      String s1 = "hello";
      String s2 = "hello";
      System.out.println(s1 == s2);
      System.out.println(s1.equals(s2));
   }
}

1
2

true
true

1
2
3
4
5
6
7
8

public class Main {
   public static void main(String[] args) {
      String s1 = "hello";
      String s2 = "HELLO".toLowerCase(); // 因为在编译期间，只有 hello 和 HELLO 两个字符串
      System.out.println(s1 == s2);
      System.out.println(s1.equals(s2));
   }
}

1
2

false
true

结论：两个字符串比较，必须总是使用 equals() 方法。要忽略大小写比较，使用 equalsIgnoreCase() 方法。String 类还提供了多种方法来搜索子串、提取子串。常用的方法有：

子串、提取子串

1. 是否包含子串

   1 2	// 是否包含子串: "Hello".contains("ll"); // true

   注意到 contains() 方法的参数是 CharSequence 而不是 String，因为 CharSequence 是 String 的父类。

2. 搜索子串的更多的例子：

   1 2 3 4

   "Hello".indexOf("l"); // 2 "Hello".lastIndexOf("l"); // 3 "Hello".startsWith("He"); // true "Hello".endsWith("lo"); // true

3. 提取子串

   1 2	"Hello".substring(2); // "llo" "Hello".substring(2, 4); // "ll"

注意索引号是从 0 开始的

去除首尾空白字符

使用 trim() 方法可以移除字符串首尾空白字符。空白字符包括 空格、\t、\r、\n：

1

"  \tHello\r\n ".trim(); // "Hello"

注意：trim() 并没有改变字符串的内容，而是返回了一个新字符串。
另一个 strip() 方法也可以移除字符串首尾空白字符。它和 trim() 不同的是，类似中文的空格字符 \u3000 也会被移除：

1 2 3

"\u3000Hello\u3000".strip(); // "Hello" " Hello ".stripLeading(); // "Hello " " Hello ".stripTrailing(); // " Hello"

String 还提供了 isEmpty() 和 isBlank() 来判断字符串是否为空和空白字符串：

1 2 3 4

"".isEmpty(); // true，因为字符串长度为0 " ".isEmpty(); // false，因为字符串长度不为0 " \n".isBlank(); // true，因为只包含空白字符 " Hello ".isBlank(); // false，因为包含非空白字符

替换子串

要在字符串中替换子串，有两种方法。一种是根据字符或字符串替换：