一. 并发编程线程基础

一.  线程和进程

1.  什么是进程

进程是代码在数据集合上的一次运行活动，是系统除CPU外进行资源分配和调度的基本单位（CPU资源是直接分配到线程的，线程是CPU分配的基本单位），进程包括线程。

2.  什么是线程

线程是进程的一个实体，一个执行路径，一个进程中至少有一个线程，进程中的多个线程共享进程的资源

3.  在Java中，启动main函数就相当于启动了一个JVM进程，main函数所在的线程称为主线程

4.  一个进程中的线程共享该进程的堆和方法区的资源，堆是一个进程中最大的一块内存，主要存放使用new操作创建的对象实例。方法区用来存放JVM加载的类、常量、及静态变量等信息。

5.  每个线程有自己的程序计数器和栈区域，程序计数器用于记录当前线程要执行的指令地址，栈用来存储该线程的局部变量，该局部变量无法被其他线程访问。

二.  线程创建与运行

创建线程一共有三种方式

方式一：继承Thread类

public class ThreadTest {
    public static class MyThread extends Thread{
        @Override
        public void run() {
            System.out.println("I am a child thread");
        }
    }

    public static void main(String[] args) {
        //1.  创建线程
        MyThread myThread = new MyThread();
        //2.  启动线程
        myThread.start();
    }
}

需要注意的是，当第一步创建了Thread对象后，线程并没有被执行，直到调用了start方法，该线程才被启动执行，调用start方法后，该线程处于就绪状态（已经获得了除CPU外其他资源），当该线程获取了CPU资源后才真正处于运行状态，执行完run方法，线程处于终止状态。

方式二：实现Runnable接口

public class ThreadTest {

    public static void main(String[] args) {
        //1.  创建线程
        RunnableTask task = new RunnableTask();
        //2.  启动线程
        new Thread(task).start();
        new Thread(task).start();
    }

    public static class RunnableTask implements Runnable {

        @Override
        public void run() {
            System.out.println("I am a child thread");
        }
    }
}

前两种方式任务都没有返回值，可以FutureTask的方式来获取任务的返回值

方式三：FutureTask

public class ThreadTest {

    public static void main(String[] args) {
        //1. 创建异步任务：使用FutrueTask对象作为任务，创建了一个进程
        FutureTask<String> futureTask = new FutureTask<>(new CallerTask());
        //2. 启动线程
        new Thread(futureTask).start();
        try {
        //3. 等待任务执行完毕，并返回结果
            String result = futureTask.get();
            System.out.println(result);//输出：zhangjia
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    //创建任务类，类似Runnable
    public static class CallerTask implements Callable<String> {

        @Override
        public String call() throws Exception {
            return "ZhangJia";
        }
    }
}

三种方式的优缺点：

• 继承Thread类

• 优点：在run()方法中可以直接使用this获取当前线程，方便传参，可以在子类里添加成员变量，通过set方法设置参数或者通过构造方法传递

• 缺点：java不支持多继承，任务和代码没有分离，当多个线程执行一样的任务时需要多份任务代码

• 实现Runnable接口

• 优点：可以继承其他类，多个线程可以共用一份代码

• 缺点：没有返回值，只能使用主线程里面被声明为final的变量

• FutureTask：

• 优点：可以拿到任务的返回值

三.  线程的通知与等待

在讨论线程的通知与等待之前，想起之前面试的时候，面试官一直在问各种多线程相关的问题，其中有一个问题印象深刻：你用过Object类中的哪些方法？菜鸡的我只说出了equals，toString，getClass，hashCode之类常见的方法，其实面试官想要的答案是wait、notify、notifyAll，接下来我们就从这几个函数入手，来讲解一下线程的通知与等待

1. wait()函数

一个线程可以通过调用一个共享变量的wait(）方法将自己挂起，直到发生以下事情之一才返回：

• 其他线程调用了该共享对象的notify() 方法或者notifyAll() 方法

• 其他线程（或者该线程自己调用interrupt）调用了该线程的interrupt()方法导致该线程抛出InterruptedException异常返回

另外如果调用wait方法的线程事先没有获取该独享的监视器锁，那么会抛出IllegalMonitorStateException异常，可以通过下面两种方法来获取该对象的监视器锁来避免该异常

//方法一
synchronized (共享变量){
    //防止虚假唤醒
    while(条件不满足) {
        共享变量.wait(); 
    }
}
//方法二
synchronized void add(int a, int b){
    //doSomething
}

需要注意的是，如果一个线程持有多个共享变量的锁，那么调用wait方法后只会释放当前共享变量的锁，举个例子来理解一下这句话：

package io.zhangjia.threads.test.Test;

import org.apache.ibatis.annotations.Param;

/**
 * @Author : ZhangJia
 * @Date : 2019/12/4 21:45
 * @Description : 
 */
public class Test2 {
    private static volatile Object a = new Object();
    //volatile关键字能够保证代码的有序性
    private static volatile Object b = new Object();

    public static void main(String[] args) {
        new Thread(new ThreadA()).start();
        new Thread(new ThreadB()).start();
    }

    public static class ThreadA implements Runnable {

        @Override
        public void run() {
            try {
                synchronized (a) {
                    System.out.println("线程A获得了共享变量a的监视器锁");

                    synchronized (b) {
                        System.out.println("线程A获得了共享变量b的监视器锁");

                        System.out.println("线程A阻塞，并释放获取到的共享变量a的锁");
                        a.wait();

                    }
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }


    public static class ThreadB implements Runnable {

        @Override
        public void run() {
            try {
                Thread.sleep(1000);
                synchronized (a) {
                    System.out.println("线程B获取到共享变量a的锁啦");
                    System.out.println("我是线程B，我一直在尝试获取共享变量b的锁，就是没获取到");

                    synchronized (b) {
                        System.out.println("线程B获取到共享变量b的锁啦");
                        System.out.println("线程B阻塞，并释放获取到的共享变量a的锁");
                        a.wait();
                    }
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

        }
    }
}
输出：
线程A获得了共享变量a的监视器锁
线程A获得了共享变量b的监视器锁
线程A阻塞，并释放获取到的共享变量a的锁
线程B获取到共享变量a的锁啦
我是线程B，我一直在尝试获取共享变量b的锁，就是没获取到

上例中，线程A一开始拥有变量a和变量b的锁，通过调用a的wait方法后，只有a的锁被释放了，b的锁并没有被释放掉，所以线程B无法获取到b变量的锁。

2. wait(long tiemout)函数

timeout意为超时参数，单位是毫秒（ms)，比如wait(1000)意为在1秒内如果没被其他线程调用notify()或者notifyAll()方法唤醒，还是会因为超时返回。

3.  wait(long timeout,int nanos)函数

timeout单位是毫秒，nanos单位是纳秒，1毫秒 = 1000 微秒 = 1000 000 纳秒 ，该函数的主要作用是为了能够更加精确的控制等待时间

4. notify()函数

该方法用户唤醒被挂起的线程。注意阻塞和挂起的区别，阻塞是被动的，挂起是主动的。

另外如果一个共享变量上有多个线程被挂起了，那么具体唤醒哪个等待线程是随机的，被唤醒的线程依旧需要先获取共享对象的锁才可以返回。

notify函数和wait函数类似，如果当前线程没有获取到共享变量的监视器锁就调用notify方法，也会抛出IllegalMonitorStateException异常。

5. notifyAll()函数

当一个线程通过共享变量调用notifyAll()函数时，该方法会唤醒在此之前所有通过该共享变量调用了wait系列函数的线程。

举一个例子来理解：

package io.zhangjia.threads.test.Test;

/**
 * @Author : ZhangJia
 * @Date : 2019/12/15 19:30
 * @Description : 
 */
public class NotifyTest {
    private static volatile Object a = new Object();

    public static void main(String[] args) throws InterruptedException {
        Thread threadA = new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (a) {
                    System.out.println("线程A获得了共享变量a的监视器锁");
                    try {
                        System.out.println("线程A开始等待");
                        a.wait();
                        System.out.println("线程A结束等待");
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                }
            }
        });

        Thread threadB = new Thread(new Runnable() {
            @Override
            public void run() {
               synchronized (a) {
                   System.out.println("线程B获得了共享变量a的监视器锁");
                   try {
                       System.out.println("线程B开始等待");
                       a.wait();
                       System.out.println("线程B结束等待");
                   } catch (InterruptedException e) {
                       e.printStackTrace();
                   }
               }
            }
        });

        Thread threadC = new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (a) {
                    System.out.println("线程c开始唤醒");
                    a.notify();
                }
            }
        });

        threadA.start();
        threadB.start();
        Thread.sleep(1000); //主线程先休眠1s，为了让线程A和线程B都执行完wait方法后再调线程c的notify方法
        threadC.start();

        //等待线程结束
        threadA.join();
        threadB.join();
        threadC.join();
        System.out.println("主线程结束");
    }
}
//输出：
线程A获得了共享变量a的监视器锁
线程A开始等待
线程B获得了共享变量a的监视器锁
线程B开始等待
线程c开始唤醒
线程A结束等待

通过上例可以看到，当线程A和线程B分别通过a变量调用wait方法将自身挂起后，线程c调用notify方法，随机唤醒了一个线程，如果将线程c中的 a.notify();修改为 a.notifyAll();则结果为：

线程A获得了共享变量a的监视器锁
线程A开始等待
线程B获得了共享变量a的监视器锁
线程B开始等待
线程c开始唤醒
线程B结束等待
线程A结束等待
主线程结束

四.  等待线程执行终止的Join方法

未完待续…

最近一次更新：19.12.15