2024-04-12 / 面试题 JAVA

Java 常见的面试题（多线程）

一、并行和并发有什么区别？

并发：是指多个线程任务在同一个CPU上快速地轮换执行，由于切换的速度非常快，给人的感觉就是这些线程任务是在同时进行的，但其实并发只是一种逻辑上的同时进行；
并行：是指多个线程任务在不同CPU上同时进行，是真正意义上的同时执行。

二、线程和进程的区别？

首先是定义
1. 进程：是执行中一段程序，即一旦程序被载入到内存中并准备执行，它就是一个进程。进程是表示资源分配的的基本概念，又是调度运行的基本单位，是系统中的并发执行的单位。
2. 线程：单个进程中执行中每个任务就是一个线程。线程是进程中执行运算的最小单位。
一个线程只能属于一个进程，但是一个进程可以拥有多个线程。多线程处理就是允许一个进程中在同一时刻执行多个任务。
线程是一种轻量级的进程，与进程相比，线程给操作系统带来侧创建、维护、和管理的负担要轻，意味着线程的代价或开销比较小。
线程没有地址空间，线程包含在进程的地址空间中。线程上下文只包含一个堆栈、一个寄存器、一个优先权，线程文本包含在他的进程的文本片段中，进程拥有的所有资源都属于线程。所有的线程共享进程的内存和资源。同一进程中的多个线程共享代码段(代码和常量)，数据段(全局变量和静态变量)，扩展段(堆存储)。但是每个线程拥有自己的栈段，寄存器的内容，栈段又叫运行时段，用来存放所有局部变量和临时变量。
父和子进程使用进程间通信机制，同一进程的线程通过读取和写入数据到进程变量来通信。
进程内的任何线程都被看做是同位体，且处于相同的级别。不管是哪个线程创建了哪一个线程，进程内的任何线程都可以销毁、挂起、恢复和更改其它线程的优先权。线程也要对进程施加控制，进程中任何线程都可以通过销毁主线程来销毁进程，销毁主线程将导致该进程的销毁，对主线程的修改可能影响所有的线程。
子进程不对任何其他子进程施加控制，进程的线程可以对同一进程的其它线程施加控制。子进程不能对父进程施加控制，进程中所有线程都可以对主线程施加控制。

相同点： 进程和线程都有ID/寄存器组、状态和优先权、信息块，创建后都可更改自己的属性，都可与父进程共享资源、都不能直接访问其他无关进程或线程的资源。

三、守护线程是什么？

在Java中有两类线程：**User Thread(用户线程)、Daemon Thread(守护线程) **

定义：守护线程--也称“服务线程”，在没有用户线程可服务时会自动离开。

优先级：守护线程的优先级比较低，用于为系统中的其它对象和线程提供服务。

设置：通过setDaemon(true)来设置线程为“守护线程”；将一个用户线程设置为守护线程的方式是在线程对象创建之前用线程对象的setDaemon方法。

example: 垃圾回收线程就是一个经典的守护线程，当我们的程序中不再有任何运行的Thread,程序就不会再产生垃圾，垃圾回收器也就无事可做，所以当垃圾回收线程是JVM上仅剩的线程时，垃圾回收线程会自动离开。它始终在低级别的状态中运行，用于实时监控和管理系统中的可回收资源。

生命周期：守护进程（Daemon）是运行在后台的一种特殊进程。它独立于控制终端并且周期性地执行某种任务或等待处理某些发生的事件。也就是说守护线程不依赖于终端，但是依赖于系统，与系统“同生共死”。那Java的守护线程是什么样子的呢。当JVM中所有的线程都是守护线程的时候，JVM就可以退出了；如果还有一个或以上的非守护线程则JVM不会退出。

总结：守护线程类似于gc线程随着主线程的关闭而关闭，但不影响用户线程

四、创建线程有哪几种方式？

继承Thread类型重写run 方法

定义Thread类的子类，并重写该类的run方法，该run方法的方法体就代表了线程要完成的任务。因此把run()方法称为执行体。
创建Thread子类的实例，即创建了线程对象。
调用线程对象的start()方法来启动该线程。


public class ThreadDemoTest extends Thread{
    @Override
    public void run() {
        System.out.println("通过继承Thread类重写run方法实现接口！");
    }
 
    public static void main(String[] args) {
        ThreadDemoTest threadDemoTest = new ThreadDemoTest();
        threadDemoTest.run();
    }
}

实现Runnable接口

定义runnable接口的实现类，并重写该接口的run()方法，该run()方法的方法体同样是该线程的线程执行体。
创建 Runnable实现类的实例，并依此实例作为Thread的target来创建Thread对象，该Thread对象才是真正的线程对象。
调用线程对象的start()方法来启动该线程。


public class RunnableDemoTest implements Runnable{
 
    public void run() {
        System.out.println("实现Runnable开启线程！");
    }
 
    public static void main(String[] args) {
        Thread thread = new Thread(new RunnableDemoTest());
        thread.start();
    }
}

实现Callable接口

创建Callable接口的实现类，并实现call()方法，该call()方法将作为线程执行体，并且有返回值。
创建Callable实现类的实例，使用FutureTask类来包装Callable对象，该FutureTask对象封装了该Callable对象的call()方法的返回值。
使用FutureTask对象作为Thread对象的target创建并启动新线程。
调用FutureTask对象的get()方法来获得子线程执行结束后的返回值


public class CallableDemoTest implements Callable {
    public Object call() {
        return "HelloCallable!";
    }
 
    @Test
    public void test() throws ExecutionException, InterruptedException {
        CallableDemoTest callableDemoTest = new CallableDemoTest();
        FutureTask futureTask = new FutureTask(callableDemoTest);
        Thread thread = new Thread(futureTask);
        thread.start();
        //获取返回值
        futureTask.get();
    }
}

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

Callable接口：


public interface Callable<V> {
    V call() throws Exception;
}

Runnable接口：


public interface Runnable {
    public abstract void run();
}

相同点：

两者都是接口；
两者都可用来编写多线程程序；
两者都需要调用Thread.start()启动线程；

不同点：

两者最大的不同点是：实现Callable接口的任务线程能返回执行结果；而实现Runnable接口的任务线程不能返回结果；
Callable接口的call()方法允许抛出异常；而Runnable接口的run()方法的异常只能在内部消化，不能继续上抛；

注意点：

Callable接口支持返回执行结果，此时需要调用FutureTask.get()方法实现，此方法会阻塞主线程直到获取‘将来’结果；当不调用此方法时，主线程不会阻塞！

Callable工作的Demo：


package com.callable.runnable;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

public class CallableImpl implements Callable<String> {

    public CallableImpl(String acceptStr) {
        this.acceptStr = acceptStr;
    }

    private String acceptStr;

    @Override
    public String call() throws Exception {
        // 任务阻塞 1 秒
        Thread.sleep(1000);
        return this.acceptStr + " append some chars and return it!";
    }


    public static void main(String[] args) throws ExecutionException, InterruptedException {
        Callable<String> callable = new CallableImpl("my callable test!");
        FutureTask<String> task = new FutureTask<>(callable);
        long beginTime = System.currentTimeMillis();
        // 创建线程
        new Thread(task).start();
        // 调用get()阻塞主线程，反之，线程不会阻塞
        String result = task.get();
        long endTime = System.currentTimeMillis();
        System.out.println("hello : " + result);
        System.out.println("cast : " + (endTime - beginTime) / 1000 + " second!");
    }
}

测试结果：


hello : my callable test! append some chars and return it!
cast : 1 second!

Process finished with exit code 0

Runnable工作的Demo：


package com.callable.runnable;

public class RunnableImpl implements Runnable {

    public RunnableImpl(String acceptStr) {
        this.acceptStr = acceptStr;
    }

    private String acceptStr;

    @Override
    public void run() {
        try {
            // 线程阻塞 1 秒，此时有异常产生，只能在方法内部消化，无法上抛
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        // 最终处理结果无法返回
        System.out.println("hello : " + this.acceptStr);
    }


    public static void main(String[] args) {
        Runnable runnable = new RunnableImpl("my runable test!");
        long beginTime = System.currentTimeMillis();
        new Thread(runnable).start();
        long endTime = System.currentTimeMillis();
        System.out.println("cast : " + (endTime - beginTime) / 1000 + " second!");
    }
}

测试结果：


cast : 0 second!
hello : my runable test!

Process finished with exit code 0

六、线程有哪些状态？

线程状态有 5 种，新建，就绪，运行，阻塞，死亡。关系图如下：

****编辑

线程 start 方法执行后，并不表示该线程运行了，而是进入就绪状态，意思是随时准备运行，但是真正何时运行，是由操作系统决定的，代码并不能控制，
同样的，从运行状态的线程，也可能由于失去了 CPU 资源，回到就绪状态，也是由操作系统决定的。这一步中，也可以由程序主动失去 CPU 资源，只需调用 yield 方法。
线程运行完毕，或者运行了一半异常了，或者主动调用线程的 stop 方法，那么就进入死亡。死亡的线程不可逆转。
下面几个行为，会引起线程阻塞。
1. 主动调用 sleep 方法。时间到了会进入就绪状态
2. 主动调用 suspend 方法。主动调用 resume 方法，会进入就绪状态
3. 调用了阻塞式 IO 方法。调用完成后，会进入就绪状态。
4. 试图获取锁。成功的获取锁之后，会进入就绪状态。
5. 线程在等待某个通知。其它线程发出通知后，会进入就绪状态

七、sleep() 和 wait() 有什么区别？

sleep()和wait()都是线程暂停执行的方法。

这两个方法来自不同的类分别是Thread和Object，sleep方法属于Thread类中的静态方法，wait属于Object的成员方法。
sleep() 是线程类（Thread）的方法，不涉及线程通信，调用时会暂停此线程指定的时间，但监控依然保持，不会释放对象锁 ，到时间自动恢复 ；wait() 是Object的方法，用于线程间的通信，调用时会放弃对象锁 ，进入等待队列，待调用notify()/notifyAll()唤醒指定的线程或者所有线程，才进入对象锁定池准备获得对象锁进入运行状态。
wait，notify和notifyAll只能在同步控制方法 或者同步控制块 里面使用，而sleep可以在任何地方使用（使用范围）。
sleep()方法必须捕获异常InterruptedException，而wait()\notify()以及notifyAll()不需要捕获异常。

注意：

sleep方法只让出了CPU，而并不会释放同步资源锁。
线程执行sleep()方法后会转入阻塞状态。
sleep()方法指定的时间为线程不会运行的最短时间。因此，sleep()方法不能保证该线程睡眠到期后就开始执行。
notify的作用相当于叫醒睡着的人，而并不会给他分配任务，就是说notify只是让之前调用wait的线程有权利重新参与线程的调度。

解释说明：

sleep：Thread类中定义的方法，表示线程休眠，会自动唤醒；
wait：Object中定义的方法，需要手工调用notify()或者notifyAll()方法。
sleep是线程类（Thread）的方法，导致此线程暂停执行指定时间，给执行机会给其他线程，但是监控状态依然保持，到时后会自动恢复。调用sleep不会释放对象锁。 wait是Object类的方法，对此对象调用wait方法导致本线程放弃对象锁，进入等待此对象的等待锁定池，只有针对此对象发出notify方法（或notifyAll）后本线程才进入对象锁定池准备获得对象锁进入运行状态。
sleep就是正在执行的线程主动让出cpu，cpu去执行其他线程，在sleep指定的时间过后，cpu才会回到这个线程上继续往下执行，如果当前线程进入了同步锁，sleep方法并不会释放锁，即使当前线程使用sleep方法让出了cpu，但其他被同步锁挡住了的线程也无法得到执行。wait是指在一个已经进入了同步锁的线程内，让自己暂时让出同步锁，以便其他正在等待此锁的线程可以得到同步锁并运行，只有其他线程调用了notify方法（notify并不释放锁，只是告诉调用过wait方法的线程可以去参与获得锁的竞争了，但不是马上得到锁，因为锁还在别人手里，别人还没释放。如果notify方法后面的代码还有很多，需要这些代码执行完后才会释放锁，可以在notfiy方法后增加一个等待和一些代码，看看效果），调用wait方法的线程就会解除wait状态和程序可以再次得到锁后继续向下运行。

八、notify()和 notifyAll()有什么区别？

等待池： 假设一个线程A调用了某个对象的wait()方法，线程A就会释放该对象的锁后，进入到了该对象的等待池，等待池中的线程不会去竞争该对象的锁。

锁池： 只有获取了对象的锁，线程才能执行对象的 synchronized 代码，对象的锁每次只有一个线程可以获得，其他线程只能在锁池中等待

区别： notify() 方法随机唤醒对象的等待池中的一个线程，进入锁池；notifyAll() 唤醒对象的等待池中的所有线程，进入锁池。

九、线程的 run()和 start()有什么区别？

每个线程都是通过某个特定 Thread 对象所对应的方法 run() 来完成其操作的，方法 run() 称为线程体。通过调用 Thread 类的 start() 方法来启动一个线程。

start() 方法来启动一个线程，真正实现了多线程运行。这时无需等待 run() 方法体代码执行完毕，可以直接继续执行下面的代码；这时此线程是处于就绪状态，并没有运行。然后通过此 Thread 类调用方法 run() 来完成其运行状态，这里方法 run() 称为线程体，它包含了要执行的这个线程的内容， run() 方法运行结束，此线程终止。然后CPU再调度其它线程。

**run() ** 方法是在本线程里的，只是线程里的一个函数，而不是多线程的。如果直接调用 run() ，其实就相当于是调用了一个普通函数而已，直接调用 run() 方法必须等待 run() 方法执行完毕才能执行下面的代码，所以执行路径还是只有一条，根本就没有线程的特征。

所以在多线程执行时要使用 start() 方法，而不是 run() 方法。

十、创建线程池有哪几种方式？

newCachedThreadPool()： 创建一个可缓存的线程池，如果线程池的规模超过了处理需求，将自动回收空闲线程，而当需求增加时，则可以自动添加新线程，线程池的规模不存在任何限制。


//newCachedThreadPool 
public static void main(String[] args) {  
	ExecutorService cachedThreadPool = Executors.newCachedThreadPool();  
	for (int i = 0; i < 10; i++) {  
		final int index = i;  
		try {  
			Thread.sleep(10);  
		} catch (InterruptedException e) {  
			e.printStackTrace();  
		}  
		cachedThreadPool.execute(new Runnable() {  
			public void run() {  
				System.out.println(index);  
			}  
		});  
	}  
}

newFixedThreadPool(2)： 创建一个固定长度的线程池，每当提交一个任务就创建一个线程，直到达到线程池的最大数量，超出的线程会在队列中等待。


//newFixedThreadPool 
public static void main(String[] args) {  
	ExecutorService fixedThreadPool = Executors.newFixedThreadPool(3);  
	for (int i = 0; i < 10; i++) {  
		final int index = i;  
		fixedThreadPool.execute(new Runnable() {  
			public void run() {  
				try {  
					System.out.println(index);  
					Thread.sleep(10);  
				} catch (InterruptedException e) {  
					e.printStackTrace();  
				}  
			}  
		});  
	}  
}

new ScheduledThreadPool(2)： 创建了一个固定长度的线程池，而且以延迟或定时的方式来执行任务，类似于Timer。


//newScheduledThreadPool
public static void main(String[] args) {  
	ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);  
	for (int i = 0; i < 10; i++) {  
		scheduledThreadPool.schedule(new Runnable() {  
			public void run() {  
				System.out.println("delay 3 seconds");  
			}  
		}, 3, TimeUnit.SECONDS);  
	}  
 
}

new SingleThreadExecutor()： 创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。


//newSingleThreadExecutor
public static void main(String[] args) {  
	ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();  
	for (int i = 0; i < 10; i++) {  
		final int index = i;  
		singleThreadExecutor.execute(new Runnable() {  
			public void run() {  
/*                  System.out.println(index);*/  
				try {  
					System.out.println(index);  
					Thread.sleep(2000);  
				} catch (InterruptedException e) {  
					e.printStackTrace();  
				}  
			}  
		});  
	}  
}

newSingleThreadScheduledExecutor()： 创建一个单例线程池，定期或延时执行任务。


//newSingleThreadScheduledExecutor
public class ThreadpoolsSingleThreadScheduled {
  
    public static  void main(String[]args) {
        ScheduledExecutorService scheduledExecutorService = Executors.newSingleThreadScheduledExecutor();
 
 
        for(int i=0;i<10;i++)
        {
            final int index=i;
            scheduledExecutorService.schedule(new ThreadForpools(index),3, TimeUnit.SECONDS);
 
        }
    }
}

newWorkStealingPool(3)： 创建一个带并行级别的线程池，并行级别决定了同一时刻最多有多少个线程在执行，如不穿如并行级别参数，将默认为当前系统的CPU个数。


//newWorkStealingPool
public class ThreadpoolsWorkStealingPool {
	public static void main(String[] args) throws Exception {
 
		// 设置并行级别为2，即默认每时每刻只有2个线程同时执行
		ExecutorService executorService = Executors.newWorkStealingPool(3);
 
		for (int i = 1; i <= 50; i++) {
			final int count=i;
			executorService.submit(new ThreadForpools(count));
		}
		while(true){
			//主线程陷入死循环，来观察结果，否则是看不到结果的
		}
	}
}

十一、线程池都有哪些状态？

**RUNNING ** ：能接受新提交的任务，并且也能处理阻塞队列中的任务；
SHUTDOWN ：关闭状态，不再接受新提交的任务，但却可以继续处理阻塞队列中已保存的任务。在线程池处于 RUNNING 状态时，调用 shutdown()方法会使线程池进入到该状态。（finalize() 方法在执行过程中也会调用shutdown()方法进入该状态）；
STOP ：不能接受新任务，也不处理队列中的任务，会中断正在处理任务的线程。在线程池处于 RUNNING 或 SHUTDOWN 状态时，调用 shutdownNow() 方法会使线程池进入到该状态；
TIDYING ：如果所有的任务都已终止了，workerCount (有效线程数) 为0，线程池进入该状态后会调用 terminated() 方法进入TERMINATED 状态。
TERMINATED ：在terminated() 方法执行完后进入该状态，默认terminated()方法中什么也没有做。

进入TERMINATED的条件如下：

线程池不是RUNNING状态；
线程池状态不是TIDYING状态或TERMINATED状态；
如果线程池状态是SHUTDOWN并且workerQueue为空；
workerCount为0；
设置TIDYING状态成功。

线程池的生命周期流程图

****编辑

十二、线程池中 submit()和 execute()方法有什么区别？

execute 方法执行完成后没有返回值，而submit方法执行后有返回值

方法所在的类不同：

execute 方法：java.util.concurrent.Executor;
submit方法：java.util.concurrent.ExecutorService

所需要的参数不同：

execute : java.util.concurrent.Executor#execute(java.lang.Runnable)

submit: java.util.concurrent.ExecutorService#submit(java.lang.Runnable, T),


  java.util.concurrent.ExecutorService#submit(java.lang.Runnable)

  java.util.concurrent.ExecutorService#submit(java.util.concurrent.Callable<T>)


public class MainTest {

    public static void main(String[] args) throws Exception {
        ExecutorService pool = Executors.newFixedThreadPool(10);
        pool.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println("execute");
            }
        });

        Future<?> submit = pool.submit(new Runnable() {
            @Override
            public void run() {
                System.out.println("submit");
            }
        });
        //等任务执行完毕会打印null
        System.out.println(submit.get());

        FutureTask<Integer> submit2 = (FutureTask<Integer>) pool.submit(new Callable<Integer>() {
            @Override
            public Integer call() throws Exception {
                System.out.println("submit_2");
                return 2;
            }
        });
        System.out.println("result=" + submit2.get());
    }

}

十三、在 java 程序中怎么保证多线程的运行安全？

线程的安全性问题体现在：* 原子性：一个或者多个操作在 CPU 执行的过程中不被中断的特性

可见性：一个线程对共享变量的修改，另外一个线程能够立刻看到
有序性：程序执行的顺序按照代码的先后顺序执行

导致原因：

缓存导致的可见性问题
线程切换带来的原子性问题
编译优化带来的有序性问题

解决办法：

JDK Atomic开头的原子类、synchronized、LOCK，可以解决原子性问题
synchronized、volatile、LOCK，可以解决可见性问题
Happens-Before 规则可以解决有序性问题

Happens-Before 规则如下：

程序次序规则：在一个线程内，按照程序控制流顺序，书写在前面的操作先行发生于书写在后面的操作
管程锁定规则：一个unlock操作先行发生于后面对同一个锁的lock操作
volatile变量规则：对一个volatile变量的写操作先行发生于后面对这个变量的读操作
线程启动规则：Thread对象的start()方法先行发生于此线程的每一个动作
线程终止规则：线程中的所有操作都先行发生于对此线程的终止检测
线程中断规则：对线程interrupt()方法的调用先行发生于被中断线程的代码检测到中断事件的发生
对象终结规则：一个对象的初始化完成(构造函数执行结束)先行发生于它的finalize()方法的开始

十四、多线程锁的升级原理是什么？

锁的级别从低到高：无锁 -> 偏向锁 -> 轻量级锁 -> 重量级锁

锁分级别原因： 没有优化以前，synchronized是重量级锁（悲观锁），使用 wait 和 notify、notifyAll 来切换线程状态非常消耗系统资源；线程的挂起和唤醒间隔很短暂，这样很浪费资源，影响性能。所以 JVM 对 synchronized关键字进行了优化，把锁分为无锁、偏向锁、轻量级锁、重量级锁状态。

无锁：没有对资源进行锁定，所有的线程都能访问并修改同一个资源，但同时只有一个线程能修改成功，其他修改失败的线程会不断重试直到修改成功。
偏向锁：对象的代码一直被同一线程执行，不存在多个线程竞争，该线程在后续的执行中自动获取锁，降低获取锁带来的性能开销。偏向锁，指的就是偏向第一个加锁线程，该线程是不会主动释放偏向锁的，只有当其他线程尝试竞争偏向锁才会被释放。偏向锁的撤销，需要在某个时间点上没有字节码正在执行时，先暂停拥有偏向锁的线程，然后判断锁对象是否处于被锁定状态。如果线程不处于活动状态，则将对象头设置成无锁状态，并撤销偏向锁；如果线程处于活动状态，升级为轻量级锁的状态。
轻量级锁：轻量级锁是指当锁是偏向锁的时候，被第二个线程 B 所访问，此时偏向锁就会升级为轻量级锁，线程 B 会通过自旋的形式尝试获取锁，线程不会阻塞，从而提高性能。当前只有一个等待线程，则该线程将通过自旋进行等待。但是当自旋超过一定的次数时，轻量级锁便会升级为重量级锁；当一个线程已持有锁，另一个线程在自旋，而此时又有第三个线程来访时，轻量级锁也会升级为重量级锁。
重量级锁：指当有一个线程获取锁之后，其余所有等待获取该锁的线程都会处于阻塞状态。重量级锁通过对象内部的监视器（monitor）实现，而其中 monitor 的本质是依赖于底层操作系统的 Mutex Lock 实现，操作系统实现线程之间的切换需要从用户态切换到内核态，切换成本非常高。
锁状态对比：

	偏向锁	轻量级锁	重量级锁
适用场景	只有一个线程进入同步块	虽然很多线程，但是没有冲突：多条线程进入同步块，但是线程进入时间错开因而并未争抢锁	发生了锁争抢的情况：多条线程进入同步块并争用锁
本质	取消同步操作	CAS操作代替互斥同步	互斥同步
优点	不阻塞，执行效率高（只有第一次获取偏向锁时需要CAS操作，后面只是比对ThreadId）	不会阻塞	不会空耗CPU
缺点	适用场景太局限。若竞争产生，会有额外的偏向锁撤销的消耗	长时间获取不到锁空耗CPU	阻塞，上下文切换，重量级操作，消耗操作系统资源

十五、什么是死锁？

所谓死锁，是指多个进程在运行过程中因争夺资源而造成的一种僵局，当进程处于这种僵持状态时，若无外力作用，它们都将无法再向前推进。

产生死锁的原因？

竞争资源
- 系统中的资源可以分为两类：
  1. 另一类资源是不可剥夺资源，当系统把这类资源分配给某进程后，再不能强行收回，只能在进程用完后自行释放，如磁带机、打印机等。
  2. 可剥夺资源，是指某进程在获得这类资源后，该资源可以再被其他进程或系统剥夺，CPU和主存均属于可剥夺性资源；
- 产生死锁中的竞争资源之一指的是竞争不可剥夺资源（例如：系统中只有一台打印机，可供进程P1使用，假定P1已占用了打印机，若P2继续要求打印机打印将阻塞）
- 产生死锁中的竞争资源另外一种资源指的是竞争临时资源（临时资源包括硬件中断、信号、消息、缓冲区内的消息等），通常消息通信顺序进行不当，则会产生死锁
进程间推进顺序非法
- 若P1保持了资源R1,P2保持了资源R2，系统处于不安全状态，因为这两个进程再向前推进，便可能发生死锁
- 例如，当P1运行到P1：Request（R2）时，将因R2已被P2占用而阻塞；当P2运行到P2：Request（R1）时，也将因R1已被P占用而阻塞，于是发生进程死锁

产生死锁的4个必要条件：

互斥条件：进程要求对所分配的资源进行排它性控制，即在一段时间内某资源仅为一进程所占用。
请求和保持条件：当进程因请求资源而阻塞时，对已获得的资源保持不放。
不剥夺条件：进程已获得的资源在未使用完之前，不能剥夺，只能在使用完时由自己释放。
环路等待条件：在发生死锁时，必然存在一个进程--资源的环形链。

十六、解决死锁的基本方法

预防死锁：

资源一次性分配：一次性分配所有资源，这样就不会再有请求了：（破坏请求条件）
只要有一个资源得不到分配，也不给这个进程分配其他的资源：（破坏请保持条件）
可剥夺资源：即当某进程获得了部分资源，但得不到其它资源，则释放已占有的资源（破坏不可剥夺条件）
资源有序分配法：系统给每类资源赋予一个编号，每一个进程按编号递增的顺序请求资源，释放则相反（破坏环路等待条件）

以确定的顺序获得锁：

如果必须获取多个锁，那么在设计的时候需要充分考虑不同线程之前获得锁的顺序。按照上面的例子，两个线程获得锁的时序图如下：

****编辑

如果此时把获得锁的时序改成：

****编辑

那么死锁就永远不会发生。针对两个特定的锁，开发者可以尝试按照锁对象的hashCode值大小的顺序，分别获得两个锁，这样锁总是会以特定的顺序获得锁，那么死锁也不会发生。问题变得更加复杂一些，如果此时有多个线程，都在竞争不同的锁，简单按照锁对象的hashCode进行排序（单纯按照hashCode顺序排序会出现“环路等待”），可能就无法满足要求了，这个时候开发者可以使用银行家算法，所有的锁都按照特定的顺序获取，同样可以防止死锁的发生，该算法在这里就不再赘述了，有兴趣的可以自行了解一下。

超时放弃：

当使用synchronized关键词提供的内置锁时，只要线程没有获得锁，那么就会永远等待下去，然而Lock接口提供了boolean tryLock(long time, TimeUnit unit) throws InterruptedException方法，该方法可以按照固定时长等待锁，因此线程可以在获取锁超时以后，主动释放之前已经获得的所有的锁。通过这种方式，也可以很有效地避免死锁。还是按照之前的例子，时序图如下：

****编辑

避免死锁：

预防死锁的几种策略，会严重地损害系统性能。因此在避免死锁时，要施加较弱的限制，从而获得较满意的系统性能。由于在避免死锁的策略中，允许进程动态地申请资源。因而，系统在进行资源分配之前预先计算资源分配的安全性。若此次分配不会导致系统进入不安全的状态，则将资源分配给进程；否则，进程等待。其中最具有代表性的避免死锁算法是银行家算法。
银行家算法：首先需要定义状态和安全状态的概念。系统的状态是当前给进程分配的资源情况。因此，状态包含两个向量Resource（系统中每种资源的总量）和Available（未分配给进程的每种资源的总量）及两个矩阵Claim（表示进程对资源的需求）和Allocation（表示当前分配给进程的资源）。安全状态是指至少有一个资源分配序列不会导致死锁。当进程请求一组资源时，假设同意该请求，从而改变了系统的状态，然后确定其结果是否还处于安全状态。如果是，同意这个请求；如果不是，阻塞该进程知道同意该请求后系统状态仍然是安全的。

检测死锁：

首先为每个进程和每个资源指定一个唯一的号码；
然后建立资源分配表和进程等待表。

解除死锁：

当发现有进程死锁后，便应立即把它从死锁状态中解脱出来，常采用的方法有：

剥夺资源：从其它进程剥夺足够数量的资源给死锁进程，以解除死锁状态；
撤消进程：可以直接撤消死锁进程或撤消代价最小的进程，直至有足够的资源可用，死锁状态.消除为止；所谓代价是指优先级、运行代价、进程的重要性和价值等。

十七、ThreadLocal 是什么？有哪些使用场景？

ThreadLocal：

Synchronized用于线程间的数据共享，而ThreadLocal则用于线程间的数据隔离。在同步机制中，通过对象的锁机制保证同一时间只有一个线程访问变量。

而ThreadLocal则从另一个角度来解决多线程的并发访问。ThreadLocal会为每一个线程提供一个独立的变量副本，从而隔离了多个线程对数据的访问冲突。

ThreadLocal在每个本地线程中创建了一个ThreadLocalMap对象，每个线程可以访问自己内部ThreadLocalMap对象里的value。通过这种方式，实现线程之间的数据隔离。

经典的使用场景是：

为每个线程分配一个JDBC连接的Connection。这样可以保证每个线程都在各自的Connection上进行数据库的操作，不会出现A线程关闭了线程B正在使用的Connection。

十八、说一下 synchronized 底层实现原理？

作用

确保线程互斥的访问同步代码
保证共享变量的修改能够及时可见
有效解决重排序问题

用法

修饰普通方法
修饰静态方法
修饰代码块

原理

同步代码块是通过 monitorenter 和 monitorexit 指令获取线程的执行权
同步方法通过加 ACC_SYNCHRONIZED 标识实现线程的执行权的控制

十九、synchronized 和 volatile 的区别是什么？

作用：

synchronized 表示只有一个线程可以获取作用对象的锁，执行代码，阻塞其他线程。
volatile 表示变量在 CPU 的寄存器中是不确定的，必须从主存中读取。保证多线程环境下变量的可见性；禁止指令重排序。

区别：

synchronized 可以作用于变量、方法、对象；volatile 只能作用于变量。
synchronized 可以保证线程间的有序性（猜测是无法保证线程内的有序性，即线程内的代码可能被 CPU 指令重排序）、原子性和可见性；volatile 只保证了可见性和有序性，无法保证原子性。
synchronized 线程阻塞，volatile 线程不阻塞。

二十、synchronized 和 Lock 有什么区别？

实现层面不一样。synchronized 是 Java 关键字，JVM层面实现加锁和释放锁；Lock 是一个接口，在代码层面实现加锁和释放锁
是否自动释放锁。synchronized 在线程代码执行完或出现异常时自动释放锁；Lock 不会自动释放锁，需要再 finally {} 代码块显式地中释放锁
是否一直等待。synchronized 会导致线程拿不到锁一直等待；Lock 可以设置尝试获取锁或者获取锁失败一定时间超时
获取锁成功是否可知。synchronized 无法得知是否获取锁成功；Lock 可以通过 tryLock 获得加锁是否成功
功能复杂性。synchronized 加锁可重入、不可中断、非公平；Lock 可重入、可判断、可公平和不公平、细分读写锁提高效率

二十一、synchronized 和 ReentrantLock 区别是什么？

synchronized 竞争锁时会一直等待；ReentrantLock 可以尝试获取锁，并得到获取结果
synchronized 获取锁无法设置超时；ReentrantLock 可以设置获取锁的超时时间
synchronized 无法实现公平锁；ReentrantLock 可以满足公平锁，即先等待先获取到锁
synchronized 控制等待和唤醒需要结合加锁对象的 wait() 和 notify()、notifyAll()；ReentrantLock 控制等待和唤醒需要结合 Condition 的 await() 和 signal()、signalAll() 方法
synchronized 是 JVM 层面实现的；ReentrantLock 是 JDK 代码层面实现
synchronized 在加锁代码块执行完或者出现异常，自动释放锁；ReentrantLock 不会自动释放锁，需要在 finally{} 代码块显示释放

补充一个相同点：都可以做到同一线程，同一把锁，可重入代码块。

二十二、说一下 atomic 的原理？

线程安全： 当多个线程访问某个类时，不管运行时环境采用何种调度方式或者这些进程将如何交替执行，并且在主调代码中不需要任何额外的同步或协调，这个类都能表现出正确的行为，那么就称这个类时线程安全的。

线程安全主要体现在以下三个方面：

原子性：提供了互斥访问，同一时刻只能有一个线程对它进行操作
可见性：一个线程对主内存的修改可以及时的被其他线程观察到
有序性：一个线程观察其他线程中的指令执行顺序，由于指令重排序的存在，该观察结果一般杂乱无序

引子

在多线程的场景中，我们需要保证数据安全，就会考虑同步的方案，通常会使用synchronized或者lock来处理，使用了synchronized意味着内核态的一次切换。这是一个很重的操作。

有没有一种方式，可以比较便利的实现一些简单的数据同步，比如计数器等等。concurrent包下的atomic提供我们这么一种轻量级的数据同步的选择。


import java.util.concurrent.CountDownLatch; 
import java.util.concurrent.atomic.AtomicInteger; 
  
public class App { 
  
 public static void main(String[] args) throws Exception { 
  CountDownLatch countDownLatch = new CountDownLatch(100); 
  
  AtomicInteger atomicInteger = new AtomicInteger(0); 
  for (int i = 0; i < 100; i++) { 
   new Thread() { 
    @Override
    public void run() { 
     atomicInteger.getAndIncrement(); 
  
     countDownLatch.countDown(); 
    } 
   }.start(); 
  } 
  
  countDownLatch.await(); 
  
  System.out.println(atomicInteger.get()); 
 } 
}

注：以上内容仅提供参考和交流，请勿用于商业用途，如有侵权联系本人删除！

注：此博客只是为了记忆相关知识点，大部分为网络上的文章，在此向各个文章的作者表示感谢！

标题：Java 常见的面试题（多线程）
作者：wangjing
地址：https://www.codedblogs.cn/articles/2024/04/12/1712888223941.html

王京的个人博客

记录精彩的程序人生

Java 常见的面试题（多线程）

一、并行和并发有什么区别？

二、线程和进程的区别？

三、守护线程是什么？

四、创建线程有哪几种方式？

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

六、线程有哪些状态？

七、sleep() 和 wait() 有什么区别？

八、notify()和 notifyAll()有什么区别？

九、线程的 run()和 start()有什么区别？

十、创建线程池有哪几种方式？

十一、线程池都有哪些状态？

十二、线程池中 submit()和 execute()方法有什么区别？

十三、在 java 程序中怎么保证多线程的运行安全？

十四、多线程锁的升级原理是什么？

十五、什么是死锁？

十六、解决死锁的基本方法

预防死锁：

避免死锁：

检测死锁：

解除死锁：

十七、ThreadLocal 是什么？有哪些使用场景？

十八、说一下 synchronized 底层实现原理？

十九、synchronized 和 volatile 的区别是什么？

二十、synchronized 和 Lock 有什么区别？

二十一、synchronized 和 ReentrantLock 区别是什么？

二十二、说一下 atomic 的原理？