太全了！多线程问题概述

如果在这段期间它的值曾经被改成了B，后来又被改回为A，那CAS操作就会误认为它从来没有被改变过。这个漏洞称为CAS操作的“ABA”问题。Java并发包为了解决这个问题，提供了一个带有标记的原子引用类“AtomicStampedReference”，它可以通过控制变量值的版本来保证CAS的正确性。因此，在使用CAS前要考虑清楚“ABA”问题是否会影响程序并发的正确性，如果需要解决ABA问题，改用传统的互斥同步可能会比原子类更高效。或者我们可以给预期值加一个属性，记录一下修改的次数(版本号)。

15.Reentrantlock的特性以及和synchronized的区别？

详情请看：java显式锁和隐式锁的区别_北~笙的博客-CSDN博客一篇文章带你彻底搞懂显式锁和隐式锁之间的区别https://blog.csdn.net/qq_53679373/article/details/129935791

16.JUC包下的工具类有哪些？

详细请看：JUC常用并发工具类_北~笙的博客-CSDN博客四个案例带你彻底搞懂java最常见的并发工具类，semaphore，countdownlatch，exchanger，cyclicbarrier。https://blog.csdn.net/qq_53679373/article/details/129944755

17.线程安全的集合类有哪些？

一：早期的线程安全集合类

1.1Vector
Vector和ArrayList类似，是长度可变的数组，与ArrayList不同的是，Vector是线程安全的，它几乎给所有的public方法都加上了sychronized关键字。由于加锁倒是性能降低，在不需要并发访问时，这种强制性的同步就显得多余，所以现在几乎没有什么人在使用。

1.2 HashTable
HashTable和HashMap类似，不同的是HashTable是线程安全的，它也是几乎的给所有的public方法都加上了sychronized关键字，还有一个不同点是：**HashTable的K, V都不能是null，但是HashMap可以。**现在HashTable也是因为性能的问题，几乎没有人使用了。

二、Collections包装方法

由于ArrayList和HashMap性能好，但是不是线程安全，所以Collections工具类中提供了相应的包装方法将他们包装成相应的线程安全的集合：

List<E> synchronizedList = Collections.sychronizedList(new ArrayList<E>());

Set<E> sychronizedSet = Collections.sychronizedSet(new HashSet<E>());

Map<K, V> synchronizedMap = Collections.sychronizedMap(new HashMap<K, V>());

三、java.util.concurrent包中的集合

3.1. ConcurrentHashMap

ConcurrentHashMap和HashTable都是线程安全的集合，它们的不同主要是加锁粒度上的不同。HashTable的加锁方法是给每个方法加上synchronized关键字，这样锁的是整个对象。而ConcurrentHashMap是有更细粒度的锁。在JDK1.8之前，ConcurrentHashMap加的是分段锁，即Segment，每个Segment含有整个table的一部分，这样不同分段之间的并发操作就互不影响。
JDK1.8之后对此进行了进一步的改进，取消了Segment，直接在table元素上加锁，实现对每一行加锁，进一步减小了并发冲突的概率。

3.2 CopyOnWriteArrayList和CopyOnWriteArraySet

针对涉及到数据修改的部分，都会使用ReentrantLock锁住操作，并将修改或添加的元素，通过拷贝的方式，加入数组中，最后修改数组的引用为新复制的数组。读取时直接读取数组，不需要获取锁。

18.ConcurrentHashMap介绍一下？

ConcurrentHashMap和HashMap一样，是一个存放键值对的容器。使用hash算法来获取值的地址，因此时间复杂度是O(1)。查询非常快。
同时，ConcurrentHashMap是线程安全的HashMap。专门用于多线程环境。

既然谈到了ConcurrentHashMap，那ConcurrentHashMap与Hashmap与Hashtable有什么区别呢

1. HashMap
HashMap是线程不安全的，因为HashMap中操作都没有加锁，因此在多线程环境下会导致数据覆盖之类的问题，所以，在多线程中使用HashMap是会抛出异常的。

2. HashTable
HashTable是线程安全的,但是HashTable只是单纯的在put()方法上加上synchronized。保证插入时阻塞其他线程的插入操作。虽然安全，但因为设计简单，所以性能低下。

3. ConcurrentHashMap
ConcurrentHashMap是线程安全的，ConcurrentHashMap并非锁住整个方法，而是通过原子操作和局部加锁的方法保证了多线程的线程安全，且尽可能减少了性能损耗。

4.ConcurrentHashMap对于写操作put加锁，对于读操作get不加锁

5.ConcurrentHashMap对于共享变量大量运用的volatile关键字去修饰

6.ConcurrentHashMap对扩容做了优化

19.死锁问题？

首先我们应该了解造成死锁的原因是什么？

1.互斥访问：例如线程1拿到了锁A，那么线程2就不能同时拿到锁

2.不可抢占：获取到锁的线程，除非它自己释放掉锁，不然其他线程不能抢占过来

3.保持与请求：例如线程1已经获取到了锁A，还要在这个基础上去获取锁B

4.循环等待：例如线程1等待线程2释放锁，线程2等待线程3释放锁，线程3等待线程1释放锁

那么我们应该如何解决死锁问题呢？

1.互斥访问：锁的基本特征，不能打破

2.不可抢占：锁的基本特征，不能打破

3.保持与请求：从代码实现和设计的角度来看可以改变保持与请求的顺序，也是获取锁的顺序

4.循环等待：破坏循环等待条件，需要对资源进行排序，然后按序申请资源。

20.ThreadLocal介绍一下？

1. ThreadLocal是什么？

从名字我们就可以看到ThreadLocal 叫做本地线程变量，意思是说，ThreadLocal 中填充的的是当前线程的变量，该变量对其他线程而言是封闭且隔离的，ThreadLocal 为变量在每个线程中创建了一个副本，这样每个线程都可以访问自己内部的副本变量。

2. ThreadLocal怎么用？

下面让我们来看一个例子：

public class ThreadLocalDemo {
    public static void main(String[] args) {
        ThreadLocal<Integer> threadLocal = new ThreadLocal<>();
        Thread thread0 = new Thread(() -> {
            int count = 0;
            threadLocal.set(count);
            System.out.println(Thread.currentThread().getName() + ":" + count);
        });
        thread0.start();
        Thread thread1 = new Thread(() -> {
            int count = 1;
            threadLocal.set(count);
            System.out.println(Thread.currentThread().getName() + ":" + count);
        });
        thread1.start();
        Thread thread2 = new Thread(() -> {
            int count = 2;
            threadLocal.set(count);
            System.out.println(Thread.currentThread().getName() + ":" + count);
        });
        thread2.start();
        Thread thread3 = new Thread(() -> {
            int count = 3;
            threadLocal.set(count);
            System.out.println(Thread.currentThread().getName() + ":" + count);
        });
        thread3.start();
    }
}

从结果可以看到，每一个线程都有自己的local 值，这就是TheadLocal的基本使用。

3.看看set(T value)和get()方法的源码

一句话总结：每个线程都有一个 ThreadLocalMap（ThreadLocal内部类），Map 中元素的键为 ThreadLocal，而值对应线程的变量副本。Map 是数组实现，使用线性探测解决hash冲突，需要手动调用set、get、remove防止内存泄漏。ThreadLoal 变量，线程局部变量，同一个 ThreadLocal 所包含的对象，在不同的 Thread 中有不同的副本。ThreadLocal 变量通常被private static修饰。当一个线程结束时，它所使用的所有 ThreadLocal 相对的实例副本都可被回收。

一个线程内可以存在多个 ThreadLocal 对象，所以其实是 ThreadLocal 内部维护了一个 Map ，这个 Map 不是直接使用的 HashMap ，而是 ThreadLocal 实现的一个叫做 ThreadLocalMap 的静态内部类。而我们使用的 get()、set() 方法其实都是调用了这个ThreadLocalMap类对应的 get()、set() 方法。