四分钟快速入门Java线程的六种状态与流转 |
您所在的位置：网站首页 › java多线程会出现哪些问题 › 四分钟快速入门Java线程的六种状态与流转 |
四分钟快速入门Java线程的六种状态与流转
|
1.并行与并发有什么区别？ 并行和并发都是指多个任务同时执行的概念，但是它们之间有着明显的区别。 并行：多个任务在同一时刻同时运行，通常需要使用多个处理器或者多核处理器来实现。例如，一个计算机同时执行多个程序、多个线程或者多个进程时，就是采用并行的方式来处理任务，这样能够提高计算机的处理效率。并发：多个任务同时进行，但是这些任务的执行是交替进行的，即一个任务执行一段时间后，再执行另外一个任务。它是通过操作系统的协作调度来实现各个任务的切换，达到看上去同时进行的效果。例如，一个多线程程序中的多个线程就是同时运行的，但是因为 CPU 只能处理一个线程，所以在任意时刻只有一个线程在执行，线程之间会通过竞争的方式来获取 CPU 的时间片。
总的来说，虽然并行和并发都是多任务处理的方式，但是并行是采用多核处理器等硬件实现任务同步执行，而并发则是通过操作系统的调度算法来合理地分配系统资源，使得多个任务看上去同时执行。 2.说说什么是进程和线程?进程和线程是操作系统中的概念，用于描述程序运行时的执行实体。 进程：一个程序在执行过程中的一个实例，每个进程都有自己独立的地址空间，也就是说它们不能直接共享内存。进程的特点包括： 需要占用独立的内存空间；可以并发地执行多个任务；进程之间需要通过进程间通信（IPC）来交换数据；线程：进程中的一个执行单元，一个进程中可以包含多个线程，这些线程共享进程的内存空间。线程的特点包括： 线程共享进程内存空间，可以方便、高效地访问变量；同一个进程中的多个线程可以并发地执行多个任务；线程之间切换开销小，可以实现更细粒度的控制，例如 UI 线程控制界面刷新，工作线程进行耗时的计算等。
线程相比于进程，线程的创建和销毁开销较小，上下文切换开销也较小，因此线程是实现多任务并发的一种更加轻量级的方式。 3.说说线程有几种创建方式？Java中创建线程主要有三种方式：
JVM执行start方法，会先创建一个线程，由创建出来的新线程去执行thread的run方法，这才起到多线程的效果。 start()和run()的主要区别如下： start方法可以启动一个新线程，run方法只是类的一个普通方法而已，如果直接调用run方法，程序中依然只有主线程这一个线程。start方法实现了多线程，而run方法没有实现多线程。start不能被重复调用，而run方法可以。start方法中的run代码可以不执行完，就继续执行下面的代码，也就是说进行了线程切换。然而，如果直接调用run方法，就必须等待其代码全部执行完才能继续执行下面的代码。/** * Created by BaiLi */ public class BaiLiDemo { public static void main(String[] args) { Thread thread = new Thread(() -> System.out.println(Thread.currentThread().getName()+":一键三连")); thread.start(); thread.run(); thread.run(); System.out.println(Thread.currentThread().getName()+":一键三连 + 分享"); } }5.线程有哪些常用的调度方法
线程在自身的生命周期中， 并不是固定地处于某个状态，而是随着代码的执行在不同的状态之间进行切换，如下图：
线程上下文切换指的是在多线程运行时，操作系统从当前正在执行的线程中保存其上下文（包括当前线程的寄存器、程序指针、栈指针等状态信息），并将这些信息恢复到另一个等待执行的线程中，从而实现线程之间的切换。
线程间通信是指在多线程编程中，各个线程之间共享信息或者协同完成某一任务的过程。常用的线程间通信方式有以下几种： 共享变量：共享变量是指多个线程都可以访问和修改的变量，它们通常是在主线程中创建的。多个线程对同一个共享变量进行读写操作时，可能会出现竞态条件导致数据错误或程序异常。因此需要使用同步机制比如synchronized、Lock等来保证线程安全管道通信：管道是一种基于文件描述符的通信机制，形成一个单向通信的数据流管道。它通常用于只有两个进程或线程之间的通信。其中一个进程将数据写入到管道（管道的输出端口），而另一个进程从管道的输入端口读取数据信号量：信号量是一种计数器，用于控制多个线程对资源的访问。当一个线程需要访问资源时，它需要申请获取信号量，如果信号量的计数器值大于 0，则可以访问资源，否则该线程就会等待。当线程结束访问资源后，需要释放信号量，并将计数器加1条件变量：条件变量是一种通知机制，用于在多个线程之间传递状态信息和控制信息。当某个线程需要等待某个条件变量发生改变时，它可以调用 wait() 方法挂起，并且释放所占用的锁。当某个线程满足条件后，可以调用 notify() 或者 signal() 方法来通知等待该条件变量的线程继续执行/** * 共享变量 * 创建人：百里 */ public class BaiLiSharedMemoryDemo { public static void main(String[] args) { ArrayList integers = new ArrayList(); Thread producerThread = new Thread(() -> { for (int i = 0; i < 5; i++) { synchronized (integers) { integers.add(i); System.out.println(Thread.currentThread().getName() + "_Producer:" + i); } try { Thread.sleep(2000); } catch (InterruptedException e) { e.printStackTrace(); } } }, "ProducerThread"); Thread consumeThread = new Thread(() -> { while (true) { synchronized (integers) { if (!integers.isEmpty()) { Integer integer = integers.remove(0); System.out.println(Thread.currentThread().getName() + "_Consume:" + integer); } } try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } } }, "ConsumeThread"); producerThread.start(); consumeThread.start(); } }/** * 管道通信模式 * 创建人：百里 */ public class BaiLiPipedStreamDemo { public static void main(String[] args) throws IOException { //输出管道 PipedOutputStream pipedOutputStream = new PipedOutputStream(); //输入管道 PipedInputStream pipedInputStream = new PipedInputStream(); pipedInputStream.connect(pipedOutputStream); Thread producerThread = new Thread(() -> { try { for (int i = 0; i < 5; i++) { pipedOutputStream.write(i); System.out.println(Thread.currentThread().getName() + "_Produce: " + i); Thread.sleep(2000); } pipedOutputStream.close(); } catch (IOException | InterruptedException e) { e.printStackTrace(); } }, "ProducerThread"); Thread consumeThread = new Thread(() -> { try { for (int i = 0; i < 5; i++) { while (true) { int read = pipedInputStream.read(); if (read != -1) { System.out.println(Thread.currentThread().getName() + "_Consume: " + read); } else { break; } Thread.sleep(1000); } } pipedInputStream.close(); } catch (IOException | InterruptedException e) { e.printStackTrace(); } }, "ConsumeThread"); producerThread.start(); consumeThread.start(); } }/** * 信号量 * 创建人：百里 */ public class BaiLiSemaphoreDemo { public static void main(String[] args) { // 实例化一个信号量对象，初始值为 0 Semaphore semaphore = new Semaphore(0); // 创建生产者线程 Thread producerThread = new Thread(() -> { try { for (int i = 0; i < 5; i++) { System.out.println(Thread.currentThread().getName() + "_Producer:" + i); semaphore.release(); // 把信号量的计数器加 1 Thread.sleep(1000); //模拟停顿 } } catch (InterruptedException e) { e.printStackTrace(); } }, "ProducerThread"); // 创建消费者线程 Thread consumeThread = new Thread(() -> { try { for (int i = 0; i < 5; i++) { semaphore.acquire(); // 请求占有信号量，如果计数器不为 0，计数器减 1，否则线程阻塞等待 System.out.println(Thread.currentThread().getName() + "_Consume:" + i); Thread.sleep(1000); //模拟停顿 } } catch (InterruptedException e) { e.printStackTrace(); } }, "ConsumeThread"); producerThread.start(); consumeThread.start(); } }/** * 条件变量|可重入锁 * 创建人：百里 */ public class BaiLIConditionDemo { public static void main(String[] args) { // 实例化一个可重入锁对象 ReentrantLock lock = new ReentrantLock(); // 获取该锁对象的条件变量 Condition condition = lock.newCondition(); // 创建生产者线程 Thread producerThread = new Thread(() -> { try { lock.lock(); // 获取锁对象 for (int i = 1; i { try { lock.lock(); // 获取锁对象 for (int i = 1; i { System.out.println(threadLocal.get()); threadLocal.set(0); System.out.println(threadLocal.get()); },"Thread-1"); Thread thread2 = new Thread(() -> { System.out.println(threadLocal.get()); threadLocal.set(1); System.out.println(threadLocal.get()); },"Thread-2"); thread1.start(); thread1.join(); thread2.start(); thread2.join(); } }10.ThreadLocal怎么实现？ThreadLocal是Java中所提供的线程本地存储机制，可以利用该机制将数据缓存在某个线程内部，该线程可以在任意时刻、任意方法中获取缓存的数据ThreadLocal底层是通过ThreadLocalMap来实现的，每个Thread对象（注意不是ThreadLocal对象）中都存在一个ThreadLocalMap，Map的key为ThreadLocal对象，Map的value为需要缓存的值
实现方式观察ThreadLocal的set方法： public void set(T value) { Thread t = Thread.currentThread(); ThreadLocalMap map = getMap(t); if (map != null) map.set(this, value); else createMap(t, value); } ThreadLocalMap getMap(Thread t) { return t.threadLocals; } ThreadLocal.ThreadLocalMap threadLocals = null; static class Entry extends WeakReference k = e.get(); if (k == null) { e.value = null; // Help the GC } else { int h = k.threadLocalHashCode & (newLen - 1); while (newTab[h] != null) h = nextIndex(h, newLen); newTab[h] = e; count++; } } } setThreshold(newLen); size = count; table = newTab; }15.ThreadLocal怎么进行父子线程通信在Java多线程编程中，父子线程之间的数据传递和共享问题一直是一个非常重要的议题。如果不处理好数据的传递和共享，会导致多线程程序的性能下降或者出现线程安全问题。ThreadLocal是Java提供的一种解决方案，可以非常好地解决父子线程数据共享和传递的问题。 那么它是如何实现通信的了？在Thread类中存在InheritableThreadLocal变量，简单的说就是使用InheritableThreadLocal来进行传递，当父线程的InheritableThreadLocal不为空时，就会将这个值传到当前子线程的InheritableThreadLocal。 /** * ThreadLocal父子线程通信 * 创建人：百里 */ public class BaiLiInheritableThreadLocalDemo { public static void main(String[] args) throws Exception { ThreadLocal threadLocal = new ThreadLocal(); threadLocal.set("threadLocal"); ThreadLocal inheritableThreadLocal = new InheritableThreadLocal(); inheritableThreadLocal.set("分享 + inheritableThreadLocal"); Thread t = new Thread(() -> { System.out.println("一键三连 + " + threadLocal.get()); System.out.println("一键三连 + " + inheritableThreadLocal.get()); }); t.start(); } }16.说一下你对Java内存模型（JMM）的理解？Java 内存模型（Java Memory Model）是一种规范，用于描述 Java 虚拟机（JVM）中多线程情况下，线程之间如何协同工作，如何共享数据，并保证多线程的操作在各个线程之间的可见性、有序性和原子性。 具体定义如下： 所有的变量都存储在主内存（Main Memory）中。每个线程都有一个私有的本地内存（Local Memory），本地内存中存储了该线程以读/写共享变量的拷贝副本。线程对变量的所有操作都必须在本地内存中进行，而不能直接读写主内存。不同的线程之间无法直接访问对方本地内存中的变量；线程间共享变量时，通过主内存来实现通信、协作和传递信息。Java内存模型的抽象图：
在这个抽象的内存模型中，在两个线程之间的通信（共享变量状态变更）时，会进行如下两个步骤： 线程A把在本地内存更新后的共享变量副本的值，刷新到主内存中。线程B在使用到该共享变量时，到主内存中去读取线程A更新后的共享变量的值，并更新线程B本地内存的值。17.说说你对原子性、可见性、有序性的理解？原子性、有序性、可见性是并发编程中非常重要的基础概念，JMM的很多技术都是围绕着这三大特性展开。 原子性：指一个操作是不可分割、不可中断的，在执行过程中不会受到其他线程的干扰，要么全部执行，要么就全不执行。即使是在多线程的环境下，一个操作也是原子性的执行完成。线程切换会带来原子性问题，示例： int count = 0; //1 count++; //2 int a = count; //3上面展示语句中，除了语句1是原子操作，其它两个语句都不是原子性操作，下面我们来分析一下语句2 其实语句2在执行的时候，包含三个指令操作 指令 1：首先，把变量 count 从内存加载到 CPU 的寄存器指令 2：然后，在寄存器中执行 +1 操作指令 3：最终，将结果写入内存对于上面的三条指令来说，如果线程 A 在指令 1 执行完后做线程切换，线程 A 和线程 B 按照下图的序列执行，那么我们会发现两个线程都执行了 count+=1 的操作，但是得到的结果不是我们期望的 2，而是 1。
原子性、可见性、有序性都应该怎么保证呢？ 原子性：JMM只能保证基本的原子性，如果要保证一个代码块的原子性，需要使用synchronized。可见性：Java是利用volatile关键字来保证可见性的，除此之外，final和synchronized也能保证可见性。有序性：synchronized或者volatile都可以保证多线程之间操作的有序性。18.说说什么是指令重排？在不影响单线程程序执行结果的前提下，计算机为了最大限度的发挥机器性能，对机器指令进行重排序优化。
从Java源代码到最终实际执行的指令序列，会分别经历下面3种重排序：
以双重校验锁单例模式为例子，Singleton instance=new Singleton()；对应的JVM指令分为三步：分配内存空间-->初始化对象--->对象指向分配的内存空间，但是经过了编译器的指令重排序，第二步和第三步就可能会重排序。
JMM属于语言级的内存模型，它确保在不同的编译器和不同的处理器平台之上，通过禁止特定类型的编译器重排序和指令级重排序，为程序员提供一致的内存可见性保证。 19.指令重排有限制吗？happens-before了解吗？指令重排也是有一些限制的，有两个规则happens-before和as-if-serial来约束。 happens-before的定义： 如果一个操作happens-before另一个操作，那么第一个操作的执行结果将对第二个操作可见，而且第一个操作的执行顺序排在第二个操作之前。两个操作之间存在happens-before关系，并不意味着Java平台的具体实现必须要按照 happens-before关系指定的顺序来执行。只要没有改变程序的执行结果，编译器和处理器怎么优化都可以。happens-before的六大规则：
从图中，我们可以看到： “x=42”Happens-Before 写变量“v=true”，这是规则1的内容；写变量“v=true”Happens-Before 读变量“v=true”，这是规则3的内容；再根据这个传递性规则，我们得到结果：“x=42”Happens-Before 读变量“v=true”；这意味着什么呢？如果线程 B 读到了“v=true”，那么线程A设置的“x=42”对线程B是可见的。也就是说，线程B能看到“x == 42“。 /** * 传递性规则 * @author 百里 */ public class BaiLiHappenBeforeVolatileDemo { int x = 0; volatile boolean v = false; public void writer() { x = 42; v = true; } public void reader() { if (v == true) { System.out.println(x); } } }线程启动规则：如果线程A执行操作ThreadB.start()（启动线程B），那么A线程的ThreadB.start()操作happens-before于线程B中的任意操作。
我们可以理解为：线程A启动线程B之后，线程B能够看到线程A在启动线程B之前的操作。 线程结束规则：如果线程A执行操作ThreadB.join()并成功返回，那么线程B中的任意操作 happens-before于 ThreadB.join()操作成功返回后的线程A操作。
在Java语言里面，Happens-Before的语义本质上是一种可见性，A Happens-Before B 意味着A事件对B事件来说是可见的，并且无论A事件和B事件是否发生在同一个线程里。 20.as-if-serial又是什么？单线程的程序一定是顺序的吗？as-if-serial是指无论如何重排序都不会影响单线程程序的执行结果。这个原则的核心思想是编译器和处理器等各个层面的优化，不能改变程序执行的意义。
A和C之间存在数据依赖关系，同时B和C之间也存在数据依赖关系。因此在最终执行的指令序列中，C不能被重排序到A和B的前面（C排到A和B的前面，程序的结果将会被改变）。但A和B之间没有数据依赖关系，编译器和处理器可以重排序A和B之间的执行顺序。 所以最终，程序可能会有两种执行顺序：
volatile有两个作用，保证可见性和有序性。 可见性：当一个变量被声明为 volatile 时，它会告诉编译器和CPU将该变量存储在主内存中，而不是线程的本地内存中。即每个线程读取的都是主内存中最新的值，避免了多线程并发下的数据不一致问题。
有序性：重排序可以分为编译器重排序和处理器重排序，valatile保证有序性，就是通过分别限制这两种类型的重排序。
为了实现volatile的内存语义，编译器在生成字节码时，会在指令序列中插入内存屏障来禁止特定类型的处理器重排序。 在每个volatile写操作的前面插入一个StoreStore屏障在每个volatile写操作的后面插入一个StoreLoad屏障在每个volatile读操作的后面插入一个LoadLoad屏障在每个volatile读操作的后面插入一个LoadStore屏障
synchronized经常用的，用来保证代码的原子性。 synchronized主要有三种用法： 修饰实例方法: 作用于当前对象实例加锁，进入同步代码前要获得当前对象实例的锁。
注意事项： 修饰实例方法：不同的对象实例之间并不会互相影响，它们的锁是相互独立的。因此，如果不同的线程在不同的对象实例上执行同一个同步方法，它们之间并不会因为共享变量而产生互斥的效果。修饰静态方法：应该尽量避免持有锁的时间过长，否则可能会导致其他线程长时间等待，从而影响系统性能。同时，也要注意避免死锁的情况。修饰代码块：同步锁并不是对整个代码块进行加锁，而是对同步锁对象进行加锁。因此，如果在不同的代码块中使用了相同的同步锁对象，它们之间也会产生互斥的效果。而如果使用不同的同步锁对象，则它们之间并不会产生互斥的效果。23.synchronized的实现原理？我们使用synchronized的时候，发现不用自己去lock和unlock，是因为JVM帮我们把这个事情做了。 synchronized修饰代码块时，JVM采用monitorenter、monitorexit两个指令来实现同步，monitorenter 指令指向同步代码块的开始位置， monitorexit 指令则指向同步代码块的结束位置。
synchronized锁住的是什么呢？ 实例对象结构里有对象头，对象头里面有一块结构叫Mark Word，Mark Word指针指向了monitor。 所谓的Monitor其实是一种同步机制，我们可以称为内部锁或者Monitor锁。 monitorenter、monitorexit或者ACC_SYNCHRONIZED都是基于Monitor实现的。 反编译class文件方法： 反编译一段synchronized修饰代码块代码，javap -c -s -v -l ***.class，可以看到相应的字节码指令。 24.synchronized的可见性，有序性，可重入性是怎么实现的？synchronized怎么保证可见性？ 线程加锁前，将清空工作内存中共享变量的值，从而使用共享变量时需要从主内存中重新读取最新的值。线程加锁后，其它线程无法获取主内存中的共享变量。线程解锁前，必须把共享变量的最新值刷新到主内存中。synchronized怎么保证有序性？ synchronized同步的代码块，具有排他性，一次只能被一个线程拥有，所以synchronized保证同一时刻，代码是单线程执行的。 因为as-if-serial语义的存在，单线程的程序能保证最终结果是有序的，但是不保证不会指令重排。 所以synchronized保证的有序是执行结果的有序性，而不是防止指令重排的有序性。 synchronized怎么实现可重入的？ synchronized 是可重入锁，也就是说，允许一个线程二次请求自己持有对象锁的临界资源，这种情况称为可重入锁。 之所以是可重入的。是因为 synchronized 锁对象有个计数器，当一个线程请求成功后，JVM会记下持有锁的线程，并将计数器计为1。此时其他线程请求该锁，则必须等待。而该持有锁的线程如果再次请求这个锁，就可以再次拿到这个锁，同时计数器会递增。 当线程执行完毕后，计数器会递减，直到计数器为0才释放该锁。 25.说说synchronized和ReentrantLock的区别可以从锁的实现、性能、功能特点等几个维度去回答这个问题： 锁的实现： synchronized是Java语言的关键字，基于JVM实现。而ReentrantLock是基于JDK的API层面实现的（一般是lock()和unlock()方法配合try/finally语句块来完成。）性能： 在JDK1.6锁优化以前，synchronized的性能比ReenTrantLock差很多。但是JDK6开始，增加了适应性自旋、锁消除等，两者性能就差不多了。功能特点： ReentrantLock 比 synchronized 多了一些高级功能，如等待可中断、可实现公平锁、可实现选择性通知。ReentrantLock提供了一种能够中断等待锁的线程的机制，通过lock.lockInterruptibly()来实现这个机制ReentrantLock可以指定是公平锁还是非公平锁。而synchronized只能是非公平锁。所谓的公平锁就是先等待的线程先获得锁。synchronized与wait()和notify()/notifyAll()方法结合实现等待/通知机制；ReentrantLock类借助Condition接口与newCondition()方法实现。ReentrantLock需要手工声明来加锁和释放锁，一般跟finally配合释放锁。而synchronized不用手动释放锁。下面的表格列出了两种锁之间的区别：
ReentrantLock是一种可重入的排它锁，主要用来解决多线程对共享资源竞争的问题；它提供了比synchronized关键字更加灵活的锁机制。其实现原理主要涉及以下三个方面： 基本结构ReentrantLock内部维护了一个Sync对象（AbstractQueuedSynchronizer类的子类），Sync持有锁、等待队列等状态信息，实际上 ReentrantLock的大部分功能都是由Sync来实现的。 加锁过程当一个线程调用ReentrantLock的lock()方法时，会先尝试CAS操作获取锁，如果成功则返回；否则，线程会被放入等待队列中，等待唤醒重新尝试获取锁。 如果一个线程已经持有了锁，那么它可以重入这个锁，即继续获取该锁而不会被阻塞。ReentrantLock通过维护一个计数器来实现重入锁功能，每次重入计数器加1，每次释放锁计数器减1，当计数器为0时，锁被释放。 解锁过程当一个线程调用ReentrantLock的unlock()方法时，会将计数器减1，如果计数器变为了0，则锁被完全释放。如果计数器还大于0，则表示有其他线程正在等待该锁，此时会唤醒等待队列中的一个线程来获取锁。 总结： ReentrantLock的实现原理主要是基于CAS操作和等待队列来实现。它通过Sync对象来维护锁的状态，支持重入锁和公平锁等特性，提供了比synchronized更加灵活的锁机制，是Java并发编程中常用的同步工具之一。 27.ReentrantLock怎么实现公平锁的？ReentrantLock可以通过构造函数的参数来控制锁的公平性，如果传入 true，就表示该锁是公平的；如果传入 false，就表示该锁是不公平的。 new ReentrantLock()构造函数默认创建的是非公平锁 NonfairSync
同时也可以在创建锁构造函数中传入具体参数创建公平锁 FairSync
FairSync、NonfairSync 代表公平锁和非公平锁，两者都是 ReentrantLock 静态内部类，只不过实现不同锁语义。 非公平锁和公平锁的区别： 非公平锁在调用 lock 后，首先就会调用 CAS 进行一次抢锁，如果这个时候恰巧锁没有被占用，那么直接就获取到锁返回了。非公平锁在 CAS 失败后，和公平锁一样都会进入到 tryAcquire 方法，在 tryAcquire 方法中，如果发现锁这个时候被释放了（state == 0），非公平锁会直接 CAS 抢锁，但是公平锁会判断等待队列是否有线程处于等待状态，如果有则不去抢锁，乖乖排到后面。
CAS叫做CompareAndSwap，比较并交换，主要是通过处理器的指令来保证操作的原子性的。 CAS 操作包含三个参数：共享变量的内存地址（V）、预期原值（A）和新值（B），当且仅当内存地址 V 的值等于 A 时，才将 V 的值修改为 B；否则，不会执行任何操作。 在多线程场景下，使用 CAS 操作可以确保多个线程同时修改某个变量时，只有一个线程能够成功修改。其他线程需要重试或者等待。这样就避免了传统锁机制中的锁竞争和死锁等问题，提高了系统的并发性能。 29.CAS存在什么问题？如何解决？CAS的经典三大问题：
ABA问题 ABA 问题是指一个变量从A变成B，再从B变成A，这样的操作序列可能会被CAS操作误判为未被其他线程修改过。例如线程A读取了某个变量的值为 A，然后被挂起，线程B修改了这个变量的值为B，然后又修改回了A，此时线程A恢复执行，进行CAS操作，此时仍然可以成功，因为此时变量的值还是A。 怎么解决ABA问题？ 加版本号每次修改变量，都在这个变量的版本号上加1，这样，刚刚A->B->A，虽然A的值没变，但是它的版本号已经变了，再判断版本号就会发现此时的A已经被改过了。 比如使用JDK5中的AtomicStampedReference类或JDK8中的LongAdder类。这些原子类型不仅包含数据本身，还包含一个版本号，每次进行操作时都会更新版本号，只有当版本号和期望值都相等时才能执行更新，这样可以避免 ABA 问题的影响。 循环性能开销 自旋CAS，如果一直循环执行，一直不成功，会给CPU带来非常大的执行开销。 怎么解决循环性能开销问题？ 可以使用自适应自旋锁，即在多次操作失败后逐渐加长自旋时间或者放弃自旋锁转为阻塞锁； 只能保证一个变量的原子操作 CAS 保证的是对一个变量执行操作的原子性，如果需要对多个变量进行复合操作，CAS 操作就无法保证整个操作的原子性。 怎么解决只能保证一个变量的原子操作问题？ 可以使用锁机制来保证整个复合操作的原子性。例如，使用 synchronized 关键字或 ReentrantLock 类来保证多个变量的复合操作的原子性。在锁的作用下，只有一个线程可以执行复合操作，其他线程需要等待该线程释放锁后才能继续执行。这样就可以保证整个操作的原子性了。可以使用类似于事务的方式来保证多个变量的复合操作的原子性。例如，使用AtomicReference 类，可以将多个变量封装到一个对象中，通过 CAS 操作更新整个对象，从而保证多个变量的复合操作的原子性。只有当整个对象的值和期望值都相等时才会执行更新操作。30.Java多线程中如何保证i++的结果正确
这里使用 AtomicInteger 类来保证 i++ 操作的原子性。 使用synchronized，对i++操作加锁。
这里使用 synchronized 方法来保证 increment() 方法的原子性，从而保证 i++ 操作的结果正确。 使用锁机制，除了使用 synchronized 关键字外，还可以使用 ReentrantLock 类来保护临界区域。
这里使用 ReentrantLock 类的 lock() 和 unlock() 方法来保护 i++操作的原子性。 31.AtomicInteger的原理是什么？一句话概括：使用CAS实现。 在AtomicInteger中，CAS操作的流程如下： 调用 incrementAndGet()方法，该方法会通过调用unsafe.getAndAddInt()方法，获取当前 AtomicInteger对象的值val将 val + 1 得到新的值 next
总结： 在 CAS 操作中，由于只有一个线程可以成功修改共享变量的值，因此可以保证操作的原子性，即多线程同时修改AtomicInteger变量时也不会出现竞态条件。这样就可以在多线程环境下安全地对AtomicInteger进行整型变量操作。其它的原子操作类基本都是大同小异。 32.什么是线程死锁？我们该如何避免线程死锁？死锁是指两个或两个以上的线程在执行过程中，因争夺资源而造成的互相等待的现象，在无外力作用的情况下，这些线程会一直相互等待而无法继续运行下去。
那么为什么会产生死锁呢？死锁的产生必须具备以下四个条件：
该如何避免死锁呢？答案是至少破坏死锁发生的一个条件。 互斥：我们没有办法破坏，因为用锁为的就是互斥。不过其他三个条件都是有办法打破的，到底如何做呢？请求并持有：可以一次性请求所有的资源。不可剥夺：设置超时时间。已经占用资源的线程进一步申请其他资源时，如果长时间申请不到，超时释放已经持有的资源。环路等待：注意加锁顺序，保证每个线程按同样的顺序进行加锁。33.如何排查死锁问题可以使用jdk自带的命令行工具排查： 使用jps查找运行的Java进程：jps -l使用jstack查看线程堆栈信息：jstack -l 进程id基本就可以看到死锁的信息。 还可以利用图形化工具，比如JConsole（JConsole工具在JDK的bin目录中）。出现线程死锁以后，点击JConsole线程面板的检测到死锁按钮，将会看到线程的死锁信息。 演示样例如下： package lock; /** * @author 百里 */ public class BaiLiDeadLock { private static Object lock1 = new Object(); private static Object lock2 = new Object(); public static void main(String[] args) { Thread thread1 = new Thread(() -> { synchronized (lock1) { System.out.println("Thread-1获取了锁1"); try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } synchronized (lock2) { System.out.println("Thread-1尝试获取锁2"); } } }); Thread thread2 = new Thread(() -> { synchronized (lock2) { System.out.println("Thread-2获取了锁2"); try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } synchronized (lock1) { System.out.println("Thread-2尝试获取锁1"); } } }); thread1.start(); thread2.start(); try { thread1.join(); thread2.join(); } catch (InterruptedException e) { e.printStackTrace(); } } }1.新建连接，找到相应的线程，点击连接 2.选择线程标签，点击检测死锁。查看死锁线程信息
线程池是一种用于管理和复用线程的机制，它提供了一种执行大量异步任务的方式，并且可以在多个任务之间合理地分配和管理系统资源。 线程池的主要优点包括： 改善了资源利用率，降低了线程创建和销毁的开销。提高了系统响应速度，因为线程池已经预先创建好了一些线程，可以更加快速地分配资源以响应用户请求。提高了代码可读性和可维护性，因为线程池将线程管理和任务执行进行了分离，可以更加方便地对其进行调整和优化。可以设置线程数目上限，避免了缺乏控制的线程创建造成的系统无法承受的负载压力。35.简单说一下线程池的工作流程用一个通俗的比喻： 有一个银行营业厅，总共有六个窗口，现在有三个窗口坐着三个营业员小姐姐在营业。小天去办业务，可能会遇到什么情况呢？ 小天发现有空闲的窗口，直接去找小姐姐办理业务。
上面的这个流程几乎就跟JDK线程池的大致流程类似。 营业中的 3个窗口对应核心线程池数：corePoolSize总的营业窗口数6对应：maximumPoolSize打开的临时窗口在多少时间内无人办理则关闭对应：unit排队区就是等待队列：workQueue无法办理的时候银行给出的解决方法对应：RejectedExecutionHandlerthreadFactory 该参数在JDK中是线程工厂，用来创建线程对象，一般不会动。所以我们线程池的工作流程也比较好理解了：
线程池有七大参数，我们重点关注corePoolSize、maximumPoolSize、workQueue、handler 可以帮助我们更好地理解和优化线程池的性能 corePoolSize此值是用来初始化线程池中核心线程数，当线程池中线程数< corePoolSize时，系统默认是添加一个任务才创建一个线程池。当线程数 = corePoolSize时，新任务会追加到workQueue中。 maximumPoolSizemaximumPoolSize表示允许的最大线程数 = (非核心线程数+核心线程数)，当BlockingQueue也满了，但线程池中总线程数 < maximumPoolSize时候就会再次创建新的线程。 keepAliveTime非核心线程 =(maximumPoolSize - corePoolSize ) ,非核心线程闲置下来不干活最多存活时间。 unit线程池中非核心线程保持存活的时间的单位 TimeUnit.DAYS;天TimeUnit.HOURS;小时TimeUnit.MINUTES;分钟TimeUnit.SECONDS;秒TimeUnit.MILLISECONDS; 毫秒TimeUnit.MICROSECONDS; 微秒TimeUnit.NANOSECONDS; 纳秒workQueue线程池等待队列，维护着等待执行的Runnable对象。当运行当线程数= corePoolSize时，新的任务会被添加到workQueue中，如果workQueue也满了则尝试用非核心线程执行任务，等待队列应该尽量用有界的。 threadFactory创建一个新线程时使用的工厂，可以用来设定线程名、是否为daemon线程等等。 handlercorePoolSize、workQueue、maximumPoolSize都不可用的时候执行的饱和策略。 37.线程池的拒绝策略有哪些？在线程池中，当提交的任务数量超过了线程池的最大容量，线程池就需要使用拒绝策略来处理无法处理的新任务。Java 中提供了 4 种默认的拒绝策略: AbortPolicy（默认策略）：直接抛出 runtime 异常，阻止系统正常运行。CallerRunsPolicy：由提交该任务的线程来执行这个任务。DiscardPolicy：直接丢弃任务，不给予任何处理。DiscardOldestPolicy：丢弃队列中最老的一个请求，尝试再次提交当前任务。除了这些默认的策略之外，我们也可以自定义自己的拒绝策略，实现RejectedExecutionHandler接口即可。 public class CustomRejectedExecutionHandler implements RejectedExecutionHandler { @Override public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) { // 自定义的拒绝策略处理逻辑 } }38.线程池有哪几种工作队列
在Java中，线程池中一般有两种方法来提交任务：execute() 和 submit() execute() 用于提交不需要返回值的任务
可以通过调用线程池的shutdown或shutdownNow方法来关闭线程池。它们的原理是遍历线程池中的工作线程，然后逐个调用线程的interrupt方法来中断线程，所以无法响应中断的任务可能永远无法终止。 shutdown：将线程池状态置为shutdown,并不会立即停止： 停止接收外部submit的任务内部正在跑的任务和队列里等待的任务，会执行完等到第二步完成后，才真正停止shutdownNow：将线程池状态置为stop。一般会立即停止，事实上不一定： 和shutdown()一样，先停止接收外部提交的任务忽略队列里等待的任务尝试将正在跑的任务interrupt中断返回未执行的任务列表shutdown 和shutdownnow区别如下： shutdownNow：能立即停止线程池，正在跑的和正在等待的任务都停下了。这样做立即生效，但是风险也比较大。shutdown：只是关闭了提交通道，用submit()是无效的；而内部的任务该怎么跑还是怎么跑，跑完再彻底停止线程池。import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; /** * @author 百里 */ public class BaiLiShutdownDemo { public static void main(String[] args) { // 创建一个线程池，包含两个线程 ExecutorService executor = Executors.newFixedThreadPool(2); // 提交任务到线程池 executor.submit(() -> { try { Thread.sleep(30000); } catch (InterruptedException e) { Thread.currentThread().interrupt(); } System.out.println("Task 1 finished"); }); executor.submit(() -> { try { Thread.sleep(2000); } catch (InterruptedException e) { Thread.currentThread().interrupt(); } System.out.println("Task 2 finished"); }); // 关闭线程池 executor.shutdown(); while (!executor.isTerminated()) { System.out.println("Waiting for all tasks to finish..."); try { // 每500毫秒检查一次 Thread.sleep(500); } catch (InterruptedException e) { Thread.currentThread().interrupt(); } } System.out.println("All tasks finished"); } }import java.util.List; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import java.util.concurrent.TimeUnit; /** * @author 百里 */ public class BaiLiShutdownNowDemo { public static void main(String[] args) { // 创建一个线程池，包含两个线程 ExecutorService executor = Executors.newFixedThreadPool(2); // 提交任务到线程池 executor.submit(() -> { while (!Thread.interrupted()) { System.out.println("Task 1 running..."); } System.out.println("Task 1 interrupted"); }); executor.submit(() -> { while (!Thread.interrupted()) { System.out.println("Task 2 running..."); } System.out.println("Task 2 interrupted"); }); // 关闭线程池 List unfinishedTasks = null; executor.shutdownNow(); try { // 等待直到所有任务完成或超时60秒 if (!executor.awaitTermination(60, TimeUnit.SECONDS)) { // 如果等待超时，则记录未完成的任务列表 unfinishedTasks = executor.shutdownNow(); System.out.println("Some tasks were not finished"); } } catch (InterruptedException e) { // 如果等待过程中发生异常，则记录未完成的任务列表 unfinishedTasks = executor.shutdownNow(); Thread.currentThread().interrupt(); } if (unfinishedTasks != null && !unfinishedTasks.isEmpty()) { System.out.println("Unfinished tasks: " + unfinishedTasks); } else { System.out.println("All tasks finished"); } } }41.有哪几种常见的线程池在Java中，常见的线程池类型主要有四种，都是通过工具类Excutors创建出来的。
需要注意阿里巴巴《Java开发手册》里禁止使用这种方式来创建线程池。 42.说一说newSingleThreadExecutor工作原理
线程池特点： 核心线程数为1最大线程数也为1阻塞队列是无界队列LinkedBlockingQueue，可能会导致OOMkeepAliveTime为0
工作流程： 提交任务线程池是否有一个线程正在运行，如果没有，新建线程执行任务如果有并且非空闲状态，将任务加到阻塞队列当前的唯一线程，从队列取任务，执行完一个，再继续取，一个线程执行任务。使用场景： 适用于串行执行任务的场景，一个任务一个任务地执行。 43.说一说newFixedThreadPool工作原理
线程池特点： 核心线程数和最大线程数大小一样没有所谓的非空闲时间，即keepAliveTime为0阻塞队列为无界队列LinkedBlockingQueue，可能会导致OOM
工作流程： 提交任务如果线程数少于核心线程，创建核心线程执行任务如果线程数等于核心线程，把任务添加到LinkedBlockingQueue阻塞队列如果线程执行完任务，去阻塞队列取任务，继续执行。使用场景： FixedThreadPool 适用于处理CPU密集型的任务，确保CPU在长期被工作线程使用的情况下，尽可能的少的分配线程，即适用执行长期的任务。 44.说一说newCachedThreadPool工作原理
线程池特点： 核心线程数为0最大线程数为Integer.MAX_VALUE，即无限大，可能会因为无限创建线程，导致OOM阻塞队列是SynchronousQueue非核心线程空闲存活时间为60秒当提交任务的速度大于处理任务的速度时，每次提交一个任务，就必然会创建一个线程。极端情况下会创建过多的线程，耗尽 CPU 和内存资源。由于空闲 60 秒的线程会被终止，长时间保持空闲的 CachedThreadPool 不会占用任何资源。
工作流程： 提交任务因为没有核心线程，所以任务直接加到SynchronousQueue队列。判断是否有空闲线程，如果有，就去取出任务执行。如果没有空闲线程，就新建一个线程执行。执行完任务的线程，还可以存活60秒，如果在这期间，接到任务，可以继续活下去；否则，被销毁。使用场景： 用于并发执行大量短期的小任务。 45.说一说newScheduledThreadPool工作原理
线程池特点： 最大线程数为Integer.MAX_VALUE，也有OOM的风险阻塞队列是DelayedWorkQueuekeepAliveTime为0scheduleAtFixedRate() ：按某种速率周期执行scheduleWithFixedDelay()：在某个延迟后执行
工作流程： 线程从DelayQueue中获取已到期的ScheduledFutureTask（DelayQueue.take()）。到期任务是指ScheduledFutureTask的time大于等于当前时间。线程执行这个ScheduledFutureTask。线程修改ScheduledFutureTask的time变量为下次将要被执行的时间。线程把这个修改time之后的ScheduledFutureTask放回DelayQueue中（DelayQueue.add()）。使用场景： 周期性执行任务的场景，需要限制线程数量的场景。 import java.util.concurrent.*; /** * @author 百里 */ public class BaiLiScheduledThreadPoolDemo { public static void main(String[] args) throws Exception { // 创建一个可以执行定时任务的线程池 ScheduledExecutorService executorService = Executors.newScheduledThreadPool(1); // 调度一个定时任务，每隔 2 秒钟输出一次当前时间 ScheduledFuture scheduledFuture = executorService.scheduleAtFixedRate(() -> { System.out.println("Current time: " + System.currentTimeMillis()); }, 0, 2, TimeUnit.SECONDS); // 主线程休眠 10 秒钟后取消任务 Thread.sleep(10000); scheduledFuture.cancel(true); // 关闭线程池 executorService.shutdown(); } }import java.util.concurrent.*; /** * @author 百里 */ public class BaiLiScheduleWithFixedDelayDemo { public static void main(String[] args) throws Exception { // 创建一个可以执行定时任务的线程池 ScheduledExecutorService executorService = Executors.newScheduledThreadPool(1); // 调度一个周期性任务，每次任务执行完毕后等待 2 秒钟再执行下一个任务 executorService.scheduleWithFixedDelay(() -> { System.out.println("Current time: " + System.currentTimeMillis()); }, 0, 2, TimeUnit.SECONDS); // 主线程休眠 10 秒钟后关闭线程池 Thread.sleep(10000); executorService.shutdown(); } }46.线程池异常怎么处理知道吗？在使用线程池处理任务的时候，任务代码可能抛出RuntimeException，抛出异常后，线程池可能捕获它，也可能创建一个新的线程来代替异常的线程，我们可能无法感知任务出现了异常，因此我们需要考虑线程池异常情况。 常见的异常处理方式：
1.try-catch捕获异常 import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; /** * @author 百里 */ public class BaiLiHandlerException implements Runnable { @Override public void run() { try { // 任务代码 int a = 10 / 0; } catch (Exception e) { System.err.println("任务执行异常：" + e.getMessage()); } } public static void main(String[] args) { ExecutorService executor = Executors.newFixedThreadPool(10); BaiLiHandlerException task = new BaiLiHandlerException(); executor.execute(task); } }2.使用Thread.UncaughtExceptionHandler处理异常 import com.google.common.util.concurrent.ThreadFactoryBuilder; import java.util.concurrent.*; /** * @author 百里 */ public class BaiLiHandlerException implements Runnable { @Override public void run() { // 任务代码 int a = 10 / 0; } public static class MyUncaughtExceptionHandler implements Thread.UncaughtExceptionHandler { @Override public void uncaughtException(Thread t, Throwable e) { System.err.println("任务执行异常：" + e.getMessage()); } } public static void main(String[] args) { BaiLiHandlerException task = new BaiLiHandlerException(); Thread thread = new Thread(task); thread.setUncaughtExceptionHandler(new MyUncaughtExceptionHandler()); thread.start(); } }3.重写ThreadPoolExecutor.afterExcute处理异常 package exception; import com.google.common.util.concurrent.ThreadFactoryBuilder; import java.util.concurrent.*; /** * @author 百里 */ public class BaiLiHandlerException implements Runnable { @Override public void run() { // 任务代码 int a = 10 / 0; } public static class MyThreadPoolExecutor extends ThreadPoolExecutor { public MyThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue workQueue, ThreadFactory threadFactory) { super(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue, threadFactory); } @Override protected void afterExecute(Runnable r, Throwable t) { super.afterExecute(r, t); if (t != null) { System.err.println("任务执行异常：" + t.getMessage()); } } } public static void main(String[] args) { MyThreadPoolExecutor executor = new MyThreadPoolExecutor(1, 1, 0, TimeUnit.MILLISECONDS, new LinkedBlockingQueue(), new ThreadFactoryBuilder().setNameFormat("MyThread-%d").build()); BaiLiHandlerException task = new BaiLiHandlerException(); executor.execute(task); } }4.使用future.get处理异常 import com.google.common.util.concurrent.ThreadFactoryBuilder; import java.util.concurrent.*; /** * @author 百里 */ public class BaiLiHandlerException { public static void main(String[] args) { ExecutorService executor = Executors.newSingleThreadExecutor(); Future future = executor.submit(() -> { throw new RuntimeException("任务执行失败"); }); try { String result = future.get(); System.out.println(result); } catch (ExecutionException e) { Throwable ex = e.getCause(); System.out.println("捕获到异常: " + ex.getMessage()); } catch (InterruptedException e) { Thread.currentThread().interrupt(); executor.shutdownNow(); System.out.println("线程被中断，已执行相应处理"); } executor.shutdown(); } }47.能说一下线程池有几种状态吗？线程池有这几个状态：RUNNING，SHUTDOWN，STOP，TIDYING，TERMINATED //线程池状态 private static final int RUNNING = -1 |
【本文地址】
今日新闻 |
推荐新闻 |