Java并发基础

并行和并发有什么区别？

从操作系统的角度来看，线程是CPU分配的最小单位。

并行就是同一时刻，两个线程都在执行。即两个CPU去分别执行两个线程。

并发就是同一个时刻，只有一个执行，但是一个时间段内，两个都执行了，并发依赖于CPU的切换，因为切换时间段，用户无感知。

说说什么是进程和线程？

要说线程，必须得先说进程

• 进程：进程是代码在数据集合上的一次运行活动，是系统进行资源分配和调度的基本单位。
• 线程：线程是进程的一个执行路径，一个进程中至少有一个线程，进程中的多个线程共享进程的资源。

Java线程创建方式？

继承Thread类、实现Runnable接口、实现Callable接口，线程池

Runnable和Callable接口的区别？

Runnable里面的run()方法没有返回值，只能处理一些简单的任务，无法抛出异常

实现Callable接口，重写call()方法，这种方式可以通过FutureTask获取任务执行的返回值,可以处理一些复杂的线程任务，可以抛出异常。

为什么调用start()方法时会执行run()方法，不直接调用run()方法？

JVM执行start方法，会先创建一条线程，由创建出来的新线程去执行thread的run方法，这才起到多线程的效果。

**为什么我们不能直接调用run()方法？**也很清楚， 如果直接调用Thread的run()方法，那么run方法还是运行在主线程中，相当于顺序执行，就起不到多线程的效果。

**为什么我们不能直接调用run()方法？**也很清楚， 如果直接调用Thread的run()方法，那么run方法还是运行在主线程中，相当于顺序执行，就起不到多线程的效果。

sleep()和wait()的区别？

1. sleep方法属于Thread类的静态方法，而wait方法属于Object类的实例方法。因此，sleep方法可以直接通过Thread类调用，而wait方法需要通过对象实例调用。

2. sleep方法会让当前线程暂停执行指定的时间，然后继续执行。在睡眠期间，线程不会释放锁。wait方法会让当前线程暂停执行，并释放对象的锁，使得其他线程可以访问该对象。

3. sleep方法不需要被唤醒，一旦时间到达，线程会自动恢复执行。wait方法需要被其他线程调用notify或notifyAll方法来唤醒。

4. sleep方法使用的是线程的本地资源，不会释放对象的锁。wait方法会释放对象的锁，使得其他线程可以获取该对象的锁。

   sleep方法适用于线程暂停执行一段时间后继续执行的场景，而wait方法适用于线程等待某个条件满足后再继续执行的场景。

线程的生命周期(状态)？

new(新建)、runnable(可运行)、blocked(阻塞)、waiting(等待)、time waiting(超时等待)和terminated(终止)。

什么是守护线程？

Java中的线程分为两类，分别是daemon线程(守护线程)和user(用户)线程。

在JVM 启动时会调用 main 函数，main函数所在的线程就是一个用户线程。其实在 JVM 内部同时还启动了很多守护线程， 比如垃圾回收线程。

那么守护线程和用户线程有什么区别呢？区别之一是当最后一个非守护线程束时， JVM会正常退出，而不管当前是否存在守护线程，也就是说守护线程是否结束并不影响 JVM退出。换而言之，只要有一个用户线程还没结束，正常情况下JVM就不会退出。

线程间通信有哪些通信方式？

• volatile和synchronized关键字

关键字volatile可以用来修饰字段（成员变量），就是告知程序任何对该变量的访问均需要从共享内存中获取，而对它的改变必须同步刷新回共享内存，它能保证所有线程对变量访问的可见性。

关键字synchronized可以修饰方法或者以同步块的形式来进行使用，它主要确保多个线程在同一个时刻，只能有一个线程处于方法或者同步块中，它保证了线程对变量访问的可见性和排他性。

• 等待/通知机制

可以通过Java内置的等待/通知机制（wait()/notify()）实现一个线程修改一个对象的值，而另一个线程感知到了变化，然后进行相应的操作。

• 管道输入/输出流

管道输入/输出流和普通的文件输入/输出流或者网络输入/输出流不同之处在于，它主要用于线程之间的数据传输，而传输的媒介为内存。

管道输入/输出流主要包括了如下4种具体实现：PipedOutputStream、PipedInputStream、 PipedReader和PipedWriter，前两种面向字节，而后两种面向字符。

• 使用Thread.join()

如果一个线程A执行了thread.join()语句，其含义是：当前线程A等待thread线程终止之后才从thread.join()返回。。线程Thread除了提供join()方法之外，还提供了join(long millis)和join(long millis,int nanos)两个具备超时特性的方法。

• 使用ThreadLocal

ThreadLocal，即线程变量，是一个以ThreadLocal对象为键、任意对象为值的存储结构。这个结构被附带在线程上，也就是说一个线程可以根据一个ThreadLocal对象查询到绑定在这个线程上的一个值。

可以通过set(T)方法来设置一个值，在当前线程下再通过get()方法获取到原先设置的值。

ThreadLocal是什么？

ThreadLocal，是线程本地变量，如果你创建了一个ThreadLocal变量，那么访问这个变量的每个线程都会有这个变量的一个本地拷贝，多个线程操作这个变量的时候，实际是操作自己本地内存里面的变量，从而起到线程隔离的作用，避免了线程安全问题。

• 创建

//创建一个ThreadLocal变量
public static ThreadLocal<String> localVariable = new ThreadLocal<>();

• 写入

线程可以在任何地方使用localVariable,写入变量。
localVariable.set("张三”);

• 读取

线程在任何地方读取的都是它写入的变量。
    localVariable.get();

你在项目中用到过ThreadLocal吗？

有用到过的，用来做用户信息上下文的存储。

登录后用户每次访问接口，都会在请求头携带一个token，在控制层可以根据这个token解析用户基本信息，但是在业务层也需要用到用户信息(id)，可以用到ThreadLocal，在控制层拦截请求把用户信息存入ThreadLocal，这样我们在任何一个地方，都可以取出ThreadLocal中存的用户数据。

ThreadLocal原理？要答出这几个点：

• Thread类有一个类型为ThreadLocal.ThreadLocalMap的实例变量threadLocals，每个线程都有一个属于自己的ThreadLocalMap。
• ThreadLocalMap内部维护着Entry数组，每个Entry代表一个完整的对象，key是ThreadLocal的弱引用，value是ThreadLocal的泛型值。
• 每个线程在往ThreadLocal里设置值的时候，都是往自己的ThreadLocalMap里存，读也是以某个ThreadLocal作为引用，在自己的map里找对应的key，从而实现了线程隔离。
• ThreadLocal本身不存储值，它只是作为一个key来让线程往ThreadLocalMap里存取值。

ThreadLocalMap怎么解决Hash冲突的？

我们可能都知道HashMap使用了链表来解决冲突，也就是所谓的链地址法。

ThreadLocalMap没有使用链表，自然也不是用链地址法来解决冲突了，它用的是另外一种方式——开放定址法。开放定址法是什么意思呢？简单来说，就是这个坑被人占了，那就接着去找空着的坑。

父子线程怎么共享数据？

这时候可以用到另外一个类——InheritableThreadLocal

public class InheritableThreadLocalTest {
    
    public static void main(String[] args) {
        final ThreadLocal threadLocal = new InheritableThreadLocal();
        // 主线程
        threadLocal.set("不擅技术");
        //子线程
        Thread t = new Thread() {
            @Override
            public void run() {
                super.run();
                System.out.println("张三 ，" + threadLocal.get());
            }
        };
        t.start();
    }
}

Java内存模型

说一下你对Java内存模型（JMM）的理解？

Java内存模型（Java Memory Model，JMM），是一种抽象的模型，被定义出来屏蔽各种硬件和操作系统的内存访问差异。

线程池

什么是线程池？

说的简单点，就是帮我们管理线程的池子。

避免增加创建线程和销毁线程的资源损耗。因为线程其实也是一个对象，创建一个对象，需要经过类加载过程，销毁一个对象，需要走GC垃圾回收流程，都是需要资源开销的。

提高响应速度。 如果任务到达了，相对于从线程池拿线程，重新去创建一条线程执行，速度肯定慢很多。

重复利用。 线程用完，再放回池子，可以达到重复利用的效果，节省资源

线程池主要参数有哪些？

线程池有七大参数，需要重点关注corePoolSize、maximumPoolSize、workQueue、handler这四个。

1. corePoolSize

此值是用来初始化线程池中核心线程数，当线程池中线程池数< corePoolSize时，系统默认是添加一个任务才创建一个线程池。当线程数 = corePoolSize时，新任务会追加到workQueue中。

1. maximumPoolSize

maximumPoolSize表示允许的最大线程数 = (非核心线程数+核心线程数)，当BlockingQueue也满了，但线程池中总线程数 < maximumPoolSize时候就会再次创建新的线程。

1. keepAliveTime

非核心线程 =(maximumPoolSize - corePoolSize ) ,非核心线程闲置下来不干活最多存活时间。

1. unit

线程池中非核心线程保持存活的时间的单位

• TimeUnit.DAYS; 天
• TimeUnit.HOURS; 小时
• TimeUnit.MINUTES; 分钟
• TimeUnit.SECONDS; 秒
• TimeUnit.MILLISECONDS; 毫秒
• TimeUnit.MICROSECONDS; 微秒
• TimeUnit.NANOSECONDS; 纳秒

2. workQueue

线程池等待队列，维护着等待执行的Runnable对象。当运行当线程数= corePoolSize时，新的任务会被添加到workQueue中，如果workQueue也满了则尝试用非核心线程执行任务，等待队列应该尽量用有界的。

3. threadFactory

创建一个新线程时使用的工厂，可以用来设定线程名、是否为daemon线程等等。

4. handler

corePoolSize、workQueue、maximumPoolSize都不可用的时候执行的饱和策略。

锁

synchronized用过吗？怎么使用？

synchronized经常用的，用来保证代码的原子性。它可以用来修饰方法或代码块，确保在同一时间只有一个线程可以执行被synchronized修饰的代码。

synchronized主要有三种用法：

• 修饰实例方法: 作用于当前对象实例加锁，进入同步代码前要获得 当前对象实例的锁

synchronized void method() {
  //业务代码
}

• 修饰静态方法：也就是给当前类加锁，会作⽤于类的所有对象实例 ，进⼊同步代码前要获得当前 class 的锁。因为静态成员不属于任何⼀个实例对象，是类成员（ static 表明这是该类的⼀个静态资源，不管 new 了多少个对象，只有⼀份）。

  如果⼀个线程 A 调⽤⼀个实例对象的⾮静态 synchronized ⽅法，⽽线程 B 需要调⽤这个实例对象所属类的静态 synchronized ⽅法，是允许的，不会发⽣互斥现象，因为访问静态 synchronized ⽅法占⽤的锁是当前类的锁，⽽访问⾮静态 synchronized ⽅法占⽤的锁是当前实例对象锁。

synchronized void staic method() {
 //业务代码
}

• 修饰代码块 ：指定加锁对象，对给定对象/类加锁。 synchronized(this|object) 表示进⼊同步代码库前要获得给定对象的锁。 synchronized(类.class) 表示进⼊同步代码前要获得 当前 class 的锁

说说synchronized和ReentrantLock的区别？

synchronized是Java语言的关键字，而ReentrantLock是基于JDK的API层面进行的实现

• ReentrantLock提供了一种能够中断等待锁的线程的机制，通过lock.lockInterruptibly()来实现这个机制
• ReentrantLock可以指定是公平锁还是非公平锁。而synchronized只能是非公平锁。所谓的公平锁就是先等待的线程先获得锁。
• synchronized与wait()和notify()/notifyAll()方法结合实现等待/通知机制，ReentrantLock类借助Condition接口与newCondition()方法实现。
• ReentrantLock需要手工声明来加锁和释放锁，一般跟finally配合释放锁。而synchronized不用手动释放锁。

区别	synchronized	ReentrantLock
锁实现机制	对象头监视器模式	依赖AQS
灵活性	不灵活	支持响应中断、超时、尝试获取锁
释放锁形式	自动释放锁	显式调用unlocak()
支持锁类型	非公平锁	公平锁&非公平锁
条件队列	单条件队列	多个条件队列
可重入支持	支持	支持

CAS是什么？

Compare and Swap是一种基于锁的操作，乐观锁的一种实现方式。它用于在多线程环境下保证数据的一致性和并发性。

CAS操作包含三个操作数：内存地址(或变量)、旧的预期值、新的预期值

执行过程：

读取内存地址中的当前值和旧的值比较，如果当前两个值相等，将新的值写入内存地址，完成操作，如果当前值不等于旧的预期值，则说明其他线程已经修改了该内存地址的值，操作失败。

CAS操作的特点是乐观锁，它并不直接对数据进行锁定，而是通过比较和交换的方式来实现数据的一致性。

如何解决ABA问题？

CAS（Compare and Swap）操作中可能会遇到ABA问题，这是指一个值被另一个线程修改后，又改回原来的值，CAS操作无法判断这个值是否被其他线程修改过。

解决方法：
1.使用带版本号的CAS操作，每次修改数据同时修改版本号，在CAS操作时，同时检查版本号是否一致，都一致再进行交换操作

2.使用带标记的CAS操作，在CAS操作是，还需要比较替换标记。每次进行修改操作时，都会改变标记的值。如果值恢复原来的值，但是标记也会发生变化。

据进行锁定，而是通过比较和交换的方式来实现数据的一致性。

如何解决ABA问题？

CAS（Compare and Swap）操作中可能会遇到ABA问题，这是指一个值被另一个线程修改后，又改回原来的值，CAS操作无法判断这个值是否被其他线程修改过。

解决方法：
1.使用带版本号的CAS操作，每次修改数据同时修改版本号，在CAS操作时，同时检查版本号是否一致，都一致再进行交换操作

2.使用带标记的CAS操作，在CAS操作是，还需要比较替换标记。每次进行修改操作时，都会改变标记的值。如果值恢复原来的值，但是标记也会发生变化。