多线程&高并发面试宝典

1.多线程有什么用

发挥多核CPU的优势
防止阻塞
便于建模

2.Java实现线程有哪几种方法

集成Thread类实现多线程
实现Runnable接口方式实现
使用ExcutorService、Callable、Future实现有返回结果的多线程

3.启动线程方法start()和run()有什么区别

只有调用了start()才会表现出多线程的特性，不同线程的run()方法里代交替执行。如果只调用run()，那么代码还是同步执行，必须等待一个线程的run()方法执行完毕，另一个线程才可以执行其run()里的代码。

4.怎么终止一个线程？如何优雅的终止线程？

stop()终止（不推荐），因为stop和suspend以及resume一样都过期作废的方法，不安全。
**使用interrupt方法中断线程（在当前线程打一个停止标志，并不是真的停止线程）
判断线程是否停止状态（Thread类中，this.interrupted();和this.isinterrupted()）

5.线程中的wait()和sleep()有什么区别

sleep方法和wait方法都可以用来放弃CPU一定时间，不同之处在于如果线程持有某个对象的监视器，sleep方法不会放弃这个对象的监视器，当指定时间到了又自动回复运行状态；wait方法会放弃这个对象的监视器，进入此对象的等待锁定池。
sleep方法属于Thread类，wait方法属于Object类。
sleep方法必须捕获异常

6.多线程同步的方法有哪些

Synchronized关键字，Lock锁实现，分布式锁等

7.什么是死锁，如何避免死锁

死锁就是两个线程相互等待对方释放对象锁

8.线程之间如何通信

wati()/notify()

9.线程怎样拿到返回结果

实现Callable接口

10.violatile关键字的作用

保证不同线程对这个变量进行操作时的可见性
禁止指令重排序
violatile仅能使用在变量级别，不保证原子性
不会造成线程阻塞

11.新建T1、T2、T3三个线程，如何保证它们按顺序执行

join()

12.怎么控制同一时间只有三个线程

用Semaphore

13.为什么要使用线程池

不使用线程池，每个线程都要通过new Thread(xxxRunnabe).start()创建并运行一个线程，而使用线程池的话：
降低资源消耗：通过重复利用已创建的线程降低线程创建和销毁造成的消耗
提高响应速度：任务不需要等待线程的创建就能立即执行
提高线程的可管理性：对线程进行统一的分配、调优和监控

14.常用的几种线程池

/*
*  ThreadPoolExecutor构造参数介绍
*/
public ThreadPoolExecutor(
//核心线程数，除非allowCoreThreadTimeOut被设置为true，否则它闲着也不会死
int corePoolSize, 
//最大线程数，活动线程数量超过它，后续任务就会排队                   
int maximumPoolSize, 
//超时时长，作用于非核心线程（allowCoreThreadTimeOut被设置为true时也会同时作用于核心线程），闲置超时便被回收           
long keepAliveTime,                          
//枚举类型，设置keepAliveTime的单位，有TimeUnit.MILLISECONDS（ms）、TimeUnit. SECONDS（s）等
TimeUnit unit,
//缓冲任务队列，线程池的execute方法会将Runnable对象存储起来
BlockingQueue<Runnable> workQueue,
//线程工厂接口，只有一个new Thread(Runnable r)方法，可为线程池创建新线程
ThreadFactory threadFactory)

• 固定大小的线程池 new Executors.newFixedThreadPool();

/*
* FixThreadPool介绍
*/
public static ExecutorService newFixThreadPool(int nThreads){
    return new ThreadPoolExecutor(nThreads, nThreads, 0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue<Runnable>());
}
//使用

• Executors.newFixThreadPool(5).execute®;
  单线程的线程池 new SingleThreadPool()

/*
* SingleThreadPool介绍
*/
public static ExecutorService newSingleThreadPool (int nThreads){
    return new FinalizableDelegatedExecutorService ( new ThreadPoolExecutor (1, 1, 0, TimeUnit. MILLISECONDS, new LinkedBlockingQueue<Runnable>()) );
}
//使用

• Executors.newSingleThreadPool ().execute®;

支持定时以及周期性执行任务的线程池 new ScheduledThreadPool()

/*
* ScheduledThreadPool介绍
*/
public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize){
return new ScheduledThreadPoolExecutor(corePoolSize);
}
public ScheduledThreadPoolExecutor(int corePoolSize){
super(corePoolSize, Integer.MAX_VALUE, 0, NANOSECONDS, new DelayedQueue ());
}
//使用，延迟1秒执行，每隔2秒执行一次Runnable r
Executors. newScheduledThreadPool (5).scheduleAtFixedRate(r, 1000, 2000, TimeUnit.MILLISECONDS);

• 可缓存的线程池 new CachedThreadPool()

/*
* CachedThreadPool介绍
*/
public static ExecutorService newCachedThreadPool(int nThreads){
    return new ThreadPoolExecutor(0, Integer.MAX_VALUE, 60L, TimeUnit. SECONDS, new SynchronousQueue<Runnable>());
}
//使用

• Executors.newCachedThreadPool().execute®;

15.线程池启动线程 submit()和execute()有什么不同

execute没有返回值，性能上好很多；submit返回一个Future对象，能通过Future的get()在主线程中捕获线程中的异常。

16.什么是活锁、饥饿、无锁、死锁？

死锁、活锁、饥饿是关于多线程是否活跃出现的运行阻塞障碍问题，如果线程出现了这三种情况，即线程不再活跃，不能再正常地执行下去了。
死锁： 多个线程相互占用对方的资源的锁，而又相互等对方释放锁，此时若无外力干预，这些线程则一直处理阻塞的假死状态，形成死锁。
活锁：活锁恰恰与死锁相反，死锁是大家都拿不到资源都占用着对方的资源，而活锁是拿到资源却又相互释放不执行。
饥饿： 如果优先级高的线程一直抢占优先级低线程的资源，导致低优先级线程无法得到执行，这就是饥饿。另一种情况是：一个线程一直占着一个资源不放而导致其他线程得不到执行，与死锁不同的是饥饿在以后一段时间内还是能够得到执行的，如那个占用资源的线程结束了并释放了资源。
无锁： 即没有对资源进行锁定，即所有的线程都能访问并修改同一个资源，但同时只有一个线程能修改成功。

17.什么是原子性、可见性、有序性

原子性： 一个线程的操作是不能被其他线程打断，同一时间只有一个线程对一个变量进行操作。
可见性： 某个线程修改了某一个共享变量的值，而其他线程是否可以看见该共享变量修改后的值。
有序性： 为了优化程序执行和提高CPU的处理性能，JVM和操作系统都会对指令进行重排，也就说前面的代码并不一定都会在后面的代码前面执行，即后面的代码可能会插到前面的代码之前执行，只要不影响当前线程的执行结果。所以，指令重排只会保证当前线程执行结果一致，但指令重排后势必会影响多线程的执行结果。虽然重排序优化了性能，但也是会遵守一些规则的，并不能随便乱排序，只是重排序会影响多线程执行的结果。

18.什么是守护线程，有什么用

与守护线程相对应的就是用户线程，守护线程就是守护用户线程，当用户线程全部执行完结束之后，守护线程才会跟着结束。也就是守护线程必须伴随着用户线程，如果一个应用内只存在一个守护线程，没有用户线程，守护线程自然会退出。

19.一个线程运行时发生异常会怎么样

如果异常没有被捕获该线程将会停止执行。
Thread.UncaughtExceptionHandler是用于处理未捕获异常造成线程突然中断情况的一个内嵌接口。
当一个未捕获异常将造成线程中断的时候JVM会使用Thread.getUncaughtExceptionHandler()来查询线程的UncaughtExceptionHandler并将线程和异常作为参数传递给handler的uncaughtException()方法进行处理。

20.线程yield()有什么用

可以暂停当前正在执行的线程对象，让其它有相同优先级的线程执行。它是一个静态方法而且只保证当前线程放弃CPU占用而不能保证使其它线程一定能占用CPU，执行yield()的线程有可能在进入到暂停状态后马上又被执行

21.什么是重入锁

以线程为单位，当一个线程获取对象锁之后，这个线程可以再次获取本对象的锁，而其他线程是不可以的

22.Synchronized有哪些用法

锁类、方法、代码块

23.Fork/Join框架是干什么的

大任务自动分散小任务，并发执行，合并小任务结果

24.线程数过多会造成什么异常

线程过多会造成栈溢出，也有可能会造成堆异常。

25.线程安全的和不安全的集合

Java中平时用的最多的Map集合就是HashMap了，它是线程不安全的。看下面两个场景：
1、当用在方法内的局部变量时，局部变量属于当前线程级别的变量，其他线程访问不了，所以这时也不存在线程安全不安全的问题了。
2、当用在单例对象成员变量的时候呢？这时候多个线程过来访问的就是同一个HashMap了，对同个HashMap操作这时候就存在线程安全的问题了。

26.什么是CAS算法，在多线程中有哪些应用

即比较-替换。假设有三个操作数：内存值V、旧的预期值A、要修改的值B，当且仅当预期值A和内存值V相同时，才会将内存值修改为B并返回true，否则什么都不做并返回false。当然CAS一定要volatile变量配合，这样才能保证每次拿到的变量是主内存中最新的那个值，否则旧的预期值A对某条线程来说，永远是一个不会变的值A，只要某次CAS操作失败，永远都不可能成功。
java.util.concurrent.atomic包下面的Atom****类都有CAS算法的应用。

27.怎么检测一个线程是否拥有锁？

java.lang.Thread#holdsLock方法

28.Jdk中排查多线程问题用什么命令？

jstack

29.线程同步需要注意什么？

1、尽量缩小同步的范围，增加系统吞吐量。
2、分布式同步锁无意义，要使用分布式锁。
3、防止死锁，注意加锁顺序。

29.线程wait()方法使用有什么前提？

在同步块中使用。

30.线程之间如何传递数据？

通过在线程之间共享对象就可以了，然后通过wait/notify/notifyAll、await/signal/signalAll进行唤起和等待，比方说阻塞队列BlockingQueue就是为线程之间共享数据而设计的

31.保证"可见性"有哪几种方式？

synchronized和viotatile

32.说几个常用的Lock接口实现锁。

ReentrantLock、ReadWriteLock

33.ThreadLocal是什么？有什么应用场景？

作用是提供线程内的局部变量，这种变量在线程的生命周期内起作用，减少同一个线程内多个函数或者组件之间一些公共变量的传递的复杂度。用来解决数据库连接、Session 管理等。

34.ReadWriteLocal是什么，有什么应用场景

一个读写锁接口，ReentrantReadWriteLock 是 ReadWriteLock 接口的一个具体实现，实现了读写的分离，读锁是共享的，写锁是独占的，读和读之间不会互斥，读和写、写和读、写和写之间才会互斥，提升了读写的性能。

35.FutureTask是什么

表说一个异步运算的任务，FutureTask里可以传入一个Callable的具体实现类，可以对这个异步运算的任务的结果进行等待获取、判断是否已完成、取消任务等操作。

36.怎么唤醒一个阻塞的线程

如果线程是因为调用了wait()、sleep()或者join()而导致阻塞，可以中断线程，并通过抛出InterruptedException来唤醒它；如果线程遇到IO阻塞，就无能为力，因为IO是操作系统实现的，Java代码并没有办法直接接触操作系统。

37.不可变对象对多线程有什么帮助

不可变对象保证了对象的内存可见性，对不可变对象的读取不需要进行额外的同步手段，提升了代码执行效率

38.线程上下文切换是什么意思

多线程的上下文切换是指CPU控制权由一个正在运行的线程切换到另一个就绪并等待获取CPU执行权的线程的过程。

39.Java中用到了什么线程调度算法

抢占式。一个线程用完CPU后，操作系统会根据线程优先级、线程饥饿情况等数据算出一个总的优先级并分配下一个时间片给某个线程执行

40.Thread.sleep(0)的作用是什么

由于java采用抢占式的线程调度三大，因此可能会出现某条线程常常获得CPU控制权的情况，未来路让某些优先级比较低的线程也能获得CPU控制权，可以使用Thread.sleep(0)手动触发一次操作系统分配时间片的操作，这也是平衡CPU控制权的一种操作

41.什么是乐观锁，什么是悲观锁

乐观锁：对于并发间操作产生的线程安全问题保持乐观，乐观锁认为竞争不总是发生，因此他不需要持有锁，将比较-替换着两个动作作为一个原子操作尝试修改内存中的变量，如果失败则表示发生冲突，那么久应该有相应的重试逻辑。
悲观锁：对于并发间操作产生的线程安全问题持悲观态度，悲观锁认为竞争总是会发生，因此每次对某个资源进行操作时，都会持有一个独占的锁，就像synchronized。

42.HashTable的size方法为什么要做同步

同一时间只能有一条线程执行固定类的同步方法，但是对于类的非同步方法，可以多条线程同时访问。
可能产生的问题：A线成执行put方法时，B线程则可以正常代用size方法读取HashTable中当前元素的个数，那么读取到的数可能不是最新的，可能A线程添加完完整的数据，但是没有对size++，线程B就读取了。
而给size方法加了同步之后，意味着线程 B 调用 size()方法只有在线程 A调用 put 方法完毕之后才可以调用，这样就保证了线程安全性CPU 执行代码，执行的不是 Java 代码，这点很关键，一定得记住。Java 代码最终是被翻译成机器码执行的，机器码才是真正可以和硬件电路交互的代码。即使你看到 Java 代码只有一行，甚至你看到 Java 代码编译之后生成的字节码也只有一行，也不意味着对于底层来说这句语句的操作只有一个。一句"return count"假设被翻译成了三句汇编语句执行，一句汇编语句和其机器码做对应，完全可能执行完第一句，线程就切换了。

43.同步方法和同步块，哪种更好

同步块，这意味着同步块之外的代码是异步执行的，这比同步整个方法更提升代码的效率。
请知道一条原则：同步的范围越小越好。

44.什么是自旋锁

自旋锁是采用让当前线程不停的在循环体内执行实现的，当循环条件被其他线程改变时，才能进入临界值

45.Runnable和Thread用哪个更好

Java 不支持类的多重继承，但允许你实现多个接口。所以如果你要继承其他类，也为了减少类之间的耦合性，Runnable 会更好。

46.Java中的notify和notifyAll有什么区别

notify()不能唤醒某个具体的线程，所有只有一个线程在等待时，他才会比较有用。（如果使用不正确的话可能导致死锁）
notifyAll()唤醒所有线程并允许他们争夺锁，却把至少有一个线程能运行。
都需要在synchronized中使用，过程不释放锁。

47.为什么wait()和notify()要在同步块中使用

主 要 是 因 为 Java API 强 制 要 求 这 样 做 ， 如 果 你 不 这 么 做 ， 你 的 代 码会 抛 出IllegalMonitorStateException 异常。还有一个原因是为了避免 wait 和 notify之间产生竞态条件。

48.为什么 wait/notify/notifyAll 这些方法不在 thread 类里面？

一个很明显的原因是JAVA 提供的锁是对象级的而不是线程级的，每个对象都有锁，通过线程获得。如果线程需要等待某些锁那么调用对象中的wait()方法就有意义了。如果 wait()方法定义在 Thread 类中，线程正在等待的是哪个锁就不明显了。简单的说，由于 wait，notify 和 notifyAll 都是锁级别的操作，所以把他们定义在 Object 类中因为锁属于对象。

49.为什么你应该在循环条件中检查等待条件

处于等待状态的线程可能会收到错误警报和伪唤醒，如果不在循环中检查等待条件，程序就会在没有满足结束条件的情况下退出。因此，当一个等待线程醒来时，不能认为它原来的等待状态仍然是有效的，在 notify()方法调用之后和等待线程醒来之前这段时间它可能会改变。这就是在循环中使用 wait()方法效果更好的原因。

50.Java中堆和栈有什么不同

每个线程都有自己的栈内存，用于存储本地变量，方法参数和栈调用，一个线程中存储的变量对其它线程是不可见的。而堆是所有线程共享的一片公用内存区域。对象都在堆里创建，为了提升效率线程会从堆中弄一个缓存到自己的栈，如果多个线程使用该变量就可能引发问题，这时 volatile 变量就可以发挥作用了，它要求线程从主存中读取变量的值。

51.如何在Java中获取线程堆栈

当你获取线程堆栈时，JVM会把所有线程的状态存到日志文件或者输出到控制台。在 Windows 你可以使用 Ctrl + Break 组合键来获取线程堆栈，Linux 下用 kill -3 命令。你也可以用 jstack 这个工具来获取，它对线程 id 进行操作，你可以用 jps 这个工具找到 id。

52.如何创建线程安全的单例模式

单例模式即一个 JVM 内存中只存在一个类的对象实例分类
1、懒汉式
类加载的时候就创建实例

/**
 * 单例模式：懒汉式（线程安全的）
 */
public class Test03 {
    private Test03(){}
    private static volatile Test03 instance=null;
    public static Test03 getTest03(){
        if(instance==null){
            synchronized (Test03.class){
                if (instance==null){
                    instance=new Test03();
                }
            }
        }
        return instance;
    }
}

2、饿汉式
使用的时候才创建实例

/**
 * 单例模式：饿汉式（线程安全）
 */
public class Test01 {
 
    private Test01(){}
    private static Test01 instance =new Test01();
 
    public static Test01 getTest01(){
        return instance;
    }
}

53.什么是阻塞式方法

指程序会一直等待该方法完成期间不做其他事情，ServerSocket 的accept()方法就是一直等待客户端连接。这里的阻塞是指调用结果返回之前，当前线程会被挂起，直到得到结果之后才会返回。此外，还有异步和非阻塞式方法在任务完成前就返回。

54.提交任务时线程池队列已满时会发生什么

当线程数小于最大线程池数maximumPoolSize时就会创建新线程来处理，而线程数大于等于最大线程数maximumPoolSize时就会执行拒绝策略。