面试必备：多线程学习（一）

这是2020年“水”的第23篇文章

面试中，多线程并发问题基本上是必问的，所以，不背上个线程相关的问题，都不好意思出去面试了。

一提到多线程，相信大部分小伙伴首先想到的一定是 Synchronize、Lock，再就是volatile、concurrent并发包，厉害点的小伙伴呢，还能再跟面试官吹吹Synchronize、volatile的区别跟原理，以及并发包常用的数据结构，例如之前提到的 ConcurrentHashMap

好了，废话不多说，本篇就以面试为出发点，看看多线程到底要准备哪些傻吊知识点。

1、多线程的创建方式

继承Thread类
实现Runnable接口
实现Callable接口

一共3种创建方式，不要问哪个好，问就是接口形式的好，因为实现接口的方式比继承类的方式更灵活，也能减少程序之间的耦合度，面向接口编程也是设计模式6大原则的核心，但是，是选择实现Runnable，还是Callable，就要根据自己情况选择了。

延伸补充：Runnable跟Callable区别？

如果上边的问题回答了Runnable、Callable，那么就要准备好关于两者的区别？什么？没用过Callable？背就完事了。

Runnable没有返回值，需要做的事情就是去执行run()方法，执行完就完了。
Callable有返回值，该返回值是Callable接口中的call()方法，是一个泛型，和Future、FutureTask配合可以用来获取异步执行的结果。

简单看一下代码：

Callable callable = new Callable() {
　　@Override
　　public String call() throws Exception {
　　    Thread.sleep(5000);
　　    return "我是call方法返回值";
　　}
};
Future future = executor.submit(callable);
System.out.println("获取返回值: "+future.get());

看完上方代码，如果问到Callable接口会有哪些应用场景应该会答了吧？

2、wait() 和 notify() 的理解和使用？

有时候面试官会先延伸一下它的出处，比如，你能说一下Object类都有哪些方法吗？

只要你提到了 wait() 跟 notify() || notifyAll() 那么基本就会问相关的内容了。

wait和notify是用来让线程进入等待状态以及使线程唤醒的两个操作。

理解：

wait、notify 属于 Object 基础类，所以每个对象都有 wait、notify 的功能，也就是每个对象都有锁的权利；但是在使用此类方法的时候，一定要对竞争资源进行加锁操作，获得这个锁对象的控制权，比如放在 Synchronize(obj) 代码块中，如果不加锁的话，则会报 IllegalMonitorStateException 异常。

使用：

public class Test {

    public static void main(String[] args) {
        Object obj = new Object();
        Thread thread1 = new Thread(() -> {
            synchronized (obj) {
                try {
                    System.out.println("1-before wait");
                    obj.wait();
                    System.out.println("1-after wait");
                } catch (Exception e) {
                    System.out.println(String.format("1-catch ：%s. interrupt状态: %s",e.toString(),Thread.currentThread().isInterrupted()));
                    Thread.currentThread().interrupt();
                    System.out.println("设置标志位后interrupt状态: "+ Thread.currentThread().isInterrupted());

                }
            }
        });

        thread1.start();
        try {
            Thread.currentThread().sleep(2000);
        } catch (InterruptedException e1) {
            e1.printStackTrace();
        }
        System.out.println("线程初始interrupt状态："+thread1.isInterrupted());
        thread1.interrupt();

    }
}

如果你不太清楚上方代码中的 interrupt()、interrupted() 和isInterrupted() 那么可以参考这篇文章：Thread类中interrupt方法详解

废话总结：

wait和notify来自于Object基础类；
wait和notify是用来让线程进入等待状态以及使线程唤醒的两个操作。
wait或notify方法，使用时必须保证当前运行的线程取得了该对象的控制权。
如果在没有控制权的线程里执行wait或notify方法，会报IllegalMonitorStateException异常。

3、sleep() 和 wailt() 的区别

如果在上一个wailt、notify中没有回答出wailt的细节的话，那么这个问题就会常问;

首先两者来源不同，sleep来自Thread类，而wait来自Object类。

sleep方法和wait方法都可以用来放弃CPU一定的时间，不同点在于如果线程持有某个对象的监视器，sleep方法不会放弃这个对象的监视器，而wait方法会放弃这个对象的监视器，怎么讲？

sleep方法不会释放锁，调用sleep后不会出让系统资源，典型无赖行为「占着茅坑不拉*」；而wait则是进入线程等待池等待，会出让系统资源，其他线程可以占用CPU，就是我现在不用了，你们先用吧。

通常wait是不会加时间限制的，因为如果wait线程的运行资源不够，即使出来也没用，要等待其他线程调用notify/notifyAll唤醒等待池中的所有线程，才会进入就绪队列等待系统分配资源。

而sleep(秒)可以用指定时间使它自动唤醒过来，如果时间不到只能调用interrupt()强行打断。比如上端代码中我用到了 thread1.interrupt(); 方法，作用就是强行打断。

使用范围不同：wait只能在同步控制方法或者同步控制块里面使用，而sleep可以在任何地方使用。所以你看到的只要出现wait必出现Synchronize，而sleep可以到处使用。

废话总结：

所属类不同：sleep() 来自Thread；wailt() 来自 Object
是否释放锁：sleep() 不会释放锁；wailt() 会释放锁
用法不同：sleet时间到了会自动恢复；wailt() 可以使用notigy()/notigyAll()直接唤醒
使用范围不同：sleep() 在任何地方可用；wait() 需要结合 Synchronize使用
作用不同：sleep() 通常被用于暂停执行；wait() 通常被用于线程间交互/通信

4、如何保证多线程安全？

使用安全类，比如 java.util.concurrent 并发包下的类；
使用锁，比如自动Synchronize，手动锁 Lock

如上两点只是尽量做到线程安全，或者说目前被建议以及常用的，但做到绝对的线程安全通常需要付出许多额外代价，Java中标注自己是线程安全的类，实际上绝大多数都不是线程安全的，不过绝对线程安全的类，Java中也有，比方说CopyOnWriteArrayList、CopyOnWriteArraySet

废话总结：

如果你的代码，在多线程下执行和在单线程下执行，永远都能得到一样的结果，那么你的代码就是线程安全的。

5、Synchronize跟Lock区别

提到Synchronize就不得不扯上Lock，冤家路窄，面试总是会问。

Synchronize：java中提供的一个并发控制的关键字，自动锁、重量级。主要用在同步方法和同步代码块中，也就是说，synchronized既可以修饰方法也可以修饰代码块。被synchronized修饰的代码块及方法，在同一时间，只能被单个线程访问。应用场景：商品下单，商品库存的修改。

Lock：是一个类，确切说是一个接口类，其实现类可以实现同步访问。Lock为轻量级、手动锁，能够实现synchronized所实现的功能，但Lock相对更加灵活，可以被继承、可以有方法、可以有各种各样的类变量。

转自网上的区别表格：

类别	synchronized	Lock
存在层次	Java的关键字，在jvm层面上	是一个类
锁的释放	1、以获取锁的线程执行完同步代码，释放锁 2、线程执行发生异常，jvm会让线程释放锁	在finally中必须释放锁，不然容易造成线程死锁
锁的获取	假设A线程获得锁，B线程等待。如果A线程阻塞，B线程会一直等待	分情况而定，Lock有多个锁获取的方式，具体下面会说道，大致就是可以尝试获得锁，线程可以不用一直等待
锁状态	无法判断	可以判断
锁类型	可重入不可中断非公平	可重入可判断可公平（两者皆可）
性能	少量同步	大量同步

个人补充：

如果单单写两者，完全可以写一篇文章，由于本篇是出于面试准备的，所以面试官问到时，简单说一下两者的作用，以及各自的应用场景即可『经验初级』，当然，如果你有特地看过源码的话，自然是建议你引导面试官问你原理，你懂得~ 不过话说回来，synchronized 原理还是有必要了解的~

废话总结：

1、Synchronized为java关键字，由JVM控制；Lock为接口类，由JDK实现；
2、Synchronized重量级、自动锁，Lock轻量级、手动锁；
3、发生异常时，Synchronized会自动释放锁，Lock需要手动在finally释放锁，不释放很容易造成死锁；
4、Lock更加灵活，能够响应中断，让等待状态的线程停止等待，synchronized不行；
5、通过Lock可以知道线程是否成功获得了锁，synchronized不行；