多线程学习

1.多线程介绍

2.并发和并行

3.多线程的实现方式

3.1通过继承Thread类实现

3.2通过实现Runable接口+使用Thread类实现

3.3通过实现Callable<>接口+使用Futuretask<>类+使用Thread类实现

3.4总结

4.在线程中常见的一些成员方法（导航）

5.线程的生命周期

6.线程安全问题（导航）

7.等待唤醒机制的两种实现-生产者与消费者、阻塞队列

1.多线程介绍

什么是多线程

有了多线程，我们就可以让程序同时做多件事情。

多线程的作用

充分利用程序运行的等待时间，让CPU在多个线程之间进行切换，从而提高程序的运行效率。

多线程的用途

只要是想让多个程序同时运行，就都会用到多线程。

以游戏为例，游戏在加载页面不仅会加载资源，还需要加载背景、检查版本等，如果没有多线程，那就需要先加载资源，然后再进行其他操作，如果需要加载大量资源，那么需要等待很长时间才会进入下一步操作。如果我们引入多线程，充分利用这些等待时间，让其他线程在加载资源的同时执行其他程序，比如检查版本加载背景，就可以缩短加载页面的时间，提高效率。

多线程其实就和小学的一种题类似，小明烧水需要2min，刷牙需要2min，使用微波炉热饭需要1min，问小明做完这些事情最少需要多长时间。如果一件一件的进行总共需要5min，就相当于是单线程，一条线程执行完一个程序后再执行另一个程序；如果小明在刷牙的同时进行烧水和热饭的操作，那总共只需要2min便会完成，这就相当于多线程，虽然也是每条线程只执行一个程序，但它们是同时进行的，充分利用了等待的时间，提高了效率。

2.并发和并行

并发

并发是指多个指令在单核CPU上交替执行。

并行

并行是指多个指令在多核CPU或多个CPU上同时执行。

3.多线程的实现方式

3.1通过继承Thread类实现

//自己的线程类，继承Thread类
public class MyThread extends Thread{

    //重写run方法
    @Override
    public void run() {
        for(int i=0;i<100;i++)
        System.out.println(getName()+"hello");
    }
}

//多线程实现
public static void main(String[] args) {
        //创建两个线程对象
        MyThread mt1=new MyThread();
        MyThread mt2=new MyThread();

        //给两个线程分别命名，用于在输出结果时区分
        mt1.setName("thread1");
        mt2.setName("thread2");

        //开启两个线程，调用start方法后会自动找到run方法并执行
        mt1.start();
        mt2.start();
    }

运行结果：

可以看到调用start开启两个线程后，线程是并发执行的，这是因为线程运行时没有加锁，没有保证原子性造成的，详细探讨可以参照另一篇博客JVM学习-JMM-CSDN博客中的2.1保证原子性的部分。

那如果通过对象直接调用run方法呢？

这就是单纯的调用一个类的方法了，并没有启动两个线程，而是按照顺序先通过mt1调用run方法，再通过mt2调用run方法，运行结果就是先执行100次打印thread1hello，再执行100次打印thread2hello。所以要启动两个线程就要调用start方法。

3.2通过实现Runable接口+使用Thread类实现

//通过实现Runnable接口来写任务类
public class MyRun implements Runnable{

    //重写run方法
    @Override
    public void run() {

        //获取当前运行的线程
        Thread t = Thread.currentThread();

        for(int i=0;i<100;i++) {
            System.out.println(t.getName() + "hello");

            //或者直接链式调用
            //System.out.println(Thread.currentThread().getName() + "hello");
        }


    }
}

//实现多线程
public class Main {
    public static void main(String[] args) {

        //r相当于是要执行的任务
        Runnable r=new MyRun();
        
        //这里通过创建Thread类的对象来创建两个线程，并将任务告诉给这两个线程
        Thread t1=new Thread(r);
        Thread t2=new Thread(r);

        //给两个线程命名，用于打印时区分
        t1.setName("thread1");
        t2.setName("thread2");

        //启动两个线程
        t1.start();
        t2.start();
    }
}

由上面的代码可见，与第一种方式不同，需要先调用Thread类的静态方法currentThread来获取到当前的线程才能使用getName方法获取到线程名，这是因为getName方法是Thread类的一个方法，Runnable则是另一个接口，和Thread类无关。要注意的是获取当前线程的那一行代码不能写到run方法外面，也就是下面这种情况：

public class MyRun implements Runnable{

    Thread t = Thread.currentThread();

    @Override
    public void run() {
        Thread t = Thread.currentThread();
        for(int i=0;i<100;i++) {
            System.out.println(t.getName() + "hello");
        }
    }
}

如果获取当前进程的这行代码放到了run方法外面，则会获取到main线程。这是因为这么写就是把t作为了MyThread的一个成员变量并进行初始化，当我们在main函数中执行Runnable r=new MyThread()创建实现类对象时，就会执行MyThread类的初始化，此时正在运行的线程就是main线程，因此t就被初始化为了main线程，后面虽然启动了t1和t2两个线程，但由于没有再次获取当前线程的操作，t的值还是main线程，所以都会输出mainhello。

在上面的代码中还注意到，在main函数中我们是先实现的Runnable接口，然后是通过Thread创建的两个线程的实例，这是因为Runnable接口本身并不是用来创建线程的，而是相当于规定了一项任务，后面的new Thread(r)则是在创建线程实例的同时把这项任务赋给这个线程，告诉它要执行什么任务。

运行结果：

由于没有加锁，所以这两个线程也是并发执行的。

3.3通过实现Callable<>接口+使用Futuretask<>类+使用Thread类实现

以上两种方式都不能获取到线程运行的结果，因为无论是Thread类还是Runnable接口它们的run方法都是void的，而使用这种方式则可以获取到线程运行的结果。

//实现Callable接口，这是一个泛型接口，里面的类型就是返回值的类型
//和Runnable类似，Callable的实现类也是相当于一个任务类
public class MyCall implements Callable<String> {

    //当规定了返回值类型后再重写call方法，会自动设置重写的call方法的返回值类型
    @Override
    public String call() throws Exception {

        return "朋友们大家好，这里是MC"+Thread.currentThread().getName()+"!";
    }
}

//实现
public class Main {

    //在下面调用get时会报出异常，直接抛出即可
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        
        //实现Callable接口
        Callable<String> mc=new MyCall();

        //通过创建FutureTask<>对象来管理返回的值
        FutureTask<String> ft1=new FutureTask<>(mc);
        FutureTask<String> ft2=new FutureTask<>(mc);

        //还是用Thread来创建两个线程实例，不同的是将FutureTask<>对象赋给这两个线程实例
        Thread t1=new Thread(ft1);
        Thread t2=new Thread(ft2);

        t1.setName("子龙");
        t2.setName("曹操");

        t1.start();
        t2.start();

        //获取两个线程运行的结果并打印，因为FutureTask是管理返回值的，所以用它的实例获取
        String result1=ft1.get();
        String result2=ft2.get();
        System.out.println(result1);
        System.out.println(result2);
    }
}

运行结果：

3.4总结

4.在线程中常见的一些成员方法（导航）

详见另一篇博客多线程中常用的一些方法介绍-CSDN博客。

5.线程的生命周期

一个线程的生命周期有五种状态：新建、就绪、运行、阻塞、死亡。

新建即线程实例被成功创建；就绪为线程实例执行了start方法开启线程，此时这个线程处于正在竞争CPU的状态，有执行run方法中的程序的资格，但由于还没有抢到，所以没有执行权（相当于竞选一个职位，能够竞选说明有担任这个职位的资格，但还没有竞选上说明还没有担任这个职位的权利）；运行则是线程成功抢到了CPU，正在执行run方法中的代码；阻塞则是通过调用静态方法sleep或使用其他阻塞方式让线程暂时挂起；死亡则是线程运行结束，变成了垃圾等待被回收掉。

补充：当线程在运行态时，也有可能被其他线程夺走CPU的占用权，此时一旦CPU被夺走那么该线程就会又进入就绪态，重新竞争CPU。当线程阻塞状态结束后，线程不会立刻继续执行代码，因为当该线程进入阻塞态时它所占用的CPU会被释放掉，需要重新进入就绪态竞争CPU。

但是在java中线程的状态有6种：新建状态(new)、就绪状态(runnable)、阻塞状态(blocked)、等待状态(waiting)、计时等待状态(timed_waiting)、结束状态(terminated)。

其中，生命周期中的阻塞就包括阻塞状态、等待状态和计时等待状态，当需要加锁但还没有获取到锁时处于阻塞状态，当调用wait方法时处于等待状态，当调用sleep方法时则处于计时等待状态。java中线程的状态里没有定义运行状态，只有就绪态，这是因为当线程成功抢到CPU之后线程就被交给操作系统管了，既然此时线程不归java管，那也就没有必要再定义运行状态了，下面的运行状态是为了更好理解加上的。

6.线程安全问题（导航）

详见另一篇博客多线程学习-线程安全-CSDN博客。

7.等待唤醒机制的两种实现-生产者与消费者、阻塞队列

7.1生产者与消费者方式

生产者和消费者是一种经典的多线程协同工作模式，以厨师（生产者）和顾客（消费者）为例：

厨师和顾客中间有张桌子，厨师会将做好的饭放到桌子上，顾客需要从桌子上拿到饭并吃掉。初始状态下厨师还没有做饭，桌子上是空的，顾客也还没有开始吃饭。

对于厨师而言，他要做以下五种事情：

检查桌子上是否还有饭
如果桌子上有饭则等待顾客吃完
如果没有，则开始做饭
将做好的饭放到桌子上
通知顾客来吃

对于顾客而言，他要做以下四种事情：

检查桌子上是否有饭
如果没有饭则等待厨师做好饭
如果有饭则开始吃饭
吃完饭后通知厨师继续开始做饭

如果用代码实现上面的通知和等待，则要用到下面三种方法：

其中通知经常是用notifyAll，因为如果线程有很多，使用notify仅能随机唤醒一个线程，那可能要唤醒好多次才能唤醒所需要的线程，而notifyAll能唤醒所有线程，自然也会唤醒所需要的线程，所以一般使用notifyAll用来通知。

用代码实现上面的顾客、厨师以及桌子：

//桌子Table
public class Table {

    //桌子上是否有饭的信号，0代表没有饭，1代表有饭
    public static int flag=0;

    //顾客吃饭的目标
    public static int count=3;

    //顾客和厨师共享的锁，因为对于共享资源加的锁必须是唯一的
    public static Object object=new Object();

}

//顾客Customer
public class Customer extends Thread{

    @Override
    public void run() {
        synchronized (Table.object){
            while (true){
                //先检查自己是否已经达成了吃饭的目标
                //如果已经达到了就break
                //如果没有则进行接下来的操作
                if(Table.count==0){
                    System.out.println("顾客达成了目标，结账走人了。");
                    break;
                }else{
                    //1.先检查桌子上有没有饭
                    //2.如果有则执行吃饭操作
                    //3.如果没有则等待厨师做饭
                    if(Table.flag==1){
                        System.out.println("顾客正在吃饭中...");
                        //将饭从桌子上拿走
                        Table.flag=0;
                        //吃了这碗饭后离目标又近了一步
                        Table.count--;
                        System.out.println("饭吃完了，还剩"+Table.count+"碗饭没吃，正在通知厨师做饭...");
                        //4.吃完饭后通知厨师继续做饭
                        Table.object.notifyAll();
                    }else {
                        try {
                            Table.object.wait();
                        } catch (InterruptedException e) {
                            throw new RuntimeException(e);
                        }
                    }
                }
            }
        }
    }
}

//厨师Cook
public class Cook extends Thread{
    @Override
    public void run() {

        synchronized (Table.object) {
            while (true) {

                //先判断是否顾客已经达成吃饭的目标
                //如果吃饭的目标达成则退出循环
                //如果没有则继续接下来的操作
                if(Table.count==0){
                    System.out.println("厨师了解到顾客达成了目标，结束做饭。");
                    break;
                }else{
                    //1.先检查桌子上有没有饭
                    //2.如果没有则开始做饭
                    //3.如果有则进入等待
                    if(Table.flag==0){
                        System.out.println("厨师正在做饭中...");
                        //4.饭做好了，将饭放到桌子上
                        Table.flag=1;
                        //5.通知顾客来吃
                        //唤醒所有绑定到这个锁的线程
                        System.out.println("饭做好了，已放到桌子上，正在通知顾客来吃...");
                        Table.object.notifyAll();
                    }else{
                        try {
                            //绑定加上这个共享锁的线程，并让该线程进入等待状态
                            Table.object.wait();
                        } catch (InterruptedException e) {
                            throw new RuntimeException(e);
                        }
                    }
                }

            }
        }
    }
}


//模拟顾客和厨师的过程
public class Main {
    public static void main(String[] args) {

        Thread t1=new Customer();
        Thread t2=new Cook();

        t1.start();
        t2.start();
    }
}

运行结果：

首先要注意的是顾客和厨师是两个线程类而不是两个普通的类。然后就是Table相当于管理共享的变量，共享的变量要设置为静态的。最后就是在调用wait和notifyAll时要使用共享锁来调用，用共享锁调用wait会将这个锁和添加这个锁的线程进行绑定，在用这个共享锁调用notifyAll时会唤醒绑定这个锁的所有线程，从而在唤醒时不会通知其他无关的线程。

7.2阻塞队列方式

阻塞队列就相当于替换掉了中间的桌子，顾客吃饭时从阻塞队列中拿，厨师做好饭后将饭放到阻塞队列中；阻塞队列由于是一个队列，会遵循先入先出。桌子只能放一碗饭，而阻塞队列可以放多碗饭；并且阻塞队列的底层已经加锁了，不需要我们手动加锁。

阻塞队列有两种，一种是ArrayBlockingQueue<类型>，底层是基于数组的，所以这种阻塞队列的空间是有限的；另一种是LinkedBlockingQueue<类型>，底层是基于链表的，所以这种阻塞队列的空间理论上是无限的，但实际上它的最大长度不能超过int的范围。

用阻塞队列实现起来很简单，生产者只需要向里面放东西，也就是调用put方法，消费者只需要从里面取东西就行了，也就是调用take方法。下面是put和take的源码：

put:

take:

下面用阻塞队列来实现顾客和厨师：

//厨师
public class Cook extends Thread{

    ArrayBlockingQueue<String> queue;
    public Cook(ArrayBlockingQueue<String> queue){
        this.queue=queue;
    }

    @Override
    public void run() {
        while (true){
            try {
                queue.put("饭");
                System.out.println("厨师做好了一碗饭");
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    }
}

//顾客
public class Customer extends Thread{

    ArrayBlockingQueue<String> queue;

    public Customer(ArrayBlockingQueue<String> queue){
        this.queue=queue;
    }

    @Override
    public void run() {
        while (true){
            try {
                String food=queue.take();
                System.out.println("顾客拿走了一碗饭");
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    }
}

//模拟顾客和厨师的过程
public class Main {
    public static void main(String[] args) {

        //由于阻塞队列只能有一个，所以阻塞队列不能在Cook或Customer中创建，直接从main中创建即可
        ArrayBlockingQueue<String> queue=new ArrayBlockingQueue<String>(1);

        //将这个阻塞队列分别传递给Cook和Customer，保证两者使用的是同一个阻塞队列
        Thread t1=new Cook(queue);
        Thread t2=new Customer(queue);

        t1.start();
        t2.start();

    }
}

运行结果：

在上面的代码中，我们给阻塞队列设置的空间为1，那应该输出的是厨师放一碗饭顾客拿一碗饭才对，而这里却出现了厨师连放多次饭以及顾客连取多次饭的情况，这难道是取和放的时候出现了问题吗？

其实并不是，因为put和take的底层已经进行了加锁和解锁的操作，所以这两个过程是没有问题的，问题出在后面的输出语句。虽然put和take进行了加锁，但是输出的操作并没有加锁，这很可能出现乱输出的情况，毕竟线程的运行完全随机，永远不知道下一秒是哪个线程在占用CPU。不过虽然输出操作会出现问题，但这对实现顾客和厨师的过程并不会产生影响，因为输出操作只是用来给自己看的，实际运行过程不出错即可。