Java从零开始 第14讲 多线程

什么是多线程

在学习多线程之前，先让我们明白什么是进程，什么是线程

进程是一个内存中运行的应用程序，每个进程都有一个独立的内存空间
而线程，是指进程中的一个执行路径，共享一个内存空间，线程之间可以自由切换，并发执行. 一个进程最少 有一个线程
线程实际上是在进程基础之上的进一步划分，一个进程启动之后，里面的若干执行路径又可以划分 成若干个线程

打开你电脑的任务管理，你就能看到你目前执行的线程和进程的数量

在之前我们所有的编程都是单线程的，即仅有main线程，程序运行的顺序是从头到尾；而当我们学习玩多线程后，我们能够并发的执行多个线程，以达到一些我们需要的功能。

多线程相关概念

调度

目前我们电脑的CPU通常有多核，其中的每一个核，都只能运行单一的线程，为了在不提升运算速率（指处理单个线程的时间）的情况下，提高CPU运算的效率，就必须对合理的调度线程（对于单核而言，并不能提升）

线程的调度，即是对线程运行的调配。在一个进程中，通常所有线程不会一起运行，而是根据需要分次分时的运行，为了能够合理的调度线程，我们有两种基础调度模型：

分时调度：
所有线程轮流使用 CPU 的使用权，平均分配每个线程占用 CPU 的时间
抢占式调度：
JVM采用的就是抢占式调度，当CPU空闲后，各个线程会开始争抢运行机会，高优先级的线程会更容易抢到运行机会（注意并不是一定抢到）

同步和异步

在我们之前学习常用类库时，我们就提到过同步和异步的概念，现在让我们详细了解一下：

同步（synchronize）-线程排队执行，效率低，但是线程安全
异步（asynchronize）-线程同时执行，效率搞，但是线程不安全

想象一下有一个卖汉堡的汉堡店，同时有几个人一起来买汉堡吃
同步即是几个人排队买汉堡，虽然吃得慢，但是每个人都能安全的吃，如果店家一次能做两个汉堡，则两个人就能一起吃
异步则是围在一起等着吃，当一个人想吃某个汉堡的时候，可能这个汉堡已经被另一个人吃掉了，但是他并不知情，只能打开汉堡盒吃空气，这就是线程不安全（另一个线程篡改了公共的数据，但是执行的线程并不知情）

并发和并行

并发：指两个或多个事件在同一个时间段内发生
并行：指两个或多个事件在同一时刻发生（同时发生，平行发生）

守护线程

之前我们提到过，一个进程通常包括多个线程，至少包括一个线程
当所有的线程全部结束后，一个进程也就自然而然的结束了
线程在其中又可以被分为用户线程和守护线程，守护线程在运行时跟用户线程没有区别，但是如果所有用户线程都结束了，守护线程会自行结束

JVM中一直被我们提到的GC就是一个守护线程，当没有用户线程运行时，GC也会自动结束

多线程编程

学习了那么多概念，现在让我们正式开始学习一下多线程编程，Java中，多线程编程主要通过两种方法实现：

继承Thread类

自行编写一个类并继承Thread类，并且重写其中的run方法，创建该类的对象，调用start方法就能达到多线程的效果，下面让我们看一个简单的例子：

public class multithread {
    public static void main(String[] args) {
        MyThread myThread1 = new MyThread();
        MyThread myThread2 = new MyThread();
        MyThread myThread3 = new MyThread();
        myThread1.start();
        myThread2.start();
        myThread3.start();
    }
}

class MyThread extends Thread{

    @Override
    public void run(){
        for(int i=0; i<5; i++)
            System.out.print(i);
    }
}

在MyThread类中我们重写了run方法，然后在main方法中创建了三个MyThread类的对象，并且一一调用start方法
运行结果可能是：

012340123401234
001234012341234
010123401234234
001234123401234

这正是因为这几个线程拥有相同的优先级，他们不断的抢占运行机会，所以会产生不同的运行结果

实现Runnable接口

实现Runnable接口同样需要重写run方法，但是调用的方法略微有点不同：

MyRunnable myRunnable = new MyRunnable();
Thread thread = new Thread(myRunnable);
thread.start();

或者
new Thread(new MyRunnable()).start();

Thread和Runnable比较：

• Runnable更适用于多个线程执行相同的任务，任务和线程分离，健壮性（robustness）更强
• Runnable可以避免单继承的缺陷，即在实现Runnable后还可以继承其他类
• 线程池仅适用于Runnable

但是Thread也有非常好用的地方，比如：

new MyThread().start();
// 通过匿名类快速执行线程

甚至直接使用内部类创建并执行线程：

new Thread(){
            @Override
            public void run(){
                for(int i=0; i<5; i++)
                    System.out.print(i);
            }
        }.start();

Thread类详解

无论使用哪种多线程编程，都需要使用Thread类，现在让我们详细学习一下Thread类

首先Thread类有四种常用的构造方法：
Thread();
Thread(Runnable target);
Thread(Runnable target, String name);
Thread(String name);

还有一些我们需要关注的方法：
static void sleep(long milis);// 休眠，单位为毫秒
static void sleep(long milis, int nanos);// 后为纳秒
String getName();// 返回线程的名字（构造时传入）
也可以使用Thread.currentThread().getName();获取名字
void setName(String name);// 设置线程名字
void setDaemon(boolean on);// 设置是否为守护线程
long getId();// 返回线程的ID（标识符）

void setPriority(int newPriority);// 设置优先级
int getPriority();// 返回优先级值
优先级即是我们之前提到过的运行优先级，拥有高优先级的线程会有更高的几率抢到运行，在Java中，最高优先级为10，最低为1，默认为5

void stop();
在目前版本的JDK中，stop是一个已经被汰换的方法，因为使用stop会很容易导致死锁，目前结束线程通常在run方法中写明条件，达到条件后自行结束

Thread中还含有一个内部类State，该类用于指明线程的状态
在其中，线程被分为六种状态，New-刚创建还未启动，Runnable-正在执行，Blocked-被阻塞等待其他线程（即排队中），Waiting-无限期等待（休眠），TimeWaiting-计时等待，Terminated-被终止，已退出竞争

线程问题

线程的结束

一个线程是一个独立的执行路径，注意我们刚刚提到过，一个线程想要结束，最好通过条件让它自行结束，而不是使用stop方法

这时我们就需要使用标识符的方法

public class multithread {
    public static void main(String[] args) {
        MyRunnable myRunnable = new MyRunnable();
        Thread t1 = new Thread(myRunnable);
        t1.start();

        t1.interrupt();
    }
}

class MyRunnable implements Runnable{

    @Override
    public void run() {
        for(int i=0; i<10; i++) {
            System.out.print(i);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                //e.printStackTrace();
                System.out.println(1);
            }
        }
    }
}

注意这里的interrupt方法并不是结束这个进程，而是让这个进程执行sleep方法时抛出异常，如果你像这样将异常注释掉，线程也会默默的运行到结束，或者在catch中写上return;，这样线程会立即结束却不报错

线程安全问题

之前我们提到过线程安全问题，现在让我们详细解释一下

同样使用汉堡店的例子，三个人来到汉堡店，但是店家不做汉堡了，目前只有十个汉堡，让我们用抢占式调度完成一下该代码：

public class multithread {
    public static void main(String[] args) {
        MyRunnable myRunnable = new MyRunnable();
        Thread t1 = new Thread(myRunnable);
        Thread t2 = new Thread(myRunnable);
        Thread t3 = new Thread(myRunnable);
        t1.start();
        t2.start();
        t3.start();

    }
}

class MyRunnable implements Runnable{

    int count = 10;
    @Override
    public void run() {
        int i = 0;
        while(count > 0) {
            count--;
            i++;
            System.out.println(Thread.currentThread().getName()+":"+i);
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

从逻辑上来看，整段代码没有任何问题，但是当我们运行后，却发现结果：

Thread-1:4
Thread-0:4
Thread-2:5

Process finished with exit code 0

三个人总共竟然买到了13个汉堡，这就是线程不安全的问题，如果一个线程在另一个线程将count减到0之前进行了判断，那么该线程仍然会继续执行，最终导致count变成了负数

处理线程安全问题

为了解决线程安全问题，Java提出了多种解决方案，他们都采用了加锁的机制，即在一个线程执行时通过锁定其他线程，使整体执行变得同步

同步代码块

在第八讲中我们就提到过同步代码块的概念，现在让我们学习一下同步代码块

同步代码块通过如下方式定义

        synchronized (对象名){
            
        }

让我们用同步代码块更新一下原先的汉堡店代码：

class MyRunnable implements Runnable{

    int count = 10;
    Object obj = new Object();

    @Override
    public void run() {
        int i = 0;
        while(true) {
            synchronized (obj) {// 普通的公共对象
                if(count > 0) {
                    count--;
                    i++;
                    System.out.println(Thread.currentThread().getName() + ":" + i);
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                } else
                    break;// 不然无法结束进程
            }
        }
    }

注意其中的obj只是一个公共的Object对象（必须是公共的）

使用这种方法，能够保证三个顾客总共只能买到10个汉堡，但是同步代码块也有一些问题：

• 效率大幅降低
• 必须为了同步更改代码结构
• 很容易出现一个线程连续运行的情况

同步方法

同步方法即把synchronize关键字修饰到方法上，此时MyRunnable方法就需要改为：

class MyRunnable implements Runnable{

    int count = 10;

    @Override
    public void run() {
        while(true)
            if(!sale())
                break;
    }

    public synchronized boolean sale(){
            if(count > 0) {
                count--;
                System.out.println(Thread.currentThread().getName() + "购买了一个汉堡");
                System.out.println("汉堡余量："+count);
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                return true;
            }
            return false;
        }
}

相较于同步代码块，同步方法的锁更加不精密

显式锁

在之前我们使用的同步代码块和同步方法都是隐式锁，可以发现整体代码中没有提到过锁，加锁和开锁，而我们现在将要直接使用锁Lock类

Lock lock1 = new ReentrantLock();// 创建锁
lock1.lock();// 加锁
lock1.unlock();// 解锁

它的使用也很直接，可以直接把锁套用在同步代码块的两个大括号处

    public void run() {
        int i = 0;
        while(true) {
            lock1.lock();
                if(count > 0) {
                    count--;
                    i++;
                    System.out.println(Thread.currentThread().getName() + ":" + i);
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    
                } else
                    break;
            lock1.unlock();
            }
    }

为了能让程序正常结束我们还需要在else中添加解锁操作

                else {
                    lock1.unlock();
                    break;
                }

显式锁和隐式锁各有所长，比如显式锁是通过API完成加锁效果的，而隐式锁则是在JVM层面的；显式锁可以对锁进行分组，达到精确唤醒的目的，也可以自己决定是不是公平锁，还可以自行中断，但是Java官方明显还是更偏向于隐式锁，不仅更新不断，官方帮助文档里的描述也是写的满满当当，生怕你看不懂。

公平锁

公平锁的概念即为一个锁解开时，其他线程抢夺是否公平

如果是公平的，那么在锁还没解开是，等待锁解开的线程就开始排队等候，一个个的使用
而不公平的则是锁一旦解开，所有的线程都会同时抢夺该锁

隐式锁和显式锁默认都是非公平的，但是在显式锁的创建时，可以传入一个true参数，来创建一个公平锁

死锁

死锁的概念很简单，正如死结一样，无法通过正常手段解开，一个死锁的产生可以很复杂，也可以很简单（至少需要两个锁）

死锁的概念可以通过一个简单的例子来阐明：一条窄道上有两个英国绅士，绅士们很讲究绅士风度，所以当遇到迎面而来的人时，他们都会让出路来让对面先走

很明显，会产生的结果是，两位绅士都会接连后退，等待对方先过，最后谁也过不去，这就相当于产生了死锁

线程池

如果并发的线程数量很多，并且每个线程都是执行一个时间很短的任务就结束了，这样频繁创建线程 就会大大降低系统的效率，因为频繁创建线程和销毁线程需要时间.
线程池就是一个容纳多个线程的容器，在系统启动时即创建大量空闲的线程，程序将一个任务传给线程池，线程池就会启动一条线程来执行这个任务，执行结束以后，该线程并不会死亡，而是再次返回线程池中成为空闲状态，等待执行下一个任务
池中的线程可以反复使用，省去了频繁创建线程对象的操作，降低了资源的消耗，提高了相应速度，还提高了线程的可管理性

Java中有四种线程池，而四种线程池都通过ExecutorServie来实现，让我们一一学习：

缓存线程池

缓存线程池执行流程为：

1. 判断线程池是否存在空闲线程
2. 存在则使用
3. 不存在,则创建线程并放入线程池, 然后使用

缓存线程池的长度可以按需不断的延申，没有长度的限制

构建缓存线程池的方法是

ExecutorService service = Executors.newCachedThreadPool();
service.execute(new MyRunnable());

定长线程池

定长线程池执行流程为：

1. 判断线程池是否存在空闲线程
2. 存在则使用
3. 不存在空闲线程,且线程池未满的情况下,则创建线程 并放入线程池, 然后使用
4. 不存在空闲线程,且线程池已满的情况下,则等待线程池存在空闲线程

定长线程池就相当于长度固定的缓存线程池

定长线程池构建方法是：

ExecutorService service = Executors.newFixedThreadPool(2); // 传入长度
service.execute(new MyRunnable());

单线程线程池

单线程线程池执行流程为：

1. 判断线程池中的唯一线程是否空闲
2. 空闲则使用
3. 不空闲,则等待该线程空闲后使用

单线程线程池就相当于定长为1的定长线程池

单线程线程池构建方法为：
ExecutorService service = Executors.newSingleThreadExecutor();
service.execute(new MyRunnable());

周期性任务定长线程池

周期性任务定长线程池执行流程为：

1. 判断线程池是否存在空闲线程
2. 存在则使用
3. 不存在空闲线程,且线程池未满的情况下,则创建线程并放入线程池, 然后使用
4. 不存在空闲线程,且线程池已满的情况下,则等待线程池存在空闲线程

周期性任务定长线程池根据定时和周期有两种构建方法：

ScheduledExecutorService service = Executors.newScheduledThreadPool(2);// 长度

// 定时执行
service.schedule(new MyRunnable() , 5,TimeUnit.SECONDS);
// 其中第二个参数为时长数字，第三个参数为时长数字的单位，上面代码结果即该线程五秒钟执行一次

// 周期执行
service.scheduleAtFixedRate(new Runnable() ，5,1,TimeUnit.SECONDS);
// 其中二参为第一次执行在多久以后，三参四参同上，上面代码结构即5秒之后每一秒执行一次

多线程通信

多线程通信需要了解四个在Object类中的方法：

void notify();// 随机唤醒某线程
void notifyAll();// 唤醒所有线程
void wait();// 等待，不唤醒则一直等
void wait(long timeoutMilis);// 等待，指定时间

多线程通信中有一个很经典的问题，叫做生产者与消费者问题，也叫做PV操作问题（其中涉及到信号量的问题，但是暂时不用理解），设想刚刚的汉堡店，汉堡店做一个，顾客才能买来吃

让我们用代码来实现一下：

public class multithread {
    public static void main(String[] args) {

        ProcessSynchronization ps = new ProcessSynchronization();
        new Thread(new Producer(ps)).start();
        new Thread(new Producer(ps)).start();
        new Thread(new Producer(ps)).start();

        new Thread(new Consumer(ps)).start();
        new Thread(new Consumer(ps)).start();
        new Thread(new Consumer(ps)).start();
    }
}

//生产者类
class Producer implements Runnable{
    ProcessSynchronization ps = new ProcessSynchronization();
    Producer(ProcessSynchronization ps){
        this.ps = ps;
    }
    public void run(){
        while(true){
            try {
                this.ps.produce();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

//消费者类
class Consumer implements Runnable{
    ProcessSynchronization ps = new ProcessSynchronization();
    Consumer(ProcessSynchronization ps){
        this.ps = ps;
    }
    public void run(){
        while(true){
            try {
                this.ps.consume();
            }catch(Exception e) {
                e.printStackTrace();
            }
        }
    }
}

class ProcessSynchronization{
    int count = 0;

    public synchronized void produce() throws InterruptedException {
        Thread.sleep(500);
        if (count<10) {
            count++;
            System.out.println("制造了一个小汉堡，现在余量：" + count);
            super.notifyAll();

        } else
            super.wait();
    }

    public synchronized void consume() throws InterruptedException {
        Thread.sleep(500);
        if(count>0) {
            count--;
            System.out.println("吃掉了一个小汉堡，现在余量：" + count);
            super.notifyAll();
        } else
            super.wait();
    }
}

这段代码运行后，就会一直有新的小汉堡被制造，也会一直有顾客吃掉小汉堡

本段代码的难度比较大，如果实在不能理解可以暂时搁置

Callable接口和Lambda

在主流的两种线程创建方法之外，还可以通过实现Callable接口创建线程

Callable的使用比较复杂：

class XXX implements Callable<T> {

    @Override
    public <T> call() throws Exception {
        return T;
    }
}// 首先创建类实现，其中T为泛型


        MyCallable myCallable = new MyCallable();
        FutureTask<String> futureTask = new FutureTask<String>(myCallable);// 这里的String就是类中泛型
        Thread thread = new Thread(futureTask);
        thread.start();// 一步步构建，最终还是使用Thread类

可以使用futureTask.get();方法或者isDone();方法，等待该对象的线程完成之后再继续执行下去

Callable并不是很经常使用，但是在早期Runnable接口功能不完善时经常被使用，学习该接口有助于阅读源码

学完Runnable和Callable后你可能感觉，创建一个线程也太麻烦了，完整的创建需要创建两三个对象，其实线程中的输出语句就一句，但是为了执行该语句要写很多的结构代码

Java为了提高效率，提出了Lambda表示式，可以省略所有无实际意义的结构代码，很大幅的节约代码量，Lambda表达式通过如下方式使用

Thread thread = new Thread(() -> System.out.println(1));
thread.start();

这一行代码就相当于构建了线程代码，创建了线程并执行，而Lambda表达式其实也可以应用于任何情况，并不是线程的专属，使用Lambda表达式其实就是省略了一个创建内部类的内容

在编程中通常不提倡大量使用Lambda表达式，因为其会对debug的过程带来很多麻烦，虽然整体看起来简洁，但实际上让后续的更改更加麻烦

转载请注明出处