9. 多线程.md · fuhao_pan/java_learner

# 八. Java 多线程

现代操作系统（Windows，macOS，Linux）都可以执行多任务。多任务就是同时运行多个任务，例如，浏览器、IDE、音乐播放器等等软件同时运行。

CPU执行代码都是一条条顺序执行的，但是，即使是单核CPU, 也可以同时运行多个任务，因为操作系统执行多任务实际上就是让CPU对多个任务轮流交替执行，例如，让浏览器执行了0.001秒，让IDE执行0.001秒，再让音乐播放器执行0.001，因为速度非常快，在人看来，CPU就是在同事执行多个任务。

## 1.1 进程 VS 线程

在计算机中，我们把一个任务成为一个进程，例如浏览器就是一个进程，音乐播放器是另一个进程。那某些进程内部还需要同时执行多个子任务，比如，音乐播放器一边播放音乐，一边显示歌词，同时还可以搜索歌曲，我们把这些子任务成为线程。

进程和线程的关系是：一个进程可以包含一个或多个线程，但至少会有一个线程。
```ascii
                        ┌──────────┐
                        │Process   │
                        │┌────────┐│
            ┌──────────┐││ Thread ││┌──────────┐
            │Process   ││└────────┘││Process   │
            │┌────────┐││┌────────┐││┌────────┐│
┌──────────┐││ Thread ││││ Thread ││││ Thread ││
│Process   ││└────────┘││└────────┘││└────────┘│
│┌────────┐││┌────────┐││┌────────┐││┌────────┐│
││ Thread ││││ Thread ││││ Thread ││││ Thread ││
│└────────┘││└────────┘││└────────┘││└────────┘│
└──────────┘└──────────┘└──────────┘└──────────┘
┌──────────────────────────────────────────────┐
│               Operating System               │
└──────────────────────────────────────────────┘
```

操作系统调度的最小任务单位其实不是进程，而是线程。常用的Windows、Linux等操作系统都采用抢占式多任务，如何调度线程完全由操作系统决定，程序自己不能决定什么时候执行，以及执行多长时间。
因为同一个应用程序，既可以有多个进程，也可以有多个线程，因此，实现多任务的方法，有以下几种：

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

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

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

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

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

进程和线程是包含关系，但是多任务既可以由多进程实现，也可以由单进程内的多线程实现，还可以混合多进程＋多线程。

具体采用哪种方式，要考虑到进程和线程的特点。

和多线程相比，多进程的缺点在于：

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

而多进程的优点在于：

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

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

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

## 1.2 创建新线程

前面说到Java语言内置了多线程支持，当Java程序启动时，实际上是启动了一个JVM进程，然后主线程执行main()方法，在main()方法中又可以启动其他线程，要创建一个新线程是非常容易的，我们需要实例化一个<kbd>Thread</kbd>实例，然后调用它的<kbd>start()</kbd>方法:
```java
    public static void main(String[] args){
        Thread t = new Thread();
        t.start();
    }
```
但这个线程启动后实际上什么也没有做就立刻结束了。接下来可以让新线程执行指定的代码，有以上几种方法：

> 方法一：从<kbd>Thread</kbd>派生一个类，然后覆写<kbd>run()</kbd>方法：

```java
public class MyThread extends Thread {

@Override
    public void run() {
        System.out.println("这个是新的线程......");
    }

}

public static void main(String[] args) {
    Thread t = new MyThread();
    t.start();
}
```
当调用<kbd>start()</kbd>方法时会在内部自动调用实例的<kbd>run()</kbd>方法。要注意，直接调用<kbd>run()</kbd>方法，相当与调用了一个普通的Java方法，当前线程并没有任何改变，也不会启动新线程，必须调用<kbd>Thread</kbd>实例的<kbd>start()</kbd>方法才能启动新线程。

> 方法二： 创建<kbd>Thread</kbd>实例时，传入一个<kbd>Runnable</kbd>实例：

```java
public class MyThread implements Runnable {

@Override
    public void run() {
        System.out.println("这个是新的线程......");
    }

}

public static void main(String[] args) {
    Thread t = new Thread(new MyThread());
    t.start();
}
```

> 方法三：使用Java8引入的lambda语法：
```java
public static void main(String[] args) {
    Thread t = new Thread(()->{
        System.out.println("这个是新的线程......");
    });
    t.start();
}
```

光看代码执行的打印语句，和直接在<kbd>main()</kbd>方法执行有区别吗？

还是有区别的，我们在<kbd>main()</kbd>方法里加入一些打印语句:

```java

public static void main(String[] args) {
        System.out.println("main 开始...");
        Thread t = new Thread() {

@Override
            public void run() {
                System.out.println("新线程开始...");
                System.out.println("新线程结束...");
            }

};
        t.start();
        System.out.println("main 结束...");
    }
```
 1. <kbd>main()</kbd>方法会先打印"main 开始..."。
 2. 然后创建<kbd>Thread</kbd>对象，紧接着调用<kbd>start()</kbd>启动新线程，这时JVM就会创建一个新线程，我们通过实例变量<kbd>t</kbd>来表示这个新线程对象。
 3. 接着，<kbd>main()</kbd>方法的主线程执行打印"main 结束..."，而<kbd>t</kbd>线程在<kbd>main</kbd>线程执行的同时会并发执行，打印"新线程开始..."和"新线程结束..."

当<kbd>run()</kbd>方法结束时，新线程就结束了，而<kbd>main()</kbd>方法结束时，主线程也结束了。

运行多几次，我们会发现， "main 结束..."打印在"新线程开始..."之前、"新线程结束..."之后或者之间，都无法确定。因为从<kbd>t</kbd>线程开始运行以后，两个线程就开始同时运行了，并且由操作系统调度，程序本身无法确定线程的调度顺序。

要模拟并发执行的效果，我们可以在线程中调用Thread.sleep()，强迫当前线程暂停一段时间：
 ```java
    public static void main(String[] args) {
        System.out.println("main 开始...");
        Thread t = new Thread() {

@Override
            public void run() {
                System.out.println("新线程开始...");
                try {
                    Thread.sleep(5000);     //sleep方法传入的是参数是毫秒，强制线程停止5秒后再运行
                } catch (InterruptedException e) {

}
                System.out.println("新线程结束...");
            }

};
        t.start();
        System.out.println("main 结束...");
    }

```

## 1.3 线程的状态

线程的状态可以有以下6种状态：
* New(新建)：新创建的线程，尚未执行。
* Runnable(可运行)：运行中的线程，正在执行<kbd>run()</kbd>方法。
* Blocked(阻塞)：运行中的线程，因为某些操作被阻塞而挂起。
* Waiting(等待)：运行中的线程，因为某些操作再等待中
* Timed waiting(计时等待)：运行中的线程，因为执行<kbd>sleep()</kbd>方法正在计时等待。
* Terminated(终止)：现成已终止，因为<kbd>run()</kbd>方法执行完毕。

当线程启动后，它可以在<kbd>Runnable</kbd>、<kbd>Blocked</kbd>、<kbd>Waiting</kbd>和<kbd>Timed Waiting</kbd>这几个状态之间切换，直到最后变成<kbd>Terminated</kbd>状态，线程终止。

![avatar](./thread_status.png)

> 新建线程

当用new操作符创建一个新线程时，如new Thread(), 这个线程还没开始运行，这意味着它的状态是**新建(New)**。当一个线程处于新建状态时，程序还没有开始运行程序中的代码。

> 可运行线程

一旦调用<kbd>start()</kbd>方法，线程就处于了 **可运行(Runnable)** 状态。一个可运行的线程可能正在运行也可能没有运行。在Java中，没有将正在运行作为一个单独的状态，一个正在运行的线程仍然处于可运行状态。

一旦一个线程开始运行，它不一定始终保持运行。事实上，运行中的线程有时需要暂停，让其他线程有机会运行。线程调度的细节依赖于操作系统提供的服务。抢占式调度系统给每一个可运行线程一个时间片来执行任务，让时间片用完时，操作系统剥夺线程的运行权，并给另一个线程一个机会来运行。

> 阻塞和等待线程

当线程处于阻塞或等待状态时，它暂时是不活动的，它不运行任何的代码，而且消耗最少的资源。要由线程调度器重新激活这个线程。具体细节取决于它是怎样到达非活动状态的。

* 当这个线程试图获取一个内部的对象锁，而这个锁目前被其他线程占有，该线程就会阻塞。当所有线程都释放了这个锁，并且线程调度器允许该线程持有这个锁时，它将变成非阻塞状态。
 
* 当线程等待另一个线程通知调度器时，这个线程会进入等待状态。实际上，阻塞状态与等待状态并没有太大区别

* 有几个方法有超时参数，调用这个方法会放线程进入计时等待状态，这一个状态将一只保持到超时期满或者接收到适当的通知。带有超时参数的方法有<kbd>Thread.sleep</kbd>和<kbd>Object.wait</kbd>, <kbd>Thread.join</kbd>等。

> 终止线程

线程终止的原因有：

* <kbd>run()</kbd>方法正常退出，线程自然终止。
* 因为一个没有捕获的异常终止了<kbd>run()</kbd>方法，使线程意外终止。
* 对某个线程的<kbd>Thread</kbd>实例调用<kbd>stop()</kbd>方法强制终止。(强烈不推荐使用)

```java
    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");
    }
```

当<kbd>main()</kbd>方法主线程对线程对象<kbd>t</kbd>调用<kbd>join()</kbd>方法时，主线程将等待变量<kbd>t</kbd>表示的线程运行结束，即<kbd>join</kbd>就是指等待该线程结束，然后才继续往下执行自身线程。所以，上述代码打印顺序可以肯定是<kbd>main</kbd>线程先打印<kbd>start</kbd>，<kbd>t</kbd>线程再打印<kbd>hello</kbd>，<kbd>main()</kbd>线程最后再打印<kbd>end</kbd>。

如果<kbd>t</kbd>线程已经结束，对实例<kbd>t</kbd>调用<kbd>join()</kbd>会立刻返回。此外，<kbd>join(long)</kbd>的重载方法也可以指定一个等待时间，超过等待时间后就不再继续等待。

## 1.4 线程属性

线程属性包括中断的线程、守护线程、未捕获异常的处理器

### 1.4.1 中断线程

如果线程需要执行一个长时间任务，就可能需要能中断线程。中断线程就是其他线程给该线程发一个信号，该线程收到信号后结束执行<kbd>run()</kbd>方法，使得自身线程能立刻结束运行。

例如：从网络下载一个100M的文件，如果网速很慢，用户等得不耐烦，就可能在下载过程中点“取消”，这时，程序就需要中断下载线程的执行。

上面提到可以使用<kbd>stop()</kbd>方法来终止一个线程，但是这个方法已经被废弃了。除了已经废弃的<kbd>stop()</kbd>，我们还可以使用<kbd>interrupt()</kbd>方法来**请求**终止一个线程。当目标线程调用<kbd>interrupt()</kbd>方法后，目标线程需要反复检测自身状态是否是interrupted状态。也就是说调用线程对象的<kbd>interrupt()</kbd>方法并不一定就中断了正在运行的线程，它只是要求线程自己在核实的时机中断自己。

1. java.lang.Thread#interrupt: 中断目标线程，给目标线程发一个中断信号，线程被打上中断标记。

2. java.lang.Thread#isInterrupted(): 判断目标线程是否被中断，不会清除中断标记。

3. java.lang.Thread#interrupted: 判断目标线程是否被中断，会清除中断标记

要想得出是否设置了中断状态，首先调用静态的<kbd>Thread.currentThread</kbd>方法获得当前线程，然后调用<kbd>isInterrepted</kbd>方法
```java
public class MyThread extends Thread {

@Override
    public void run() {
        System.out.println("这个是新的线程......");
        while (!Thread.currentThread().isInterrupted()) {
            System.out.println("线程在跑了.....");
        }
    }

}

public static void main(String[] args) throws InterruptedException {
        Thread t = new MyThread();
        t.start();
        Thread.sleep(2000); //让主线程睡眠(阻塞)2秒
        t.interrupt(); // 请求中断t线程
        t.join(); // 等待t线程结束
        System.out.println("结束");
    }

```
以上代码，<kbd>main</kbd>主线程通过创建一个新线程<kbd>t</kbd>, 然后调用<kbd>start</kbd>方法启动<kbd>t</kbd>线程，然后我们让<kbd>main</kbd>主线程休眠2秒，然后调用<kbd>t.interrupt()</kbd>请求中断线程，<kbd>t.join</kbd>表示等待<kbd>t</kbd>线程结束再继续<kbd>main</kbd>主线程。

但是，如果线程被阻塞，就无法检查中断状态。这里就要引入InterruptedException。当在一个调用<kbd>sleep</kbd>或<kbd>wait</kbd>调用方法阻塞的线程上调用<kdb>interrupt</kdb>方法时，那个阻塞调用将被一个<kbd>InterruptedException</kbd>异常中断。

```java
public class MyThread extends Thread {

@Override
    public void run() {
        System.out.println("这个是新的线程......");
        try {
            Thread.sleep(10000); //休眠10秒
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
    }

}

```

以上代码，<kbd>main</kbd>主线程通过创建一个新线程<kbd>t</kbd>, 然后调用<kbd>start</kbd>方法启动<kbd>t</kbd>线程，<kbd>t</kbd>线程启动后休眠10秒进行阻塞，然后我们也让<kbd>main</kbd>主线程休眠2秒，然后调用<kbd>t.interrupt()</kbd>请求中断线程，因为<kbd>t</kbd>线程是在阻塞状态，直接抛出<kbd>InterruptedException</kbd>异常中断线程。

### 1.4.2 守护线程

Java程序入口就是由JVM启动main线程，main线程又可以启动其他线程。当所有线程都运行结束时，JVM退出，进程结束。

如果有一个线程没有退出，JVM进程就不会退出。所以，必须保证所有线程都能及时结束。

但是有一种线程的目的就是无限循环，例如，一个定时触发任务的线程：

```java
public class MyThread extends Thread {

@Override
    public void run() {
        while (true) {
            System.out.println(LocalTime.now());  //输出当前时间
            try {
                Thread.sleep(1000); //睡眠1秒
            } catch (InterruptedException e) {
                break;
            }
        }
    }

}

public static void main(String[] args) {
        Thread t = new MyThread();
        t.start();
        System.out.println("end");
    }
```
这个线程会无限循环不结束，如果这个线程不结束，JVM进程就无法结束。问题是，由谁负责结束这个线程？为避免这种情况，可以在调用<kbd>start()</kbd>方法前，通过调用<kbd>setDaemon(true)</kbd>方法将一个线程转换为 **守护线程(daemon thread)**。这样一个线程并没有什么魔力，守护线程的唯一用途是为其他线程提供服务。当只剩下守护线程时，JVM就会退出。
```java
public class MyThread extends Thread {

@Override
    public void run() {
        System.out.println("守护线程。。");
    }

}

public static void main(String[] args) {
        Thread t = new MyThread();
        t.setDaemon(true);  //设置为守护线程
        t.start();
        System.out.println("end");
    }
```

### 1.4.3 线程名

默认情况下，线程名字是以这样的方法命名：Thread-0、Thread-1、Thread-1。当线程多的时候，这样的命名不太方便我们观察程序运行，我们可以通过调用<kbd>setName</kbd>方法给线程设置我们想要的名字：
```java
    public static void main(String[] args) {
        Thread t = new MyThread();
        t.setName("测试线程");  //设置线程名
        t.start();
        System.out.println(t.getName());
    }
```

### 1.4.3 线程优先级

在Java中，每一个线程有一个**优先级**。默认情况下，一个线程会继承构造它的那个线程的优先级。当然我们也可以用<kbd>setPriority</kbd>方法提高或降低任何一个线程的优先级。优先级设置范围为1~10，1为最小优先级，10为最大优先级。每当线程调度器有机会选择要执行的线程时，它首先选择具有较高优先级的线程：

```java
    public static void main(String[] args) {
        Thread t = new MyThread();
        t.setPriority(10);  //设置最高优先级
        t.start();
    }
```

## 1.5 同步

在大多数实际的多线程应用中，两个或者多个线程需要共享对同一数据的存取，会出现数据不一致的问题。如果两个线程存取同一个数据，并且每个线程分别修改了数据，那么这两个线程会相互覆盖，去局域线程访问数据的次序。 举个例子：

```java
//公共类
public class Counter {
    public static int count = 0; //静态变量count
}

//加法操作线程类
public class AddThread extends Thread{

@Override
    public void run() {
        for (int i = 0; i < 1000; i++) {
            Counter.count += 1;
            try {
                Thread.sleep(5);//睡眠5毫秒，模拟线程方法执行耗时
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    }
}

//减法操作线程类
public class DecThread extends Thread{

@Override
    public void run() {
        for (int i = 0; i < 1000; i++) {
            Counter.count -= 1;
            try {
                Thread.sleep(5); //睡眠5毫秒，模拟线程方法执行耗时
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    }
}

//main方法
 public static void main(String[] args) throws InterruptedException {
    Thread t = new AddThread();
    Thread t2 = new DecThread();
    t.start();
    t2.start();
    t.join();
    t2.join();
    System.out.println(Counter.count);

}

```

上面的代码很简单，两个线程同时对一个int变量进行操作，一个加1000次，一个减1000次，最后结果应该是0，但是，每次运行，结果实际上都是不一样的。

这是因为对变量进行读取和写入时，结果要正确，必须保证是原子操作。原子操作是指不能被中断的一个或一系列操作。

假设count的值是0，如果两个线程同时读取count值进行操作，假设<kbd>AddThread</kbd>线程拿到count值0进行加1操作，count的值此时变为1；然而，<kbd>DecThread</kbd>线程在count值更新之前，也拿到了count值为0进行减1操作，那么count值被覆盖为-1。

想一下这个问题：
![avatar](./atm_issue.png)

由上可知，在多线程下，要保证逻辑正确，对共享变量进行读写时，必须保证一组指令以原子方法执行：即某一个线程执行时，其他线程必须等待。要实现原子操作，可通过加锁和解锁的操作，在对count值执行操作时，只有一条线程执行，不会有其他线程进入此指令区。即使在执行期线程被操作系统中断执行，其他线程也会因为无法获得锁导致无法进入此指令区间。只有执行线程将锁释放后，其他线程才有机会获得锁并执行。这种加锁和解锁之间的代码块我们称之为临界区(Critical Section)，任何时候临界区最多只有一个线程能执行。

Java程序使用<kbd>synchronized</kbd>关键字对一个对象进行加锁：
```java
//公共类
public class Counter {
    public static final Object lock = new Object();
    public static int count = 0; //静态变量count
}

//加法操作线程类
public class AddThread extends Thread{

@Override
    public void run() {
        for (int i = 0; i < 1000; i++) {
            synchronized (Counter.lock) {
                Counter.count += 1;
            }
            try {
                Thread.sleep(5);//睡眠5毫秒，模拟线程方法执行耗时
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    }
}

//减法操作线程类
public class DecThread extends Thread{

@Override
    public void run() {
        for (int i = 0; i < 1000; i++) {
            synchronized (Counter.lock) {
                Counter.count -= 1;
            }
            try {
                Thread.sleep(5); //睡眠5毫秒，模拟线程方法执行耗时
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    }
}

}

```

<kbd>synchronized</kbd>保证了代码块在任意时刻最多只有一个线程能执行。
```java
synchronized(Counter.lock) { // 获取锁
    ...
} // 释放锁
```
<kbd>synchronized(Counter.lock) { ... }</kbd>称为同步方法块，锁是括号里面的对象，要执行代码块里的代码，必须先获得锁，才能进入代码块执行。代码块执行结束后，在<kbd>synchronized</kbd>语句块结束会自动释放锁。这样一来，对count变量的加减操作就不可能同时进行。

使用<kbd>synchronized</kbd>解决了多线程同步访问共享变量的正确性问题。但是，它的缺点是带来了性能下降。因为<kbd>synchronized</kbd>代码块无法并发执行。此外，加锁和解锁需要消耗一定的时间，所以，<kbd>synchronized</kbd>会降低程序的执行效率。

### 1.5.1 synchronized详解

在应用Sychronized关键字时需要把握如下注意点：
* 一把锁只能同时被一个线程获取，没有获得锁的线程只能等待；
* 每个实例都对应有自己的一把锁(this),不同实例之间互不影响；例外：锁对象是*.class以及synchronized修饰的是static方法的时候，所有对象公用同一把锁
* synchronized修饰的方法，无论方法正常执行完毕还是抛出异常，都会释放锁

> 对象锁

包括方法锁(默认锁对象为this,即当前实例对象)和同步代码块锁(自己指定锁对象)，上面的方式就是同步代码块锁，指定使用<kbd>lock</kbd>对象作为锁对象。让线程自己选择锁对象往往会使得代码逻辑混乱，也不利于封装。更好的办法把<kbd>synchronized</kbd>逻辑封装起来。
```java
//Counter类
public class Counter {
    public int count = 0;

public void add() {
        synchronized (this) {   //可以使用this，也可以指定锁对象
            count += 1;
        }
    }

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

public int getCount(){
        return count;
    }

}

//mian 方法
public static void main(String[] args) throws InterruptedException {
        Counter counter = new Counter();
        Thread t = new Thread(){
            @Override
            public void run() {
                for (int i = 0; i < 1000; i++) {
                    counter.add();
                    try {
                        Thread.sleep(5);//睡眠5毫秒，模拟线程方法执行耗时
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                }

}
        };
        Thread t2 = new Thread(){
            @Override
            public void run() {
                for (int i = 0; i < 1000; i++) {
                    counter.dec();
                    try {
                        Thread.sleep(5);//睡眠5毫秒，模拟线程方法执行耗时
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                }
            }
        };
        t.start();
        t2.start();
        t.join();
        t2.join();
        System.out.println(counter.getCount());

}
```
这样一来，线程调用<kbd>add()</kbd>、<kbd>dec()</kbd>方法时，线程不必关心同步逻辑，因为因为<kbd>synchronized</kbd>代码块在<kbd>add()</kbd>、<kbd>dec()</kbd>方法内部。并且，我们注意到，<kbd>synchronized</kbd>锁住的对象是<kbd>this</kbd>，即当前实例。

上面的写法还是同步代码块锁，那什么是方法锁？我们对<kbd>Counter</kbd>类的<kbd>add()</kbd>和<kbd>dec()</kbd>方法做一些修改：
```java
public class Counter {
    public int count = 0;

public synchronized void add() { //没有显示声明锁对象，但默认锁对象为this
        count += 1;
    }

public synchronized void dec() {//锁住this
        count -= 1;
    }//解锁

public int getCount(){
        return count;
    }

}
```

用<kbd>synchronized</kbd>修饰的方法就是同步方法，它表示整个方法都必须用<kbd>this</kbd>实例加锁。

> 类锁

指<kbd>synchronized</kbd>修饰静态的方法或指定锁对象为Class对象

```java
public class Counter {
    public static int count = 0;

public static synchronized void add() { //synchronized用在静态方法上，但默认锁对象为当前所在的Class类
        count += 1;
    }

public static synchronized void dec() {//锁住Class类
        count -= 1;
    }//解锁

public int getCount(){
        return count;
    }

}
```

或者指定锁对象为Class对象
```java

public static synchronized void add() { 
        synchronized (Counter.class) {
            count += 1;
        }
    }

}
```

### 1.5.2 ReentrantLock 使用

从Java5开始，引入了一个高级的处理并发的<kbd>java.util.concurrent</kbd>包，它提供了大量更高级的并发功能，能大大简化多线程程序的编写。

上面已经提到Java语言直接提供了<kbd>synchronized</kbd>关键字用于加锁，但这种锁一是很重，二是获取时必须一直等待，没有额外的尝试机制。

在<kbd>java.util.concurrent.locks</kbd>包提供了<kbd>ReetrantLock</kbd>，用于替代<kbd>synchronized</kbd>加锁：

传统的<kbd>synchronized</kbd>加锁
```java
public class Counter {
    private int count;

public void add(){
        synchronized(this) {
            count += 1;
        }
    }
}
```
如果用<kbd>ReetrantLock</kbd>替代，可以把代码改造为：
```java
public class Counter {

private final Lock lock = new ReentrantLock();
    private int count = 0;

public void add() {
        lock.lock();
        try {
            count += 1;
        } finally {
            lock.unlock();
        }
    }

}
```

因为<kbd>synchronized</kbd>是Java语言层面提供的语法，所以我们不需要考虑异常，而<kbd>ReentrantLock</kbd>是Java代码实现的锁，我们就必须先获取锁，然后在<kbd>finally</kbd>中正确释放锁。

* 相同点：<kbd>ReentrantLock</kbd>和<kbd>synchronized</kbd>都是可重入锁，一个线程可以多次获取同一个锁。
* 不同点：<kbd>ReentrantLock</kbd>可以尝试获取锁

```java
if (lock.tryLock(1, TimeUnit.SECONDS)) {
    try {
        ...
    } finally {
        lock.unlock();
    }
}
```

上述代码在尝试获取锁的时候，最多等待1秒。如果1秒后仍未获取到锁，<kbd>tryLock()</kbd>返回<kbd>false</kbd>，程序就可以做一些额外处理，而不是无限等待下去。

所以，使用<kbd>ReentrantLock</kbd>比直接使用<kbd>synchronized</kbd>更安全，线程在<kbd>tryLock()</kbd>失败的时候不会导致死锁。

### 1.5.3 死锁

<kbd>ReentrantLock</kbd>和<kbd>synchronized</kbd>都是可重入锁，那到底什么是可重入锁？

**所谓重入锁，指的是以线程为单位，当一个线程获取对象锁之后，这个线程可以再次获取本对象上的锁，而其他的线程是不可以的。**。
```java
public class Counter {
    private int count = 0;

public synchronized void action(int n){
         if (n < 0) {
            dec();
        } else {
            add();
        }
    }

public synchronized void add() {
        count += 1;
    }

public synchronized void dec() {
        count -= 1;
    }
}
```

我们看到<kbd>synchronized</kbd>修饰了<kbd>action</kbd>方法，一旦线程执行到<kbd>action</kbd>方法内部，说明这个线程已经获得当前实例的<kbd>this</kbd>锁。如果传入的<kbd>n</kbd> < 0，将在<kbd>action</kbd>方法内部调用<kbd>dec()</kbd>方法。由于<kbd>dec()</kbd>方法也需要获取<kbd>this</kbd>锁。

对于同一个线程，因为在执行<kbd>action</kbd>方法已经获取到了<kbd>this</kbd>锁，再次调用<kbd>dec()</kbd>方法也是同一个<kbd>this</kbd>锁，JVM允许同一个线程重复获取同一个锁，所谓可重入，意味着线程可以进入它已经拥有的锁的同步代码块儿。这种能被同一个线程反复获取的锁，就叫做可重入锁。

可重入锁的意义在于防止死锁。

那什么是死锁？**死锁(Deadlock)情况是指：两个或两个以上的线程持有不同系统资源的锁，线程彼此都等待获取对方的锁来完成自己的任务，但是没有让出自己持有的锁，线程就会无休止等待下去**
```java
public class Counter {

private final Object lockA = new Object();
    private final Object lockB = new Object();
    private int count = 0;
    private int amount = 0;

public void add() {
        synchronized (lockA) {  //获得lockA锁
            count += 1;
            System.out.println("add count");
            synchronized (lockB) {  //获取lockB锁
                amount += 1;
                System.out.println("add amount");
            } //释放lockB锁
        }  //释放lockA锁
    }

public void dec() {
        synchronized (lockB) {  //获取lockB锁
            count -= 1;
            synchronized (lockA) {  //获得lockA锁
                amount -= 1;
                System.out.println("dec amount");
            }   //释放lockA锁
        }   //释放lockB锁
    }
```

在获取多个锁的时候，不同线程获取多个不同对象的锁可能导致死锁。对于上述代码，线程1和线程2如果分别执行<kbd>add()</kbd>和<kbd>dec()</kbd>方法时：

* 线程1：进入add()，获得lockA；
* 线程2：进入dec()，获得lockB。

随后：

* 线程1：准备获得lockB，失败，等待中；
* 线程2：准备获得lockA，失败，等待中。

此时，两个线程各自持有不同的锁，然后各自试图获取对方手里的锁，造成了双方无限等待下去，这就是死锁。

死锁发生后，没有任何机制能解除死锁，只能强制结束JVM进程。

因此，在编写多线程应用时，要特别注意防止死锁。因为死锁一旦形成，就只能强制结束进程。

### 1.5.4 wait()和notify()/notifyAll()

<kbd>wait()</kbd>与<kbd>notify()</kbd>、<kbd>notifyAll()</kbd>是Object类的方法，在执行这些方法时要先获得锁，所以只可以在<kbd>synchronized</kbd>代码块内部调用这些方法。

> wait()

调用<kbd>wait()</kbd>方法会让当前线程进入等待状态，直到它得到通知，即直到另一个线程调用此对象的<kbd>notify</kbd>或者<kbd>notifyAll()</kbd>方法。

除了无参<kbd>wait()</kbd>方法外，Java还重载了两个wait方法

> wait(long timeout)

使用<kbd>wait(long timeout)</kbd>方法，我们可以指定一个超时时间(单位为: 毫秒)，在此方法调用后，到达超时时间自动唤醒线程。当然也可以在超时之前使用<kbd>notify</kbd>或者<kbd>notifyAll()</kbd>方法提前唤醒线程

> wait(long timeout, int nanos)

这个方法与<kbd>wait(long timeout)</kbd>功能相同，唯一的区别是我们可以提供更高的时间精度。(毫秒+纳秒)

> notify()

<kbd>notify()</kbd>方法会随机选择一个在这个对象上调用<kbd>wait()</kbd>方法的线程来唤醒，解除其阻塞状态，也就是说，我们并不能确切知道唤醒的是哪个线程，<kbd>notify()</kbd>提供的是唤醒一个随机线程的机制，所以大多数情况下，使用<kbd>notifyAll()</kbd>会使一个更可行的方案。

> notifyAll()

<kbd>notifyAll()</kbd>方法用于唤醒这个对象上调用了<kbd>wait()</kbd>方法的所有线程，解除这些线程的阻塞状态。

### 1.5.5 Condition使用

使用<kbd>ReentrantLock</kbd>比直接使用<kbd>synchronized</kbd>更安全，可以替代<kbd>synchronized</kbd>进行线程同步。

但是，<kbd>synchronized</kbd>可以配合<kbd>wait()</kbd>和<kbd>notify()</kbd>实现线程在条件不满足时等待，条件满足时唤醒，用<kbd>ReentrantLock</kbd>我们怎么编写<kbd>wait()</kbd>和<kbd>notify()</kbd>的功能呢？
```java
public class Counter {

private final Lock lock = new ReentrantLock();
    private final Condition condition = lock.newCondition();
    private int count = 0;

public void add() throws InterruptedException {
        lock.lock();
        try {
            count += 1;
            condition.await();

....

condition.signalAll();
        } finally {
            lock.unlock();
        }
    }
}
```

可见，使用<kbd>Condition</kbd>时，引用的<kbd>Condition</kbd>对象必须从<kbd>Lock</kbd>实例的<kbd>newCondition()</kbd>返回，这样才能获得一个绑定了<kbd>Lock</kbd>实例的<kbd>Condition</kbd>实例。

<kbd>Condition</kbd>提供的<kbd>await()</kbd>、<kbd>signal()</kbd>、<kbd>signalAll()</kbd>原理和<kbd>synchronized</kbd>锁对象的<kbd>wait()</kbd>、<kbd>notify()</kbd>、<kbd>notifyAll()</kbd>是一致的，并且其行为也是一样的：

* <kbd>await()</kbd>会释放当前锁，进入等待状态；

* <kbd>signal()</kbd>会唤醒某个等待线程；

* <kbd>signalAll()</kbd>会唤醒所有等待线程；

### 1.5.6 线程安全的集合

针对<kbd>List</kbd>、<kbd>Map</kbd>、<kbd>Set</kbd>等，<kbd>java.util.concurrent</kbd>包也提供了对应的并发集合类。

## 1.6 线程池

创建一个新的线程开销有些大，因为需要操作系统资源，频繁的创建和销毁线程需要消耗大量的时间。

如果可以复用一组线程，那么我们就可以把很多小任务让一组线程来执行，而不是一个任务对应一个新线程。那这一组线程，就是线程池。

```ascii
┌─────┐ execute  ┌──────────────────┐
│Task1│─────────>│ThreadPool        │
├─────┤          │┌───────┐┌───────┐│
│Task2│          ││Thread1││Thread2││
├─────┤          │└───────┘└───────┘│
│Task3│          │┌───────┐┌───────┐│
├─────┤          ││Thread3││Thread4││
│Task4│          │└───────┘└───────┘│
├─────┤          └──────────────────┘
│Task5│
├─────┤
│Task6│
└─────┘
  ...
```
简单来说，线程池内部维护了若干个线程，没有任务的时候，这些线程都处于等待的状态，如果有新的任务，就分配一个空闲的线程执行；如果所有线程都处于忙碌状态，新任务要么放入队列等待，要么增加一个新线程进行处理。

Java标准库提供了<kbd>ExecutorService</kbd>接口表示线程池，它的典型用法如下：

```java
// 创建固定大小的线程池:
ExecutorService executor = Executors.newFixedThreadPool(3);
// 提交任务:
executor.submit(task1);
executor.submit(task2);
executor.submit(task3);
executor.submit(task4);
executor.submit(task5);
```

因为<kbd>ExecutorService</kbd>只是接口，Java标准库提供的几个常用实现类有：

<kbd>newFixedThreadPool</kbd>：线程数固定的线程池；
<kbd>newCachedThreadPool</kbd>：线程数根据任务动态调整的线程池；
<kbd>newSingleThreadExecutor</kbd>：仅单线程执行的线程池。

创建这些线程池的方法都被封装到<kbd>Executors</kbd>这个类中。我们以<kbd>newFixedThreadPool</kbd>为例，看看线程池的执行逻辑：
```java
public class Task implements Runnable{

@Override
    public void run() {
        try {
            Thread.sleep(2000); //休眠2秒
        } catch (InterruptedException e) {
        }
        System.out.println(Thread.currentThread().getName());
    }
}

public static void main(String[] args) throws InterruptedException {
        // 创建一个固定大小的线程池:
        ExecutorService es = Executors.newFixedThreadPool(4);
        for (int i = 0; i < 6; i++) {
            es.submit(new Task());
        }
        // 关闭线程池:
        es.shutdown();
    }
```
观察执行结果，一次性放入6个任务，由于线程池只有固定的4个线程，因此，前4个任务会同时执行，等到有线程空闲后，才会执行后面的两个任务。
线程池在程序结束的时候要关闭。使用<kbd>shutdown()</kbd>方法关闭线程池的时候，它会等待正在执行的任务先完成，然后再关闭。<kbd>shutdownNow()</kbd>会立刻停止正在执行的任务，<kbd>awaitTermination()</kbd>则会等待指定的时间让线程池关闭。

## 1.7 Callable和Future

在执行多个任务的时候，使用Java标准库提供的线程池是非常方便的。我们提交的任务只需要实现Runnable接口，就可以让线程池去执行：
```java
public class Task implements Runnable {
    public String result;

@Override
    public void run() {
        ...
        this.result = "xxxx"; 
    }
}
```
<kbd>Runnable</kbd>接口有个问题，它的方法没有返回值。如果任务需要一个返回结果，那么只能保存到变量，还要提供额外的方法读取，非常不便。所以，Java标准库还提供了一个<kbd>Callable</kbd>接口，和<kbd>Runnable</kbd>接口比，它多了一个返回值：
```java
public class Task implements Callable<String> {

@Override
    public String call() throws Exception {
        return "xxxx";
    }
}
```
并且<kbd>Callable</kbd>接口是一个泛型接口，可以返回指定类型的结果。

现在的问题是，如何获得异步执行的结果？

我们看下<kbd>ExecutorService.submit()</kbd>方法，可以看到，它返回了一个<kbd>Future</kbd>类型，一个<kbd>Future</kbd>类型的实例代表一个未来能获取结果的对象：
```java
    public static void main(String[] args) throws InterruptedException, ExecutionException {

ExecutorService es = Executors.newFixedThreadPool(4);
        // 定义任务:
        Callable<String> task = new Task();
        // 提交任务并获得Future:
        Future<String> result = es.submit(task);
        // 从Future获取异步执行返回的结果:
        System.out.println(result.get());   //get方法可能阻塞
        // 关闭线程池:
        es.shutdown();
    }
```

当我们提交一个<kbd>Callable</kbd>任务后，我们会同时获得一个<kbd>Future</kbd>对象，然后，我们在主线程某个时刻调用<kbd>Future</kbd>对象的<kbd>get()</kbd>方法，就可以获得异步执行的结果。在调用<kbd>get()</kbd>时，如果异步任务已经完成，我们就直接获得结果。如果异步任务还没有完成，那么<kbd>get()</kbd>会阻塞，直到任务完成后才返回结果。

fuhao_pan/java_learner

About

Releases

Contributors

Activities

fuhao_pan/java_learner .gitee-modal { width: 500px !important; }

About

Releases

Contributors

Activities

Search

fuhao_pan/java_learner