（二）多线程系列面试题

Sick_2W

已于 2022-06-11 15:32:43 修改

阅读量145

点赞数

文章标签： java 面试程序人生

于 2022-03-14 17:01:29 首次发布

本文链接：https://blog.csdn.net/Sick_2W/article/details/123482981

版权

线程

多线程(一)：创建线程和线程的常用方法_monday的博客-CSDN博客_线程

进程和线程的定义

进程是资源（CPU、内存等）分配的基本单位，它是程序执行时的一个实例。程序运行时系统就会创建一个进程，并为它分配资源，然后把该进程放入进程就绪队列，进程调度器选中它的时候就会为它分配CPU时间，程序开始真正运行。

线程是一条执行路径，是程序执行时的最小单位，它是进程的一个执行流，是CPU调度和分派的基本单位，一个进程可以由很多个线程组成，线程间共享进程的所有资源，每个线程有自己的堆栈和局部变量。线程由CPU独立调度执行，在多CPU环境下就允许多个线程同时运行。同样多线程也可以实现并发操作，每个请求分配一个线程来处理。

一个正在运行的软件(如迅雷)就是一个进程，一个进程可以同时运行多个任务( 迅雷软件可以同时下载多个文件，每个下载任务就是一个线程), 可以简单的认为进程是线程的集合。

对于单核CPU而言：多线程就是一个CPU在来回的切换，在交替执行。对于多核CPU而言：多线程就是同时有多条执行路径在同时(并行)执行，每个核执行一个线程，多个核就有可能是一块同时执行的。

进程与线程的关系

一个线程只能属于一个进程，而一个进程可以有多个线程，但至少有一个线程。线程是操作系统可识别的最小执行和调度单位。

资源分配给进程，同一进程的所有线程共享该进程的所有资源。同一进程中的多个线程共享代码段(代码和常量)，数据段(全局变量和静态变量)，扩展段(堆存储)。但是每个线程拥有自己的栈段，栈段又叫运行时段，用来存放所有局部变量和临时变量，即每个线程都有自己的堆栈和局部变量。线程在执行过程中，需要协作同步。不同进程的线程间要利用消息通信的办法实现同步。

线程的三种特性

原子性

在Java中，对基本数据类型的变量的【读取】和【赋值】操作是原子性操作，即这些操作是不可被中断的，一次性必须执行完成的，要么执行，要么不执行。 Java内存模型只保证了基本读取和赋值是原子性操作，如果要实现更大范围操作的原子性，可以通过synchronized和Lock来实现。由于synchronized和Lock能够保证任一时刻只有一个线程执行该代码块，那么自然就不存在原子性问题了，从而保证了原子性。

可见性

使用volatile关键字增加了实例变量在多个线程之间的可见性。但是volatile关键字最致命的缺点是不支持原子性。

synchronized和volatile比较：

关键字volatile是线程同步的轻量级实现，所以volatile性能肯定比synchronized要好，并且volatile只能修饰于变量，而synchronized可以修饰方法，以及代码块。随着JDK新版本的发布，synchronized关键字在执行效率上得到很大提升，在开发中使用synchronized关键字的比率还是比较大的。

多线程访问volatile不会发生阻塞，而synchronized会出现阻塞。

volatile能保证数据的可见性，但不能保证原子性；而synchronized可以保证原子性，也可以间接保证可见性，因为它将私有内存和公共内存中的数据做同步。

再次重申一下，关键字volatile解决的是变量在多个线程之间的可见性；而synchronized关键字解决的是多个线程之间访问资源的同步性。

有序性

在Java内存模型中，允许编译器和处理器对指令进行重排序，但是重排序过程不会影响到单线程程序的执行，却会影响到多线程并发执行的正确性。

在Java里面，可以通过volatile关键字来保证一定的“有序性”（具体原理在下一节讲述）。另外可以通过synchronized和Lock来保证有序性，很显然，synchronized和Lock保证每个时刻是有一个线程执行同步代码，相当于是让线程顺序执行同步代码，自然就保证了有序性。

另外，Java内存模型具备一些先天的“有序性”，即不需要通过任何手段就能够得到保证的有序性，这个通常也称为 happens-before 原则。如果两个操作的执行次序无法从happens-before原则推导出来，那么它们就不能保证它们的有序性，虚拟机可以随意地对它们进行重排序。

顺序并行和并发区别

顺序：代码从上而下按照固定的顺序执行，只有上一件事情执行完毕，才能执行下一件事。就像物理电路中的串行，假如有十件事情，一个人来完成，这个人必须先做第一件事情，然后再做第二件事情，最后做第十件事情，按照顺序做。

并行：多个操作同时处理，他们之间是并行的。假如十件事情，两个人来完成，每个人在某个时间点各自做各自的事情，互不影响

并发：将一个操作分割成多个部分执行并且允许无序处理，假如有十件事情，如果有一个人在做，这个人可能做一会这个不想做了，再去做别的，做着做着可能也不想做了，又去干其它事情了，看他心情想干哪个就干哪个，最终把十件事情都做完。如果有两个人在做，他们俩先分一下，比如张三做4件，李四做6件，他们各做自己的，在做自己的事情过程中可以随意的切换到别的事情，不一定要把某件事情干完再去干其它事情，有可能一件事做了N次才做完

线程的状态

Thread源码分析

 public class Thread implements Runnable {
     // 线程名字
     private volatile String name;
     // 线程优先级(1~10)
     private int priority;
     // 守护线程
     private boolean daemon = false;
     // 线程id
     private long tid;
     // 线程组
     private ThreadGroup group;
 // 预定义3个优先级
 public final static int MIN_PRIORITY = 1;
 public final static int NORM_PRIORITY = 5;
 public final static int MAX_PRIORITY = 10;
 
 // 构造函数
 public Thread();
 public Thread(String name);
 public Thread(Runnable target);
 public Thread(Runnable target, String name);
 // 线程组
 public Thread(ThreadGroup group, Runnable target);
 
 // 返回当前正在执行线程对象的引用
 public static native Thread currentThread();
 
 // 启动一个新线程
 public synchronized void start();
 // 线程的方法体，和启动线程没毛关系
 public void run();
 
 // 让线程睡眠一会，由活跃状态改为挂起状态
 public static native void sleep(long millis) throws InterruptedException;
 public static void sleep(long millis, int nanos) throws InterruptedException;
 
 // 打断线程 中断线程 用于停止线程
 // 调用该方法时并不需要获取Thread实例的锁。无论何时，任何线程都可以调用其它线程的interruptf方法
 public void interrupt();
 public boolean isInterrupted()
 
 // 线程是否处于活动状态
 public final native boolean isAlive();
 
 // 交出CPU的使用权，从运行状态改为挂起状态
 public static native void yield();
 
 public final void join() throws InterruptedException
 public final synchronized void join(long millis)
 public final synchronized void join(long millis, int nanos) throws InterruptedException
 
 // 设置线程优先级
 public final void setPriority(int newPriority);
 // 设置是否守护线程
 public final void setDaemon(boolean on);
 // 线程id
 public long getId() { return this.tid; }
 
 // 线程状态
 public enum State {
     // new 创建
     NEW,
 
     // runnable 就绪
     RUNNABLE,
 
     // blocked 阻塞
     BLOCKED,
 
     // waiting 等待
     WAITING,
 
     // timed_waiting
     TIMED_WAITING,
 
     // terminated 结束
     TERMINATED;
 }
}

sleep(): 睡眠指定时间

即让程序暂停指定时间运行，时间到了会继续执行代码，如果时间未到就要醒需要使用interrupt()来随时唤醒

sleep和wait区别

sleep在Thread类中，wait在Object类中
sleep不会释放锁，wait会释放锁
sleep使用interrupt()来唤醒，wait需要notify或者notifyAll来通知

interrupt(): 唤醒正在睡眠的程序

调用interrupt()方法，会使得sleep()方法抛出InterruptedException异常，当sleep()方法抛出异常就中断了sleep的方法，从而让程序继续运行下去

wait、notify和notifyAll

wait、notify和notifyAll方法是Object类的final native方法。所以这些方法不能被子类重写，Object类是所有类的超类，因此在程序中可以通过this或者super来调用this.wait(), super.wait()

Object.wait()和Object.notify()和Object.notifyall()必须写在synchronized方法内部或者synchronized块内部让哪个对象等待wait就去通知notify哪个对象，不要让A对象等待，结果却去通知B对象，要操作同一个对象

wait(): 导致线程进入等待阻塞状态

会一直等待直到它被其他线程通过notify()或者notifyAll唤醒。该方法只能在同步方法中调用。如果当前线程不是锁的持有者，该方法抛出一个IllegalMonitorStateException异常。wait(long timeout): 时间到了自动执行，类似于sleep(long millis) 让程序暂停执行，相当于让当前线程进入当前实例的等待队列，这个队列属于该实例对象，所以调用notify也必须使用该对象来调用，不能使用别的对象来调用。调用wait和notify必须使用同一个对象来调用。

notify() 和 notifyall()

该方法只能在同步方法或同步块内部调用，随机选择一个(注意：只会通知一个)在该对象上调用wait方法的线程，解除其阻塞状态

notifyAll():唤醒所有的wait对象

InterruptedException

Thread.sleep(long millis): 睡眠时不会释放锁

wait(): 方法的作用是释放锁，加入到等待队列，当调用interrupt()方法后，线程必须先获取到锁后，然后才抛出异常InterruptedException 。注意：在获取锁之前是不会抛出异常的，只有在获取锁之后才会抛异常

所有能抛出InterruptedException的方法都可以通过interrupt()来取消的

public static native void sleep(long millis) throws InterruptedException; public final void wait() throws InterruptedException; public final void join() throws InterruptedException; public void interrupt()；

这里写图片描述

join()

让当前线程加入父线程，加入后父线程会一直wait，直到子线程执行完毕后父线程才能执行。当我们调用某个线程的这个方法时，这个方法会挂起调用线程，直到被调用线程结束执行，调用线程才会继续执行。

将某个线程加入到当前线程中来，一般某个线程和当前线程依赖关系比较强，必须先等待某个线程执行完毕才能执行当前线程。一般在run()方法内使用

yield()

交出CPU的执行时间，不会释放锁，让线程进入就绪状态，等待重新获取CPU执行时间，yield就像一个好人似的，当CPU轮到它了，它却说我先不急，先给其他线程执行吧, 此方法很少被使用到，

守护线程

线程分两种：用户线程：如果主线程main停止掉，不会影响用户线程，用户线程可以继续运行。守护线程：如果主线程死亡，守护线程如果没有执行完毕也要跟着一块死(就像皇上死了，带刀侍卫也要一块死)，GC垃圾回收线程就是守护线程 setDaemon(boolean on)

线程组

可以对线程分组，分组后可以统一管理某个组下的所有线程，例如统一中断所有线程

线程池

多线程(二)：线程池_monday的博客-CSDN博客

线程池好处——降低资源的消耗，提高响应速度，提高线程的可管理性。

常用类

Executors 合理配置： CPU密集(计算)：线程数和CPU核数相等 IO密集(读写)： 2倍的CPU核数

 public class Executors {
     // 线程工厂
     public static ThreadFactory defaultThreadFactory();
 // 创建固定数量n的线程池，如果没有任务，那么线程一直等待, n一般与cpu个数一致(Runtime.getRuntime().availableProcessors())
 // 最为常用 
 public static ExecutorService newFixedThreadPool(int nThreads) {
     return new ThreadPoolExecutor(nThreads, nThreads,
                                   0L, TimeUnit.MILLISECONDS,
                                   new LinkedBlockingQueue<Runnable>());
 }
 
 // 创建一个可缓存的线程池
 public static ExecutorService newCachedThreadPool() {
     return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                   60L, TimeUnit.SECONDS,
                                   new SynchronousQueue<Runnable>());
 }
 
 // 创建只有一个线程的线程池,所有提交的线程是顺序执行的
 public static ExecutorService newSingleThreadExecutor() {
     return new FinalizableDelegatedExecutorService
         (new ThreadPoolExecutor(1, 1,
                                 0L, TimeUnit.MILLISECONDS,
                                 new LinkedBlockingQueue<Runnable>()));
 }
 
 // 创建一个支持定时及周期性的任务执行的线程池，多数情况下可用来替代Timer类
 public static ScheduledExecutorService newSingleThreadScheduledExecutor() {
     return new DelegatedScheduledExecutorService
         (new ScheduledThreadPoolExecutor(1));
 }
 }
 
 public interface ExecutorService extends Executor {
     // 提交可运行任务供执行，并返回表示该任务的未来。未来的get方法将在成功完成后返回
     Future<?> submit(Runnable task);
     <T> Future<T> submit(Runnable task, T result);
     <T> Future<T> submit(Callable<T> task);
     
     // 停止线程池接收新的线程，并且执行完已经接收的线程，执行完毕后结束掉线程池(如果不结束掉可以看到main方法会一直运行不会结束，生成上一般都是保持一直运行不需要关闭的)
     void shutdown();
 }
  public interface ThreadFactory { 
      // 将Runnable包装成Thread          
      Thread newThread(Runnable r); 
  }

Callable 的 call()方法只能通过 ExecutorService 的 submit(Callable task) 方法来执行，并且返回一个 Future，是表示任务等待完成的 Future。

当将一个 Callable 的对象传递给 ExecutorService 的 submit 方法，则该 call 方法自动在一个线程上执行，并且会返回执行结果 Future 对象。同样，将 Runnable 的对象传递给 ExecutorService 的 submit 方法，则该 run 方法自动在一个线程上执行，并且会返回执行结果 Future 对象，但是在该 Future 对象上调用 get 方法，将返回 null。

submit首先选择空闲线程来执行任务，如果没有，才会创建新的线程来执行任务

ExecutorService 的 shutdown()方法来平滑地关闭 ExecutorService，调用该方法后，将导致 ExecutorService 停止接受任何新的任务且等待已经提交的任务执行完成(已经提交的任务会分两类：一类是已经在执行的，另一类是还没有开始执行的)，当所有已经提交的任务执行完毕后将会关闭 ExecutorService。因此我们一般用该接口来实现和管理多线程。

ExecutorService 的生命周期包括三种状态：运行、关闭、终止。创建后便进入运行状态，当调用了 shutdown（）方法时，便进入关闭状态，此时意味着 ExecutorService 不再接受新的任务，但它还在执行已经提交了的任务，当素有已经提交了的任务执行完后，便到达终止状态。如果不调用 shutdown()方法，ExecutorService 会一直处在运行状态，不断接收新的任务，执行新的任务，服务器端一般不需要关闭它，保持一直运行即可。

锁

Java使用synchronized或Lock来定义临界区，保护多个线程共享的字段。

临界区：只允许单个线程执行的程序范围。

多线程(四)：锁_monday的博客-CSDN博客

synchronized

synchronized是Java语言的关键字，当它用来修饰一个方法或者一个代码块的时候，能够保证在同一时刻最多只有一个线程执行该段代码，也就是保证synchronized内的代码块同步执行，而不会并行执行。

synchronized可以作为代码块使用，也可以直接放在方法(对象方法、静态方法)的签名上。作为代码块必须指定一个对象锁，对象锁就是一个对象，可以是this对象(即调用该方法的实例对象)也可以是自己创建的某个对象，也可以是某个类的字节码对象，synchronized修饰的代码属于原子操作，不可再分割！

 // 实例方法使用的是this锁，即调用该对象的实例
 synchronized(this) {
     // code
 }
 Object object = new Object();
 synchronized(object) {
     // code
 }
 // 静态方法是使用的类锁
 synchronized(Xxx.class) {
     // code
 }
 // 对象锁(修饰对象方法，锁为this，即调用该方法的实例对象)
 public synchronized void foo() {
 }
 // 类锁(修饰静态方法，锁为这个类，不是某一个对象)
 public synchronized static void bar() {
 }

Lock

Lock需要手动加锁，释放锁也需要手动释放，释放锁最好(必须)放到finally代码块中释放。注意：同一个锁可以加锁多次(调用多次lock() )，相应的加N次锁也必须解N次锁(unlock())，一般情况下都是加一次锁和解一次锁

package java.util.concurrent.locks;
 
 public interface Lock {
     // 加锁
     void lock();
     void lockInterruptibly() throws InterruptedException;
     boolean tryLock();
     boolean tryLock(long time, TimeUnit unit) throws InterruptedException;
     // 释放锁
     void unlock();
     Condition newCondition();
 }
  package java.util.concurrent.locks; 
 public class ReentrantLock implements Lock, java.io.Serializable {    public boolean isLocked(); } 
  package java.util.concurrent.locks; 
 public interface ReadWriteLock {    
     *// 读锁*    
     Lock readLock();     
     *// 写锁*    
     Lock writeLock(); } 
 public interface Condition {
     // 等待，相当于Object.wait()
     void await() throws InterruptedException;
     long awaitNanos(long nanosTimeout) throws InterruptedException;
     boolean await(long time, TimeUnit unit) throws InterruptedException;
 
     // 唤醒，相当于Object.notify()
     void signal();  
     void signalAll();
 
 }

CAS无锁机制

AtomicInteger:原子数字可以对int型进行自增、自减、相加操作，保证操作的原子性。原子类有AtomicLong、AtomicBoolean、AtomicReference等

 public class AtomicInteger extends Number implements java.io.Serializable {
     private static final long serialVersionUID = 6214790243416807050L;
     // 获取指针类Unsafe
     private static final Unsafe unsafe = Unsafe.getUnsafe();
 
     //下述变量value在AtomicInteger实例对象内的内存偏移量
     private static final long valueOffset;
 
     static {
         try {
            //通过unsafe类的objectFieldOffset()方法，获取value变量在对象内存中的偏移
            //通过该偏移量valueOffset，unsafe类的内部方法可以获取到变量value对其进行取值或赋值操作
             valueOffset = unsafe.objectFieldOffset
                 (AtomicInteger.class.getDeclaredField("value"));
         } catch (Exception ex) { throw new Error(ex); }
     }
 
     //当前AtomicInteger封装的int变量value
     private volatile int value;
 
     public AtomicInteger(int initialValue) {
         value = initialValue;
     }
     public AtomicInteger() {
     }
     //获取当前最新值，
     public final int get() {
         return value;
     }
     //设置当前值，具备volatile效果，方法用final修饰是为了更进一步的保证线程安全。
     public final void set(int newValue) {
         value = newValue;
     }
     //最终会设置成newValue，使用该方法后可能导致其他线程在之后的一小段时间内可以获取到旧值，有点类似于延迟加载
     public final void lazySet(int newValue) {
         unsafe.putOrderedInt(this, valueOffset, newValue);
     }
     //设置新值并获取旧值，底层调用的是CAS操作即unsafe.compareAndSwapInt()方法
     public final int getAndSet(int newValue) {
         return unsafe.getAndSetInt(this, valueOffset, newValue);
     }
     //如果当前值为expect，则设置为update(当前值指的是value变量),更新成功返回true，失败返回false
     public final boolean compareAndSet(int expect, int update) {
         return unsafe.compareAndSwapInt(this, valueOffset, expect, update);
     }
     //当前值加1返回旧值，底层CAS操作
     public final int getAndIncrement() {
         return unsafe.getAndAddInt(this, valueOffset, 1);
     }
     //当前值减1，返回旧值，底层CAS操作
     public final int getAndDecrement() {
         return unsafe.getAndAddInt(this, valueOffset, -1);
     }
     //当前值增加delta，返回旧值，底层CAS操作
     public final int getAndAdd(int delta) {
         return unsafe.getAndAddInt(this, valueOffset, delta);
     }
     //当前值加1，返回新值，底层CAS操作
     public final int incrementAndGet() {
         return unsafe.getAndAddInt(this, valueOffset, 1) + 1;
     }
     //当前值减1，返回新值，底层CAS操作
     public final int decrementAndGet() {
         return unsafe.getAndAddInt(this, valueOffset, -1) - 1;
     }
     //当前值增加delta，返回新值，底层CAS操作
     public final int addAndGet(int delta) {
         return unsafe.getAndAddInt(this, valueOffset, delta) + delta;
     }
 }

volatile

Java多线程干货系列—（四）volatile关键字 | 嘟嘟独立技术

一旦一个共享变量（类的成员变量、类的静态成员变量）被volatile修饰之后，那么就具备了两层语义：

保证了不同线程对这个变量进行操作时的可见性，即一个线程修改了某个变量的值，这新值对其他线程来说是立即可见的。
禁止进行指令重排序。

public class MyThread1 extends Thread {    
     private static boolean flag = true;    
     @Override    
    public void run() {                                
         System.out.println(Thread.currentThread().getName());        
         while (flag){            
         try {
            //线程休眠 使其有时间修改缓存中的值                
            //如果是个空的循环 则flag不会读到堆内存中的值      
         Thread.sleep(1000);            
         } catch (InterruptedException e) {                                     
             e.printStackTrace();            
                                          }        
         }        
        System.out.println("end---------------------------");    
    }        
    public static void main(String[] args) throws InterruptedException {            
         System.out.println(Thread.currentThread().getName());        
            new MyThread1().start();        
            Thread.sleep(1000);        
            flag = false;    
        }
    }

并发中集合ConcurrentHashMap

Map 综述（三）：彻头彻尾理解 ConcurrentHashMap_Rico's Blogs-CSDN博客_concurrenthashmap

后续实战结合文章内容操作暂不继续

阻塞队列

blockingqueue：阻塞尝试插入队列但队列为满的线程；阻塞尝试取出队列为空的线程

两个游标两个等待队列

说一下 runnable 和 callable 有什么区别？

1.实现了runnable接口后无法返回结果信息，实现了callable接口后有返回值。

2.实现了runnable接口异常无法通过throws抛出异常，实现了callable接口后可以直接抛出Exception异常

43. 线程的 run() 和 start() 有什么区别？

44. 创建线程池有哪几种方式？

45. 线程池都有哪些状态？

46. 线程池中 submit() 和 execute() 方法有什么区别？

47. 在 Java 程序中怎么保证多线程的运行安全？

48. 多线程中 synchronized 锁升级的原理是什么？

什么是死锁？

产生死锁的4个必要条件:
①互斥条件:该资源在任意一个时刻只由一个线程占用。
②请求与保持条件:一个线程因请求资源而阻塞时，对已获得的资源保持不放。
③不剥夺条件:线程已获得的资源在末使用完之前不能被其他线程强行剥夺，只有自己使用完毕后才释放资源。
④循环等待条件:若干线程之间形成一种头尾相接的循环等待资源关系

如何避免线程死锁?

产生死锁的四个必要条件，为了避免死锁，我们只要破坏产生死锁的四个条件中的其中一个就可以了
①破坏互斥条件:这个条件我们没有办法破坏，因为我们用锁本来就是想让他们互斥的(临界资源需要互斥访问)。
②破坏请求与保持条件:一次性申请所有的资源。，
③破坏不剥夺条件:占用部分资源的线程进一步申请其他资源时，如果申请不到，可以主动释放它占有的资源。
④破坏循环等待条件:靠按序申请资源来预防。按某一顺序申请资源释放资源则反序释放。破坏循环等待条件。避免死锁最简单的方法就是阻止循环等待条件，将系统中所有的资源设置标志位、排序，规定所有的进程申请资源必须以一定的顺序(升序或降序)做操作来避免死锁。

51. ThreadLocal 是什么？有哪些使用场景？

52. 说一下 synchronized 底层实现原理？

53. synchronized 和 volatile 的区别是什么？

54. synchronized 和 Lock 有什么区别？

55. synchronized 和 ReentrantLock 区别是什么？

56. 说一下 atomic 的原理？

Sick_2W

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
（二）多线程系列面试题

线程多线程(一)：创建线程和线程的常用方法_monday的博客-CSDN博客_线程进程和线程的定义进程是资源（CPU、内存等）分配的基本单位，它是程序执行时的一个实例。程序运行时系统就会创建一个进程，并为它分配资源，然后把该进程放入进程就绪队列，进程调度器选中它的时候就会为它分配CPU时间，程序开始真正运行。线程是一条执行路径，是程序执行时的最小单位，它是进程的一个执行流，是CPU调度和分派的基本单位，一个进程可以由很多个线程组成，线程间共享进程的所有资源，每个线程有自己的堆栈和局部变量。线
复制链接

扫一扫