JAVA并发基础知识复习整体

当线程刚被创建时是new，调用start()方法则是可运行状态、当线程试图获取一个锁进入同步块时，如果锁被其他线程持有，则进入阻塞状态，直到它获取到，调用了共享对象的wait方法进入waiting状态，waiting（time）则是 time_waiting状态,线程执行完毕后是terminated状态

1.7 什么是线程上下文切换？

上下文切换是，假如是单核处理器，CPU资源分配采取了时间片轮转，每个线程会分配到一个时间片，消耗完进行线程的切换，这就是上下文切换。使用户觉得同一时间执行了多个任务。

1.8 守护线程了解吗

线程分为用户线程和守护线程，JVM不会因为守护线程没有执行完毕而不正常退出，意思就是只要用户线程结束，JVM就正常退出。垃圾回收就是一种守护线程

1.9 线程间的通讯方式

使用共享对象，关键字volitate、synchronized

使用wait和notify

使用completablefutur类，支持异步编程，可以将一个线程的结果传递给其他线程

1.10 sleep和wait的区别

sleep是Thread类的静态方法，wait属于Object类的普通方法

线程调用sleep方法时不会释放本身获取的资源，调用wait方法时，会将获取到的锁释放

sleep在何时都能被调用，wait方法只有在获取锁对象时调用

sleep方法过时自动唤醒，wait需要其他线程调用notify方法

二 ThreadLocal

2.1 ThreadLocal是什么

ThreadLocal是java提供的实现线程局部变量的工具类，允许每个线程拥有自己的独立副本，实现线程隔离，用于解决多线程中共享变量的线程安全问题

2.2 ThreadLocal怎么实现

ThreadLocal本身并不存储任何值，当一个线程调用Threadlocal的get或set方法时，实际访问的是线程自己的ThreadLocalMap。

ThreadLocalMap是ThreadLocal的静态内部类，内部维护一个Entry数组，key是ThreadLocal对象，value是线程局部变量本身。其key是一个弱引用。

ThreadLocal 的实现原理就是，每个线程维护一个 Map，key 为 ThreadLocal 对象，value 为想要实现线程隔离的对象。

1、当需要存线程隔离的对象时，通过 ThreadLocal 的 set 方法将对象存入 Map 中。

2、当需要取线程隔离的对象时，通过 ThreadLocal 的 get 方法从 Map 中取出对象。

3、Map 的大小由 ThreadLocal 对象的多少决定。

2.3 ThreadLocal内存泄漏是怎么回事

通常情况下ThreadLocalMap会随着线程的结束而销毁，避免了内存泄漏

但如果一个线程一直运行，并且ThreadLocalMap的Entry.value一直指向某个强引用对象，那么这个对象则不会被回收，从而导致内存泄漏，当Entry非常多时，可能会发生严重的内存泄漏

如何解决

使用完ThreadLocal后，即使调用remove（）方法释放内存空间

remove方法会将所有key为null的Entry全部清除

2.4 为什么key要设计成弱引用

弱引用的好处是当进行垃圾回收时，会将弱引用对象清除

一旦key被回收，Threadlocal进行set，get方法时会将Key为null的Entry进行清理

2.5 ThreadLocalMap源码看过吗

其叫Map但是没有实现Map的接口，结构和HashMap有些类似，主要关注元素数组和散列方法

元素数组 table数组存储Entry类型的元素，Key为弱引用，Object为value

散列方法 key的hashcode和table数组长度取余

采用开放定址方法解决hash冲突，在 get 的时候，也会根据 ThreadLocal 对象的 hash 值，定位到 table 中的位置，然后判断该槽位 Entry 对象中的 key 是否和 get 的 key 一致，如果不一致，就判断下一个位置。

2.6 ThreadLocalMap 扩容机制了解吗

HashMap的扩容因子是0.75，ThreadLocalMap的扩容阈值是2/3

如果执行完清理工作后，未清理任何数据，并且此时散列数组中的Entry数量达到了列表的上限，就开始rehash逻辑

rehash()具体实现：这里会先去清理过期的 Entry，然后还要根据条件判断size >= threshold - threshold / 4 也就是size >= threshold* 3/4来决定是否需要扩容。

resize()方法，扩容后的newTab的大小为老数组的两倍，然后遍历老的 table 数组，散列方法重新计算位置，开放地址解决冲突，然后放到新的newTab，遍历完成之后，oldTab中所有的entry数据都已经放入到newTab中了，然后 table 引用指向newTab

2.7 父子线程怎么共享数据

在主线程的 InheritableThreadLocal 实例设置值，在子线程中就可以拿到了

三 JAVA内存模型

3.1 说一下对java内存模型的理解

JMM是java内存模型，是一种抽象的模型。它主要定义多线程中变量的访问规则，用来解决变量的原子性，可见性，有序性问题。确保在并发环境中安全地访问共享变量。

每个线程都有自己的独立内存，共享变量存储在主内存中，本地内存中存储了共享变量的副本，用来进行线程内部的读写操作

当一个线程更改本地的共享变量副本后需要将这些更改刷入到主内存中，确保其他线程可以看到这些更改

当一个线程需要读取共享变量时，他可能首先从本地内存中读取。如果本地内存副本是过时的，线程就从主内存中重写加载共享变量的最新值到本地内存中

为什么线程要有自己的内存？

在多线程环境下，如果所有线程都直接操作主内存的共享变量，会引起更很多的内存访问竞争，影响性能，通过让每个线程使用本地内存，可以减少这类的竞争，提高程序的并发性能

现在CPU为了优化执行效率，可能会进行指令重排，使用本地内存可以不影响最终结果的前提下，使CPU有更大自由来乱序执行指令，提高执行效率

3.2 说说对原子性、可见性、有序性的见解

原子性：保证一个操作是不可分割的，要么同时成功要么同时失败

可见性：一个线程对一个共享变量进行修改要保证能够及时的被其他线程知道

有序性：有序性指的是对于一个线程的执行代码，从前往后依次执行，单线程下可以认为程序是有序的，但是并发时有可能会发生指令重排。

3.3 那什么是指令重排

为了提高性能，编译器和处理器常常会对指令做重排序，有三种类型

编译器优化重排序、指令级并行重排序、内存系统重排序

指令重排有限制，两个柜子happens-before和as-if-serial

如果两个操作，一个操作happens-before另一个操作那么第一个操作的结果要对第二个操作可见，而且第一个操作的执行顺序要排在第二个操作之前。如果重排序之后的结果，与按happens-before关系来执行的结果一致，那么这种重排并不非法

as-if-serial意思是不管怎么重排序，保证单线程程序的执行结果不能被改变

3.4 volatile关键字实现原理

volatilebianl关键字不仅能保证变量的可见性，也能保证变量的有序性

当线程对 volatile 变量进行写操作时，JMM 会在写入这个变量之后插入一个 Store-Barrier（写屏障）指令，这个指令会强制将本地内存中的变量值刷新到主内存中。

当线程对 volatile 变量进行读操作时，JMM 会插入一个 Load-Barrier（读屏障）指令，这个指令会强制让本地内存中的变量值失效，从而重新从主内存中读取最新的值。

如何保证有序性

写 volatile 变量的操作之前的操作不会被编译器重排序到写操作之后。
读 volatile 变量的操作之后的操作不会被编译器重排序到读操作之前。

意味着volatile变量的写操作总是发生在任何后续读操作之前

四锁

4.1 synchronized用过吗，怎么使用

synchronized是最常用的锁，synchronized关键字可以修饰方法或代码块，表示这段代码同一时间只允许一个线程执行

4.2 synchronized的实现原理

synchronized修饰代码块时，JVM会通关两个指令实现同步monitorenter和monitorexit，表示中间这代码块加锁。

其如何保证可见性：线程加锁前，将清空工作内存中共享变量的值，从而使用共享变量时需要从主内存中重新读取最新的值。加锁后，其他线程无法获取内存中的共享变量，解锁前刷新共享变量新值到主内存中。

如何保证有序性：同步代码块一次只能一个线程进入，保证了结果的有序性

其如何实现重入呢：synchronized维护一个锁计数器，每当一个线程尝试获取已持有的锁，JVM会检查mark word中锁线程ID，如果匹配锁计数递增，当线程退出同步代码块时，锁计数器递减。为零JVM将锁标记未持有状态，并清除线程ID

4.2 锁升级？synchronized优化了解吗

Mark Word中存有哈希码，GC 年龄，锁状态，偏向时间戳等

锁状态标志用来记录锁的状态：无锁状态、偏向锁状态、轻量级锁、重量级锁

无锁状态，这么状态下，没有线程试图获取锁

偏向锁：第一个线程进入同步代码块，锁进入偏向模式，存储其线程ID，目的是消除同一线程释放锁和获取锁的开销

轻量级锁：当有多个线程竞争，但交替执行代码快，会升级为轻量级锁

重量级锁：竞争激烈会膨胀成重量级锁

4.3 说说synchronized和ReentrantLock的区别

synchronized可以直接在方法上加锁，也可以在代码块上加锁

Reentrantlock必须手动声明来加锁和释放锁

Reentrantlock可以指定是公平锁还是非公平锁

ReentrantReadWritelock读写锁，读锁是共享锁，写锁是独占锁，读锁可以被多个线程持有，写锁只能被一个线程持有。这种锁的设计可以提高性能。

4.4 说说AQS

AQS 是abstractqueuedSynchronizer中文意思是抽象队列同步器是java并发包的核心框架类，ReentrantLock类的实现就依赖于它

AQS的思想是如果被请求的共享资源空闲则当前线程获取资源，否则进入一个等待队列，当有其他线程释放资源时，会挑选一个线程，赋予其资源，通过维护一个先进先出队列实现对共享资源的管理。

4.5 ReentrantLock的实现原理

它是一个可重入的独占锁，只有一个线程可以获取该锁，其他获取锁的线程会被阻塞。

公平锁模式下，锁会授予等待时间最长的线程

非公平锁模式下，锁可能会授予刚刚请求的线程，而不考虑时间。

线程调用锁.lock（）方法来尝试获取锁，获取时锁计数器变为1，同一线程再次获取锁则计数器增加，unlock释放锁计数器减一，达到0就释放，并唤醒等待队列的线程来竞争

公平锁需要在reentrantlock构造方法中传入true则是公平锁默认是非公平锁

4.6 CAS了解吗

CAS是一种乐观锁的实现方式，全称是交换并比较，是一种无锁操作，它假设没有冲突，然后完成某项操作后，再和旧值比较，符合条件就更新，不符合就重试。

有三个值：要更新的变量，预期值（旧值），新值

他比较更新的变量时候还是旧值，如果是则将V的值设为N，如果不是说明有其他线程更新了V，于是就放弃这次更改，重新尝试

4.7 CAS有什么问题

ABA问题：如果变量被其他线程从A 改到 B再改回A，那么这个线程就无法知晓变量曾被修改过。

可以通过添加版本号来解决该问题

循环性能开销：自旋CAS，如果一直循环，会给CPU造成较大的开销

可以添加一个自旋次数最大值，超过这个值就停止自旋

只能保证一个变量的原子性操作

CAS 保证的是对一个变量执行操作的原子性，如果对多个变量操作时，CAS 目前无法直接保证操作的原子性的。

考虑用锁来保证操作的原子性

4.8 JAVA有哪些保证原子性的方法

juc包下的锁

原子类，AtomicInteger

使用synchronized

4.9 线程死锁了解吗？如何避免

死锁发生在多个线程互相等待对方释放资源，导致线程都无法继续执行

死锁产生的四个条件：

互斥条件：资源不能被多个线程共享，一次只能由一个线程使用。

请求并持有：一个线程已持有至少一个资源，且正在等待额外资源

不可剥夺条件：资源不能强制从另一个线程中抢过来，只能由持有资源的线程主动释放

环路等待条件：每个线程至少持有其他线程所需要的资源，然后又等待下一个线程所占有的资源，形成一个循环等待环路

避免方法：线程开始前一次性的申请所有需要的资源

当占有资源的线程申请其他资源申请不到时，可以主动释放它占有的资源

对所有资源类型进行排序，强制每个线程按顺序申请资源，可以避免循环等待的发生

4.10 死锁问题如何排除

jps、jstat、jinfo、jmap、jstack、jcmd

4.11 聊一聊线程同步

线程同步是指线程能够有顺序的访问共享资源，以免造成混乱，当一个线程正在执行公共资源时，其他线程要等待其执行结束后再进行操作，如果多个线程同时读写共享资源，没有同步机制，就会导致数据不一致，数据混乱的现象。线程同步的方式有6中，互斥量、信号量、读写锁、条件变量、自旋锁、屏障。

4.12 聊一聊悲观锁和乐观锁

悲观锁认为每次访问共享资源时候都会有竞争，所以每次都要对数据操作上锁，保证同一时间只有一个线程执行代码块

乐观锁认为每次访问共享资源不会有竞争，线程可以不停的执行，无需加锁。一旦多个线程发送冲突，乐观送通过CAS保证线程执行的安全性。

五并发工具类

5.1 countdownlatch了解吗？

其是JUC包中的一个工具类，用于协调多个线程之间的同步。它允许一个或多个线程等待，直到其他线程中执行的一组操作完成。通过一个计数器实现，该计算器数由线程递减，直至到零

初始化contdonwlatch对象设置计数器初值，一个或多个线程调用await方法，进入等待状态。其他线程完成任务后调用countdown方法，计数器值减一，到零时await上等待的线程被唤醒，继续执行。

5.2 cyclicBarrier同步屏障了解吗

同步屏障的意思是当一组线程全部都到达同步点时，屏障才会开门，所有被屏障拦截的线程才会继续运行。

与countdownlatch的区别

同步屏障是可重用的，countdownlatch是一次性的

countdownlatch中的各个子线程不可以等待其他线程只完成自己的任务，而同步屏障中的各个线程可以等待其他线程。

5.3 信号量了解吗？

信号量用来控制同时访问特点资源的线程数量，它通过协调各个线程，以保证合理的使用公共资源。

5.4 Exchanger了解吗？

Exchanger是一个用于线程间协作的工具类,用于进行线程间的数据交换，提供一个同步点，这个同步点线程可以交换彼此的数据。这两个线程通过 exchange 方法交换数据，如果第一个线程先执行 exchange()方法，它会一直等待第二个线程也执行 exchange 方法，当两个线程都到达同步点时，这两个线程就可以交换数据，将本线程生产出来的数据传递给对方。

六线程池

6.1 什么是线程池

频繁的创建或者销毁线程会给系统造成不必要的开销，设计线程池可以对线程进行统一的管理，提高系统工作效率。

6.2 线程池的工作流程

当一个任务到达时，线程池会根据当前线程的状态和参数来处理这个任务

如果线程池中的核心线程都在忙，但还未达到设置的最大线程数，就将任务放入到等待队列中。

若任务队列已满并且线程数量小于最大线程数，则线程池会创建新的线程来执行任务。

空闲的线程会从任务队列中取出任务来执行，执行完毕后不会立即销毁，当线程超过指定时间时，临时线程会被回收

6.3 线程池的主要参数有哪些

核心线程数，等待队列，最大线程数，非核心线程存活时间，非核心线程存活时间单位，拒绝策略，创建线程使用工厂

6.4 线程池的拒绝策略有哪些

1. 抛出rejectedExcutorException异常，拒绝接受

2.让提交的线程执行此任务

3.丢弃任务队列中等待时间最长的一次任务，重新提交该任务

4.直接忽略该任务，也不抛异常

6.5 线程池有哪几种等待队列

数组实现有界队列

链表实现无界队列

延时执行队列

支持优先级无界阻塞队列

无元素存储阻塞队列

6.6 线程池提交Execute和submit方法的区别

execute 提交不需要返回值的任务

submit用于提交需要返回值的任务，线程池返回一个future类型的对象，future的get方法来获取返回值

6.7 线程池怎么关闭

shutdown和shutdownnow的方法来关闭线程池

shutdown方法将线程池状态设置为shudown

停止外部接受submit任务

将任务队列中的任务执行完才真正停止

shutdownnow将线程状态设置为stop

停止接受外部提交的任务

放弃等待队列中的任务

尝试将正在跑的任务中断

返回未执行的任务列表

6.8 线程池参数该怎么设置

I/O密集型任务的化核心线程数设置为处理机数的两倍

CPU密集型任务，设置处理器核心数或核心数+1。

6.9 有哪几种常见的线程池

1. 固定线程数目的线程池

核心线程数=最大线程数

阻塞队列无界阻塞队列

非核心线程数存活时间为0

适用于处理CPU密集型任务

2.可缓存线程的线程池

核心线程数为0

最大线程数为无限大

阻塞队列是无元素存储队列，非核心线程存活时间为60秒

适用于并发量大短期执行的小任务

3. 单线程的线程池

核心线程数 1

最大核心线程数1

队列无界阻塞队列，非核心线程存活时间为0

4. 定时以及周期执行的线程池

最大线程数为无线大

阻塞队列是延时阻塞队列

按某种速率执行任务，在某个延迟后执行任务

6.10 线程池异常怎么处理

6.11 线程池有哪几种状态

RUNNING、SHUTDOWN、STOP、TIDYING、TERMINATED

RUNNING状态可接受和处理阻塞队列的任务

shutdown将状态转换为shutdown状态

shutdownnow将状态转换为stop状态

等队列为空并且线程池中的任务也为空时进入TIDYING状态

该状态表示所有任务数为0

terminated执行完毕进入terminated状态表示线程池彻底终止

敲键盘的吗喽_1219

关注

7
点赞
踩
29

收藏

觉得还不错? 一键收藏
0
评论
JAVA并发基础知识复习整体

进程是操作系统分配资源的基本单元，比如开一个浏览器、打开一个微信程序就是一个进程，进程中包含线程。线程是CPU分配资源的基本单元，线程之间的切换由cpu决定协程是比线程更轻量的并发单元，可以由程序员控制其运行以及线程间通信，可以用completefuture模拟协程式异步执行任务上下文切换是，假如是单核处理器，CPU资源分配采取了时间片轮转，每个线程会分配到一个时间片，消耗完进行线程的切换，这就是上下文切换。使用户觉得同一时间执行了多个任务。为了提高性能，编译器和处理器常常会对指令做重排序，有三种类型。
复制链接

扫一扫