面试题汇总——Java多线程

weightOneMillion

已于 2023-08-20 22:01:48 修改

阅读量250

点赞数

分类专栏：面试题总结大全——更新中文章标签： java 开发语言

于 2023-07-11 22:28:55 首次发布

本文链接：https://blog.csdn.net/littleyy666/article/details/131653122

版权

面试题总结大全——更新中专栏收录该内容

5 篇文章 0 订阅

订阅专栏

多线程并发下的i++操作

i初始值为0，开启10个线程，每个线程对i循环1000次进行++操作，结果却小于等于10000。

public class intaddadd {
    public static int i = 0;

    public static void main(String[] args) {
        for (int j = 0; j < 10; j++) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    for (int k = 0; k < 1000; k++) {
                        i++;
                    }
                }
            }).start();
        }
        //一定要加上休眠时间，否则会在线程没有执行完成时打印，输出会远远小于10000
        try {
            Thread.sleep(3000);
        }catch (InterruptedException e){
            System.out.println(e);
        }
        System.out.println(i);//i=10000、9195
    }
}

出现这种问题的原因是，当多个线程对同一个共享变量进行操作时，由于操作系统底层高速缓存的存在，会出现缓存不一致，即一个线程对变量操作后，没有立即同步到主存，其他线程从自己的工作缓存取值进行操作，就会导致最终结果小于等于预期值。

可以使用 synchronized关键字，每次只有一个线程获取锁执行i++操作，但是这种相当于串行，性能较低。
synchronized关键字，加哪呢？

public class intaddadd {
    public static int i = 0;

    public static synchronized void add(){
    	i++;
    }
    public static void main(String[] args) {
        for (int j = 0; j < 100; j++) {
            i=0;
            fun();
        }
    }
    public static void fun(){
        for (int j = 0; j < 10; j++) {
            Thread t = new Thread(new Runnable() {
                @Override
                public void run() {
                    for (int k = 0; k < 1000; k++) {
                        add();
                        //下面这行不可以，是因为？
                        //sychronized(this){i++;}
                    }
                }
            });

            t.start();
        }
        try {
            Thread.sleep(3000);
        }catch (InterruptedException e){
            System.out.println(e);
        }
        System.out.println(i);
    }
}

或者用juc并发包下的原子类

import java.util.concurrent.atomic.AtomicInteger;

public class intaddadd {
    public static AtomicInteger i = new AtomicInteger(0);

    public static void main(String[] args) {
        for (int j = 0; j < 100; j++) {
            i.set(0);
            fun();
        }
    }
    public static void fun(){
        for (int j = 0; j < 10; j++) {
            Thread t = new Thread(new Runnable() {
                @Override
                public void run() {
                    for (int k = 0; k < 1000; k++) {
                        i.incrementAndGet();
                    }
                }
            });

            t.start();
        }
        try {
            Thread.sleep(3000);
        }catch (InterruptedException e){
            System.out.println(e);
        }
        System.out.println(i);
    }
}

atomic包下的原子类，底层使用了Unsafe类，其内存语义是，对变量的++操作是原子性的，不可分割的，且value是volatile修饰的，实现一个线程对变量++操作后，会将其他线程的工作内存的共享变量的缓存行失效，且立即同步到主存，其他线程再取值就会从主存去取了。需要注意的是，volatile本身并不能实现原子性。

atomic底层使用了CAS操作，比较并替换，类似乐观锁机制，每次先查询，然后更新的时候会比较当前值是不是自己当初查询的那个值，如果不是，就再次查询，再次更新。

参考链接：https://www.jianshu.com/p/cb2576197b72

现在有三个线程：T1、T2和T3。如何确保T2在T1完成后执行，T3在T2完成后执行？

join()方法
t1.start();t1.join();t2.start();t2.join();t3.start();t3.join();
join方法需要捕获异常

 try {
    t1.join();
    } catch (InterruptedException e) {
        // 异常捕捉处理
}

参考：here

Java中线程的实现方式

继承 Thread 类，重写run方法
实现 Runnable 接口，实现该接口的run方法。相比于继承 Thread 类的方法来说，实现 Runnable 接口是一个更好地选择，因为 Java 不支持多继承，但是可以实现多个接口。
实现 Callable 接口，重写call()方法，配合Future对象的get()方法可以得到返回值
四种线程池：Java通过Executors创建线程池，分别为：newSingleThreadExecutor()、newFixedThreadPool、newCachedThreadPool、newScheduledThreadPool。

基于底层都是实现Runnable接口。

参考：here

Java线程的状态

5种（操作系统层面）
在这里插入图片描述
Java提供了6种状态(回答这个)
新建状态 (New)：new
运行状态(Runnable)：start调用
等待状态（Waiting）：调用wait方法让线程处于等待状态
阻塞状态（Blocked）：多个线程竞争同一个锁,竞争失败的线程会处于该状态
计时等待状态（Timed Waiting）：和等待相似,但是区别在于限定了一个时间,如果超过时间则取消等待,继续执行
终止状态（Terminated）：线程运行结束,释放所有资源

在这里插入图片描述
参考：here

Java如何停止线程

1、使用stop方法强行终止线程（这个方法不推荐使用，因为stop和suspend、resume一样，也可能发生不可预料的结果）。
2、使用共享变量，也叫退出标志(很少会用)
这种方式用的也不多，有的线程可能会通过死循环来保证一直运行。咱们可以通过修改共享变量在破坏死循环，让线程退出循环,结束run方法。
3、使用 interrupt() 方法中断线程
线程内部存在一个共享变量，叫做interrupt标记位默认位false，调用interrupt方法为转为true.
在这里插入图片描述 interrupted方法：获取标记位并恢复为false
interrupt方法的另一个作用是在遇到 sleep() 或者 wait() 这样的操作，或者是在等待和超时等待状态下，我们只能通过中断来处理了。

public static native void sleep(long millis) throws InterruptedException

Thread.sleep() 方法会抛出一个 InterruptedException 异常，当线程被 sleep() 休眠时，如果被中断，这会就抛出这个异常。
（注意：Thread.sleep() 方法由于中断而抛出的异常，是会清除中断标记的。）

参考：here

wait和sleep方法的区别

1、相同点
sleep()和wait()都可以暂停线程的执行。
2、不同点
所在类不同
sleep()是Thread类的静态（static）方法。
wait()是Object类的方法。

用法不同
sleep()方法属于TIMED_WAITING，睡眠指定时间之后，线程会自动苏醒。
wait()方法属于WAITING，需要手动唤醒，被调用后，可以通过notify()或notifyAll()来唤醒wait的线程。

锁释放不同
sleep方法在持有锁时执行，不会释放锁资源；wait在执行后，会释放锁资源。
sleep可以在持有锁或者不持有锁时，执行。wait方法必须在只有锁时才可以执行。
为什么wait方法必须在只有锁时才可以执行？
因为执行wait方法操作的是synchronized锁里的的ObjectMonitor对象的一些信息。
wait方法会将持有锁的线程从owner扔到WaitSet集合中，这个操作是在修改ObjectMonitor对象，如果没有持有synchronized锁的话，是无法操作ObjectMonitor对象的。

用途不同
sleep()常用于一定时间内暂停线程执行。
wait()常用于线程间交互和通信。

参考：https://blog.csdn.net/qiuchaoxi/article/details/79837568

如何理解线程安全

线程安全是指在多线程访问共享资源时，保证程序正确性和可靠性的能力。
在 Java 中，线程安全可以通过并发编程三个特性来理解：

并发编程三个特性

原子性:指一个操作是不可分割的，不可中断的，一个线程在执行时，另一个线程不会影响到他。
1 synchronized
可以在方法上追加synchronized关键字或者采用同步代码块的形式来保证原子性
synchronized可以让避免多线程同时操作临街资源，同一时间点，只会有一个线程正在操作临界资源
2 CAS
compare and swap也就是比较和交换，他是一条CPU的并发原语。
他在替换内存的某个位置的值时，首先查看内存中的值与预期值是否一致，如果一致，执行替换操作。
3 Lock锁，lock与unlock方法也调用了cas
4 ThreadLocal，避免了多线程操作临界/共享资源
可见性：三级缓存与主内存的同步问题，避免发生数据不一致问题。
1 volatile关键字，修饰成员变量。
就是让CPU每次操作这个数据时，必须立即同步到主内存，以及从主内存读取数据。
2 synchronized
获取锁资源之后，将内部涉及到的变量从CPU缓存中移除，必须去主内存中重新拿数据，而且在释放锁之后，会立即将CPU缓存中的数据同步到主内存。
3 Lock
Lock锁是基于volatile实现的。Lock锁内部再进行加锁和释放锁时，会对一个由volatile修饰的state属性进行加减操作。
4 final
final修饰的属性，在运行期间是不允许修改的，这样一来，就间接的保证了可见性，所有多线程读取final属性，值肯定是一样。
有序性：CPU指令重排问题
2 as-if-serial
不论指定如何重排序，需要保证单线程的程序执行结果是不变的。
3 happens-before原则
让程序对某一个属性的操作不出现指令重排
4 volatile
基于volatile修饰属性，从而对这个属性的操作，就不会出现指令重排的问题了。

volatile如何实现的禁止指令重排？
内存屏障概念。将内存屏障看成一条指令。
会在两个操作之间，添加上一道指令，这个指令就可以避免上下执行的其他指令进行重排序。

参考：here

CAS

CAS是CompareAnd Swap的缩写，直译就是比较并交换。CAS是现代CPU广泛支持的一种对内存中的共享数据进行操作的一种特殊指令，这个指令会对内存中的共享数据做原子的读写操作。其作用是让CPU比较内存中某个值是否和预期的值相同，如果相同则将这个值更新为新值，不相同则不做更新。

CAS相关的实现是借助C/C++调用CPU指令来实现的，效率很高，但Java代码需通过JNI（Java Native Interface）才能调用。比如，Unsafe类提供的CAS方法（如compareAndSwapXXX）底层实现即为CPU指令cmpxchg。

Java中大量使用了CAS机制来实现多线程下数据更新的原子化操作，比如AtomicInteger、CurrentHashMap当中都有CAS的应用。
优点

高效性：相比较传统的同步方式，CAS能够在无锁的情况下进行并发操作，避免了线程之间的互斥和阻塞，因此效率更高。
无死锁：CAS不会引起死锁，因为它不需要加锁。
确保操作的原子性：CAS可以确保并发环境下对于同一内存位置的操作具有原子性，避免数据不一致的问题。

CAS存在的问题：

循环（自旋）时间长，开销大；（While循环，一直调用）
ABA问题；（解决方法：不但判断原值，还要比较版本信息。）

CAS的缺点：CAS只能保证对一个共享变量的操作是原子性的，无法实现对多行代码实现原子性。

参考：here

假设线程有一个线程池,线程池当中有个线程,7个线程执行失败,3个线程执行成功,请问怎么获取线程的返回值

【答案未知】Future对象的get方法获得返回值

@Contended注解有什么用?

使用@Contended来保证被标识的字段或者类不与其他字段出现内存争用。
Contented注解，会将当前类中的属性，会独占一个级缓存行，从而避免缓存行失效造成的性能问题。
@Contented注解，就是将一个缓存行的后面7个位置，填充上7个没有意义的数据。

参考：here

volatile

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

1）保证了不同线程对这个变量进行操作时的可见性，即一个线程修改了某个变量的值，这新值对其他线程来说是立即可见的,volatile关键字会强制将修改的值立即写入主存。

2）禁止进行指令重排序。

为什么volatile不保证原子性？
在 Java 中，原子性是指一个操作是不可中断的，即使在多线程环境下也是如此。但是，volatile 变量的写操作和读操作之间是可以被中断的，这意味着在读取或者修改 volatile 变量的过程中，其他线程可能会对这个变量进行修改。因此，使用 volatile 变量并不能保证对变量的操作是原子性的。

参考：https://blog.csdn.net/weixin_35756130/article/details/128868049

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

notify可能会导致死锁，而notifyAll则不会
使用notifyall,可以唤醒所有处于wait状态的线程，使其重新进入锁的争夺队列中，而notify只能唤醒一个。
notify() 是对notifyAll()的一个优化，但它有很精确的应用场景，并且要求正确使用，不然可能导致死锁。正确的场景应该是 WaitSet中等待的是相同的条件，唤醒任一个都能正确处理接下来的事项，如果唤醒的线程无法正确处理，务必确保继续notify()下一个线程，并且自身需要重新回到 WaitSet中.

Java四种引用类型

强：new创建，强引用是最常用的引用，不会被GC回收，一直处于可达状态。
软：softReference，在内存空间足够的时候，垃圾回收器是不会回收它的；如果内存空间不足了，就会回收这些对象的内存。软引用可用来实现内存敏感的高速缓存。
弱：GC一旦发现了只具有弱引用的对象，不管当前内存空间足够与否，都会回收它的内存。可以解决内存泄漏问题，ThreadLocal就是基于弱引用解决内存泄漏的问题。
虚：虚引用必须和引用队列（ReferenceQueue）联合使用，主要作用是跟踪对象被垃圾回收的状态。
当垃圾回收器准备回收一个对象时，如果发现它还有虚引用，就会在回收对象的内存之前，把这个虚引用加入到与之关联的引用队列中。程序可以通过判断引用队列中是否存在该对象的虚引用，来了解这个对象是否将要被回收。可以用来作为GC回收Object的标志。

参考：https://blog.csdn.net/Fantasy_Lin_/article/details/105004740

ThreadLocal的内存泄漏问题?

ThreadLocal的实现原理：
ThreadLocal就相当于一个访问工具类，通过操作ThreadLocal对象的方法来操作存储在当前线程内部的ThreadLocalMap里的值
ThreadLocalMap是一个哈希数组（Entry[]），key为ThreadLocal对象，Value为一个Object类型的值
它继承自WeakReference，ThreadLocal对象是一个「弱引用」。

ThreadLocalMap的key是一个弱引用，弱引用的特点是，即便有弱引用，在GC时，也必须被回收。这里是为了在ThreadLocal对象失去引用后，如果key的引用是强引用，会导致ThreadLocal对象无法被回收。

如果ThreadLocal引用丢失，key因为弱引用会被GC回收掉，如果同时线程还没有被回收，就会导致内存泄漏，内存中的value无法被回收，同时也无法被获取到。
由于ThreadLocalMap 是 Thread 的一个属性，被当前线程所引用，所以ThreadLocalMap的生命周期跟 Thread 一样长。如果threadlocal变量被回收，那么当前线程的threadlocal 变量副本指向的就是key=null, 也即entry(null,value),那这个entry对应的value永远无法访问到。实际私用ThreadLocal场景都是采用线程池，而线程池中的线程都是复用的，这样就可能导致非常多的entry(null,value)出现，从而导致内存泄露。

总结：
key的内存泄漏基于：弱引用解决
Value的内存泄漏问题：只需要在使用完毕ThreadLocal对象之后，及时的调用remove方法，移除Entry即可

参考：here

Java线程之间的通信方式

共享变量：线程可以通过读写共享的变量来进行通信。这可以是一个普通的变量或者一个共享对象的属性。通过对共享变量的读写操作，线程可以传递信息给其他线程。但是需要注意，多个线程对同一个共享变量进行读写时可能会引发线程安全问题，因此需要使用同步机制（如synchronized关键字）来确保线程安全。
等待/通知机制：Java提供了Object类的wait()、notify()和notifyAll()方法来实现线程之间的等待和通知。线程可以调用wait()方法进入等待状态，直到其他线程调用notify()或notifyAll()方法唤醒它。这种机制常用于生产者-消费者模型等场景。
阻塞队列：Java提供了线程安全的阻塞队列（如ArrayBlockingQueue、LinkedBlockingQueue等），线程可以通过向队列中放入元素或者从队列中获取元素来进行通信。当队列为空时，获取操作会阻塞线程，直到队列中有可用元素；当队列已满时，插入操作会阻塞线程，直到队列有空闲位置。
Condition条件：Java中的Condition接口提供了更加灵活的线程通信方式。可以通过Lock对象的newCondition()方法获取一个Condition实例，然后线程可以调用await()方法进入等待状态，直到其他线程调用signal()或signalAll()方法来唤醒它们。

参考：here