40个问题让你快速掌握Java多线程的精髓

摘要：多线程能够理解为在同一个程序中可以同时运行多个不一样的线程来执行不一样的任务，这些线程能够同时利用CPU的多个核心运行。

本文分享自华为云社区《对Java多线程的用法感到一头乱麻?40个问题让你快速掌握多线程的精髓》，原文做者：breakDraw 。html

多线程能够理解为在同一个程序中可以同时运行多个不一样的线程来执行不一样的任务，这些线程能够同时利用CPU的多个核心运行。多线程编程可以最大限度的利用CPU的资源。本文将经过如下几个方向为你们讲解多线程的用法。java

1.Thread类基础
2.synchronized关键字
3.其余的同步工具

CountDownLatch
FutureTask
Semaphore
CyclicBarrier
Exchanger
原子类AtomicXXX

4.线程池
5.Thread状态转换
6.Volatile
7.线程群组

1、Thread类基础

Q： Thread的deprecated过时方法是哪3个？做用是啥
A：编程

stop()，终止线程的执行。
suspend()，暂停线程执行。
resume()，恢复线程执行。

Q：废弃stop的缘由是啥？
A：调用stop时，会直接终止线程并释放线程上已锁定的锁，线程内部没法感知，而且不会作线程内的catch操做！即线程内部不会处理stop后的烂摊子。若是其余线程等在等着上面的锁去取数据，那么拿到的多是1个半成品。数组

变成题目的话应该是下面这样，问会输出什么？缓存

public class Test {

    public static void main(String[] args) throws InterruptedException {

        System.out.println("start");
        Thread thread = new MyThread();
        thread.start();
        Thread.sleep(1000);
        thread.stop();
        // thread.interrupt();

    }
}

class MyThread extends Thread {
    public void run() {
        try {
            System.out.println("run");
            Thread.sleep(5000);
        } catch (Exception e) {
            //处理烂摊子,清理资源
            System.out.println("clear resource!");
        }
    }
}

答案是输出 start和run，可是不会输出clear resource安全

Q： stop的替代方法是什么？
A： interrupt()。
调用thread.interrupt()终止时，不会直接释放锁，可经过调用interrupt()或者捕捉sleep产生的中断异常，来判断是否被终止，并处理烂摊子。多线程

上题把thread.stop()改为thread.interrupt()，在Thread.sleep()过程当中就会抛出interrupException（注意，InterrupExcetpion是sleep抛出的）所以就会输出clear resource。若是没有作sleep操做，能够用isInterrupted()来判断本身这个线程是否被终止了，来作清理。并发

另外注意一下interrupt和isInterrupted的区别：异步

Q： suspend/resume的废弃缘由是什么？
A：：调用suspend不会释放锁。
若是线程A暂停后，他的resume是由线程B来调用的，可是线程B又依赖A里的某个锁，那么就死锁了。例以下面这个例子，就要知道会引起死锁：ide

public class Test {
    public static Object lockObject = new Object();
    public static void main(String[] args) throws InterruptedException {

        System.out.println("start");
        Thread thread = new MyThread();
        thread.start();
        Thread.sleep(1000);

        System.out.println("主线程试图占用lockObject锁资源");
        synchronized (Test.lockObject) {
            // 用Test.lockObject作一些事
            System.out.println("作一些事");
        }
        System.out.println("恢复");
        thread.resume();

    }
}

class MyThread extends Thread {
    public void run() {
        try {
            synchronized (Test.lockObject) {
                System.out.println("占用Test.lockObject");
                suspend();
            }
            System.out.println("MyThread释放TestlockObject锁资源");
        }
        catch (Exception e){}
    }
}

答案输出

MyThread内部暂停后，外部的main由于无法拿到锁，因此没法执行后面的resume操做。

Q：上题的suspend和resume能够怎么替换，来解决死锁问题？
A：能够用wait和noitfy来处理（不过尽可能不要这样设计，通常都是用run内部带1个while循环的）

public class Test {
    public static Object lockObject = new Object(); //拿来作临时锁对象
    public static void main(String[] args) throws InterruptedException {

        Thread thread = new MyThread();
        thread.start();
        Thread.sleep(1000);

        System.out.println("主线程试图占用lockObject锁资源");
        synchronized (Test.lockObject) {
            // 用Test.lockObject作一些事
            System.out.println("作一些事");
        }
        System.out.println("恢复");

        synchronized (Test.lockObject) {
            Test.lockObject.notify();
        }

    }
}

class MyThread extends Thread {
    public void run() {
        try {
            synchronized (Test.lockObject) {
                System.out.println("占用Test.lockObject");
                Test.lockObject.wait();
            }
            System.out.println("MyThread释放TestlockObject锁资源");
        }
        catch (Exception e){}
    }
}

如此执行，结果正常：

Q：下面这例子为何会运行异常，抛出IllegalMonitorStateException错误？

public static void main(String[] args) throws InterruptedException {
        Thread thread = new MyThread();
        thread.start();
        thread.notify();
    }

A： notify和wait的使用前提是必须持有这个对象的锁，即main代码块须要先持有thread对象的锁，才能使用notify去唤醒（wait同理）。

改为下面就好了：

Thread thread = new MyThread();
        thread.start();
        synchronized (thread) {
            thread.notify();
        }

Q： Thread.sleep()和Object.wait()的区别
A：sleep不会释放对象锁，而wait会释放对象锁。

Q：Runnable接口和Callable的区别。
A： Callable能够和Futrue配合，而且启动线程时用的时call，可以拿到线程结束后的返回值，call方法还能抛出异常。

Q：thread.alive()表示线程当前是否处于活跃/可用状态。
活跃状态：线程已经启动且还没有终止。线程处于正在运行或准备开始运行的状态，就认为线程是“存活的

thread.start()后，是否alive()必定返回true？

public class Main {
    public static void main(String[] args) {
        TestThread tt = new TestThread();
        System.out.println("Begin == " + tt.isAlive());
        tt.start();
        System.out.println("end == " + tt.isAlive());
    }
}

A:不必定，有可能在打印时，线程已经运行结束了，或者start后，还未真正启动起来（就是还没进入到run中）

Q: 线程A以下：

public class A extends Thread {
    @Override
    public void run() {
        System.out.println("this.isAlive()=" + this.isAlive());
    }
}

把线程A做为构造参数，传给线程B

A a = new A();
Thread b = new Thread(a);
b.start()

此时会打印什么？
A：此时会打印false!

由于把a做为构造参数传入b中， b执行start时，其实是在B线程中去调用了 A对象的run方法，而不是启用了A线程。

若是改为

A a = new A();
a.start()

那么就会打印true了

Q：把FutureTask放进Thread中，并start后，会正常执行callable里的内容吗？

public static void main(String[] args) throws Exception {
    Callable<Integer> callable = () -> {
    System.out.println("call 100");
    return 100;
    };
 
    FutureTask<Integer> task = new FutureTask<>(callable);
    Thread thread = new Thread(task);
    thread.start();
}

A：能正常打印

2、synchronized关键字

便可做为方法的修饰符，也能够做为代码块的修饰符
注意修饰方法时，并非这个方法上有锁，而是调用该方法时，须要取该方法所在对象上的锁。

class A{
     synchroized f(){
     }   
}

即调用这个f()，并非说f同一时刻只能进入一次，而是说进入f时，须要取到A上的锁。

Q：调用下面的f()时，会出现死锁吗？

class A{
     synchroized f(){
        t()
     }
 
     synchroized t(){
     }
}

A：不会。
1个线程内，能够重复进入1个对象的synchroized 块。

原理：
当线程请求本身的锁时。JVM会记下锁的持有者，而且给这个锁计数为1。若是该线程再次请求本身的锁，则能够再次进入，计数为2。退出时计数-1，直到所有退出时才会释放锁。

Q:2个线程同时调用f1和f2会产生同步吗？

class A{
	private static synchronized void f1(){};
	private synchronized void f2(){};
}

A:不会产生同步。两者不是1个锁。
f1是类锁，等同于synchronized(A.class)
f2是对象锁。

3、其余的同步工具

CountDownLatch

final CountDownLatch latch = new CountDownLatch(2);

2是计数器初始值。

而后执行latch.await()时，就会阻塞，直到其余线程中把这个latch进行latch.countDown()，而且计数器下降至0。

和join的区别：
join阻塞时，是只等待单个线程的完成
而CountDownLatch多是为了等待多个线程

Q： countDownLatch的内部计数值能被重置吗？
A：不能重置了。若是要从新计数必须从新new一个。毕竟他的类名就叫DownLatch

FutureTask

能够理解为一个支持有返回值的线程
FutureTask<Integer> task = new FutureTask<>(runable);
当调用task.get()时，就能能达到线程里的返回值

Q：调用futrueTask.get()时，这个是阻塞方法吗？若是是阻塞，何时会结束？
A：是阻塞方法。

线程跑完并返回结果
阻塞时间达到futrueTask.get(xxx)里设定的xxx时间
线程出现异常InterruptedException或者ExecutionException
线程被取消，抛出CancellationException

Semaphore

信号量：就是操做系统里常见的那个概念，java实现，用于各线程间进行资源协调。
用Semaphore(permits)构造一个包含permits个资源的信号量，而后某线程作了消费动做，则执行semaphore.acquire()，则会消费一个资源，若是某线程作了生产动做，则执行semaphore.release()，则会释放一个资源（即新增一个资源）

更详细的信号量方法说明： https://blog.csdn.net/hanchao5272/article/details/79780045

Q：信号量中，公平模式和非公平模式的区别？下面设成true就是公平模式

//new Semaphore(permits,fair):初始化许可证数量和是否公平模式的构造函数
semaphore = new Semaphore(5, true);

A：其实就是使用哪一种公平锁仍是非公平锁。

Java并发中的fairSync和NonfairSync主要区别为：

若是当前线程不是锁的占有者,则NonfairSync并不判断是否有等待队列,直接使用compareAndSwap去进行锁的占用,即谁正好抢到，就给谁用！
若是当前线程不是锁的占有者,则FairSync则会判断当前是否有等待队列,若是有则将本身加到等待队列尾，即严格的先到先得！

CyclicBarrier

栅栏，通常是在线程中去调用的。它的构造须要指定1个线程数量，和栅栏被破坏前要执行的操做，每当有1个线程调用barrier.await()，就会进入阻塞，同时barrier里的线程计数-1。
当线程计数为0时，调用栅栏里指定的那个操做后，而后破坏栅栏，全部被阻塞在await上的线程继续往下走。

Exchanger

我理解为两方栅栏，用于交换数据。
简单说就是一个线程在完成必定的事务后，想与另外一个线程交换数据，则第一个先拿出数据的线程会一直等待第二个线程，直到第二个线程拿着数据到来时才能彼此交换对应数据。

原子类AtomicXXX

就是内部已实现了原子同步机制
Q：下面输出什么？（考察getAndAdd的用法）

AtomicInteger num = new AtomicInteger(1);
System.out.println(num.getAndAdd(1));
System.out.println(num.get());

A：输出一、2
顾名思义， getAndAdd(),那么就是先get，再加，相似于num++。
若是是addAndGet()，那么就是++num

Q：AtomicReference和AtomicInteger的区别？
A：AtomicInteger是对整数的封装，而AtomicReference则对应普通的对象引用。也就是它能够保证你在修改对象引用时的线程安全性。便可能会有多个线程修改atomicReference里包含的引用。

经典用法：
boolean exchanged = atomicStringReference.compareAndSet(initialReference, newReference)就是经典的CAS同步法
compreAndSet它会将将引用与预期值（引用）进行比较，若是它们相等，则在AtomicReference对象内设置一个新的引用。相似于一个非负责的自旋锁。
AtomicReferenceArray是原子数组，能够进行一些原子的数组操做例如 set(index, value)，

java中已实现的所有原子类：

注意，没有float，没有short和byte。

4、线程池

Q: ThreadPoolExecutor线程池构造参数中，corePoolSize和maximumPoolSize有什么区别？
A：当提交新线程到池中时

若是当前线程数 < corePoolSize，则会建立新线程
若是当前线程数=corePoolSize，则新线程被塞进一个队列中等待。
若是队列也被塞满了，那么又会开始新建线程来运行任务，避免任务阻塞或者丢弃
若是队列满了的状况下，线程总数超过了maxinumPoolSize，那么就抛异常或者阻塞（取决于队列性质）。
调用prestartCoreThread()可提早开启一个空闲的核心线程
调用prestartAllCoreThreads()，可提早建立corePoolSize个核心线程。

Q：线程池的keepalive参数是干吗的？
A：当线程数量在corePoolSize到maxinumPoolSize之间时，若是有线程已跑完，且空闲时间超过keepalive时，则会被清除（注意只限于corePoolSize到maxinumPoolsize之间的线程）

Q：线程池有哪三种队列策略？
A：

握手队列
至关于不排队的队列。可能形成线程数量无限增加直到超过maxinumPoolSize（至关于corePoolSize没什么用了，只以maxinumPoolSize作上限）
无界队列
队列队长无限，即线程数量达到corePoolSize时，后面的线程只会在队列中等待。（至关于maxinumPoolSize没什么用了）
缺陷：可能形成队列无限增加以致于OOM
有界队列

Q：线程池队列已满且maxinumPoolSize已满时，有哪些拒绝策略？
A：

AbortPolicy 默认策略：直接抛出RejectedExecutionException异常
DiscardPolicy 丢弃策略：直接丢了，什么错误也不报
DiscardOldestPolicy 丢弃队头策略：即把最早入队的人从队头扔出去，再尝试让该任务进入队尾（队头任务心里：不公平。。。。）
CallerRunsPolicy 调用者处理策略：交给调用者所在线程本身去跑任务（即谁调用的submit或者execute，他就本身去跑）
也能够用实现自定义新的RejectedExecutionHandler

Q：有如下五种Executor提供的线程池，注意记忆一下他们的用途，就能理解内部的原理了。

newCachedThreadPool：缓存线程池
corePoolSize=0, maxinumPoolSize=+∞，队列长度=0 ，所以线程数量会在corePoolSize到maxinumPoolSize之间一直灵活缓存和变更，且不存在队列等待的状况，一来任务我就建立，用完了会释放。

newFixedThreadPool ：定长线程池
corePoolSize= maxinumPoolSize=构造参数值，队列长度=+∞。所以不存在线程不够时扩充的状况
newScheduledThreadPool :定时器线程池
提交定时任务用的，构造参数里会带定时器的间隔和单位。其余和FixedThreadPool相同，属于定长线程池。
newSingleThreadExecutor : 单线程池
corePoolSize=maxinumPoolSize=1，队列长度=+∞，只会跑一个任务，因此其余的任务都会在队列中等待，所以会严格按照FIFO执行
newWorkStealingPool（继承自ForkJoinPool ）：并行线程池
若是你的任务执行时间很长，而且里面的任务运行并行跑的，那么他会把你的线程任务再细分到其余的线程来分治。ForkJoinPool介绍： https://blog.csdn.net/m0_37542889/article/details/92640903

Q： submit和execute的区别是什么？
A:

execute只能接收Runnable类型的任务，而submit除了Runnable，还能接收Callable（Callable类型任务支持返回值）
execute方法返回void， submit方法返回FutureTask。
异常方面， submit方法由于返回了futureTask对象，而当进行future.get()时，会把线程中的异常抛出，所以调用者能够方便地处理异常。（若是是execute，只能用内部捕捉或者设置catchHandler）

Q：线程池中， shutdown、 shutdownNow、awaitTermination的区别？
A：

shutdown: 中止接收新任务，等待全部池中已存在任务完成（ 包括等待队列中的线程 ）。异步方法，即调用后立刻返回。
shutdownNow: 中止接收新任务，并 中止全部正执行的task，返回还在队列中的task列表。
awaitTermination： 仅仅是一个判断方法，判断当前线程池任务是否所有结束。通常用在shutdown后面，由于shutdown是异步方法，你须要知道何时才真正结束。

5、Thread状态转换

Q：线程的6种状态是：
A：

New：新建了线程，可是还没调用start
RUNNABLE：运行，就绪状态包括在运行态中
BLOCKED：阻塞，通常是由于想拿锁拿不到
WAITING：等待，通常是wait或者join以后
TIMED_WAITING: 定时等待，即固定时间后可返回，通常是调用sleep或者wait(时间)的。
TERMINATED：终止状态。

欣赏一幅好图，能了解调用哪些方法会进入哪些状态。

原图连接
Q： java线程何时会进入阻塞（可能按多选题考）：
A：

sleep
wati()挂起，等待得到别的线程发送的Notify（）消息
等待IO
等待锁

6、Volatile

用volatile修饰成员变量时，一旦有线程修改了变量，其余线程可当即看到改变。

Q：不用volatile修饰成员变量时，为何其余线程会没法当即看到改变？
A：线程能够把变量保存在本地内存（好比机器的寄存器）中，而不是直接在主存中进行读写。
这就可能形成一个线程在主存中修改了一个变量的值，而另一个线程还继续使用它在寄存器中的变量值。

Q：用了volatile是否是就能够不用加锁啦？
A：不行。

锁并非只保证1个变量的互斥，有时候是要保证几个成员在连续变化时，让其余线程没法干扰、读取。
而volatile保证1个变量可变，保证不了几个变量同时变化时的原子性。

Q:展现一段《Java并发编程实战》书里的一个经典例子，在科目二考试里也出现了，只是例子换了个皮。为何下面这个例子可能会死循环，或者输出0？

A:首先理解一下java重排序，能够看一下这篇博文： https://www.cnblogs.com/coshaho/p/8093944.html

而后分析后面那2个奇怪的状况是怎么发生的。

永远不输出：
通过程序的指令排序，出现了这种状况：

ReaderThread在while里读取ready值，此时是false，因而存入了ReaderThread的寄存器。
主线程修改ready和number。
ReaderThread没有感知到ready的修改（对于ReaderThread线程，感知不到相关的指令，来让他更新ready寄存器的值），所以进入死循环。

输出0
通过程序的指令排序，出现了这种状况：
1）主线程设置ready为true
2）ReaderThread在while里读取ready值，是true，因而退出while循环

ReaderThread读取到number值，此时number仍是初始化的值为0，因而输出0
主线程这时候才修改number=42，此时ReaderThread已经结束了！

上面这个问题，能够用volatile或者加锁。当你加了锁时，若是变量被写了，会有指令去更新另外一个寄存器的值，所以就可见了。

7、线程群组

为了方便管理一批线程，咱们使用ThreadGroup来表示线程组，经过它对一批线程进行分类管理

使用方法：

Thread group = new ThreadGroup("group");
Thread thread = new Thread(gourp, ()->{..});

即thread除了Thread(Runable)这个构造方法外，还有个Thread(ThreadGroup, Runnable)构造方法

Q：在线程A中建立线程B，他们属于同一个线程组吗
A：是的

线程组的一大做用是对同一个组线程进行统一的异常捕捉处理，避免每次新建线程时都要从新去setUncaghtExceptionHandler。即线程组自身能够实现一个uncaughtException方法。

ThreadGroup group = new ThreadGroup("group") {
	@Override
	public void uncaughtException(Thread thread, Throwable throwable) {
		System.out.println(thread.getName() + throwable.getMessage());
		}
	};
}

线程若是抛出异常，且没有在线程内部被捕捉，那么此时线程异常的处理顺序是什么？相信不少人都看过下面这段话，好多讲线程组的博客里都这样写：
（1）首先看看当前线程组（ThreadGroup）有没有父类的线程组，若是有，则使用父类的UncaughtException()方法。
（2）若是没有，就看线程是否是调用setUncaughtExceptionHandler()方法创建Thread.setUncaughtExceptionHandler实例。若是创建，直接使用它的UncaughtException()方法处理异常。
（3）若是上述都不成立就看这个异常是否是ThreadDead实例，若是是，什么都不作，若是不是，输出堆栈追踪信息（printStackTrace）。

来源：

https://blog.csdn.net/qq_43073128/article/details/90597006
https://blog.csdn.net/qq_43073128/article/details/88280469

好，别急着记，先看一下下面的题目，问输出什么：
Q:

// 父类线程组
static class GroupFather extends ThreadGroup {
    public GroupFather(String name) {
        super(name);
    }
    @Override
    public void uncaughtException(Thread thread, Throwable throwable) {
        System.out.println("groupFather=" + throwable.getMessage());
    }
}

public static void main(String[] args) {
    // 子类线程组
    GroupFather groupSon = new GroupFather("groupSon") {
        @Override
        public void uncaughtException(Thread thread, Throwable throwable) {
            System.out.println("groupSon=" + throwable.getMessage());
        }
    };
    Thread thread1 = new Thread(groupSon, ()->{
        throw new RuntimeException("我异常了");
    });
    thread1.start();
}

A：一看（1），那是否是应该输出groupFather?

错错错，输出的是groupSon这句话在不少地方能看到，但没有去实践过看过源码的人就会这句话被误导。实际上父线程组不是指类继承关系上的线程组，而是指下面这样的：

即指的是构造关系的有父子关系。若是子类的threadGroup没有去实现uncaughtException方法，那么就会去构造参数里指定的父线程组去调用方法。

Q：那我改为构造关系上的父子关系，下面输出什么？

public static void main(String[] args) {
    // 父线程组
    ThreadGroup groupFather = new ThreadGroup("groupFather") {
        @Override
        public void uncaughtException(Thread thread, Throwable throwable) {
            System.out.println("groupFather=" + throwable.getMessage());
        }
    };

    // 子线程组,把groupFather做为parent参数
    ThreadGroup groupSon = new ThreadGroup(groupFather, "groupSon") {
        @Override
        public void uncaughtException(Thread thread, Throwable throwable) {
            System.out.println("groupSon=" + throwable.getMessage());
        }
    };

    Thread thread1 = new Thread(groupSon, ()->{
        throw new RuntimeException("我异常了");
    });

    thread1.start();
}

A：答案输出

即只要子线程组有实现过，则会用子线程组里的方法，而不是直接去找的父线程组！

Q：若是我让本身作set捕捉器的操做呢？那下面这个输出什么？

public static void main(String[] args) {
    // 父线程组
    ThreadGroup group = new ThreadGroup("group") {
        @Override
        public void uncaughtException(Thread thread, Throwable throwable) {
            System.out.println("group=" + throwable.getMessage());
        }
    };

    // 建一个线程，在线程组内
    Thread thread1 = new Thread(group, () -> {
        throw new RuntimeException("我异常了");
    });

    // 本身设置setUncaughtExceptionHandler方法
    thread1.setUncaughtExceptionHandler((t, e) -> {
        System.out.println("no gourp:" + e.getMessage());
    });

    thread1.start();
}

A:看以前的结论里，彷佛是应该输出线程组的异常？
可是结果却输出的是：

也就是说，若是线程对本身特意执行过setUncaughtExceptionHandler，那么有优先对本身设置过的UncaughtExceptionHandler作处理。

那难道第（2）点这个是错的吗？确实错了，实际上第二点应该指的是全局Thread的默认捕捉器，注意是全局的。实际上那段话出自ThreadGroup里uncaughtException的源码：

这里就解释了以前的那三点，可是该代码中没考虑线程自身设置了捕捉器

因此修改一下以前的总结一下线程的实际异常抛出判断逻辑：

若是线程自身有进行过setUncaughtExceptionHandler,则使用本身设置的按个。
若是没设置过，则看一下没有线程组。并按照如下逻辑判断:
若是线程组有覆写过uncaughtException，则用覆写过的uncaughtException
若是线程组没有覆写过，则去找父线程组（注意是构造体上的概念）的uncaughtException方法。
若是线程组以及父类都没覆写过uncaughtException，则判断是否用Thread.setDefaultUncaughtExceptionHandler(xxx)去设置全局的默认捕捉器，有的话则用全局默认
若是不是ThreadDeath线程，则只打印堆栈。
若是是ThreadDeath线程，那么就什么也不处理。

点击关注，第一时间了解华为云新鲜技术~