⾯试题Java并发包_Java并发进阶常见⾯试题总结
1.2. 说说⾃⼰是怎么使⽤ synchronized 关键字，在项⽬中⽤到了吗
synchronized关键字最主要的三种使⽤⽅式：
修饰实例⽅法: 作⽤于当前对象实例加锁，进⼊同步代码前要获得当前对象实例的锁
修饰静态⽅法: ：也就是给当前类加锁，会作⽤于类的所有对象实例，因为静态成员不属于任何⼀个实例对象，是类成员( static 表明这是该类的⼀个静态资源，不管new了多少个对象，只有⼀份)。所以如果⼀个线程A调⽤⼀个实例对象的⾮静态 synchronized ⽅法，⽽线程B需要调⽤这个实例对象所属类的静态 synchronized ⽅法，是允许的，不会发⽣互斥现象，因为访问静态 synchronized ⽅法占⽤的锁是当前类的锁，⽽访问⾮静态 synchronized ⽅法占⽤的锁是当前实例对象锁。
修饰代码块: 指定加锁对象，对给定对象加锁，进⼊同步代码库前要获得给定对象的锁。
总结： synchronized 关键字加到 static 静态⽅法和 synchronized(class)代码块上都是是给 Class 类上锁。synchronized 关键字加到实例⽅法上是给对象实例上锁。尽量不要使⽤ synchronized(String a) 因为JVM中，字符串常量池具有缓存功能！
双重校验锁实现对象单例(线程安全)
public classSingleton {private volatile staticSingleton uniqueInstance;privateSingleton() {
}public staticSingleton getUniqueInstance() {//先判断对象是否已经实例过，没有实例化过才进⼊加锁代码
if (uniqueInstance == null) {//类对象加锁
synchronized (Singleton.class) {if (uniqueInstance == null) {
uniqueInstance= newSingleton();
}
}
}returnuniqueInstance;
}
}
① synchronized 同步语句块的情况
synchronized 同步语句块的实现使⽤的是monitorenter 和 monitorexit 指令，其中 monitorenter 指令指向同步代码块的开始位
置，monitorexit 指令则指明同步代码块的结束位置。 当执⾏ monitorenter 指令时，线程试图获取锁也就是获取 monitor(monitor对象存在于每个Java对象的对象头中，synchronized 锁便是通过这种⽅式获取锁的，也是为什么Java中任意对象可以作为锁的原因) 的持有权。当计数器为0则可以成功获取，获取后将锁计数器设为1也就是加1。相应的在执⾏ monitorexit 指令后，将锁计数器设为0，表明锁被释放。如果获取对象锁失败，那当前线程就要阻塞等待，直到锁被另外⼀个线程释放为⽌。
1.5. 谈谈 synchronized和ReentrantLock 的区别
① 两者都是可重⼊锁
两者都是可重⼊锁。“可重⼊锁”概念是：⾃⼰可以再次获取⾃⼰的内部锁。⽐如⼀个线程获得了某个对象的锁，此时这个对象锁还没有释放，当其再次想要获取这个对象的锁的时候还是可以获取的，如果不可锁重⼊的话，就会造成死锁。同⼀个线程每次获取锁，锁的计数器都⾃增1，所以要等到锁的计数器下降为0时才能释放锁。
② synchronized 依赖于 JVM ⽽ ReentrantLock 依赖于 API
synchronized 是依赖于 JVM 实现的，前⾯我们也讲到了 虚拟机团队在 JDK1.6 为 synchronized 关键字进⾏了很多优化，但是这些优化都是在虚拟机层⾯实现的，并没有直接暴露给我们。ReentrantLock 是 JDK 层⾯实现的(也就是 API 层⾯，需要 lock() 和 unlock() ⽅法配合 try/finally 语句块来完成)，所以我们可以通过查看它的源代码，来看它是如何实现的。
③ ReentrantLock ⽐ synchronized 增加了⼀些⾼级功能
相⽐synchronized，ReentrantLock增加了⼀些⾼级功能。主要来说主要有三点：①等待可中断；②可实现公平锁；③可实现选择性通知(锁可以绑定多个条件)
ReentrantLock提供了⼀种能够中断等待锁的线程的机制，通过lock.lockInterruptibly()来实现这个机制。也就是说正在等待的线程可以选择放弃等待，改为处理其他事情。
ReentrantLock可以指定是公平锁还是⾮公平锁。⽽synchronized只能是⾮公平锁。所谓的公平锁就是先等待的线程先获得锁。
ReentrantLock默认情况是⾮公平的，可以通过 ReentrantLock类的ReentrantLock(boolean fair)构造⽅法来制定是否是公平的。
synchronized关键字与wait()和notify()/notifyAll()⽅法相结合可以实现等待/通知机制，ReentrantLock类
当然也可以实现，但是需要借助于Condition接⼝与newCondition() ⽅法。Condition是JDK1.5之后才有的，它具有很好的灵活性，⽐如可以实现多路通知功能也就是在⼀个Lock对象中可以创建多个Condition实例(即对象监视器)，线程对象可以注册在指定的Condition中，从⽽可以有选择性的进⾏线程通知，在调度线程上更加灵活。 在使⽤notify()/notifyAll()⽅法进⾏通知时，被通知的线程是由 JVM 选择的，⽤ReentrantLock类结合Condition实例可以实现“选择性通知” ，这个功能⾮常重要，⽽且是Condition接⼝默认提供的。⽽synchronized关键字就相当于整个Lock对象中只有⼀个Condition实例，所有的线程都注册在它⼀个⾝上。如果执⾏notifyAll()⽅法的话就会通知所有处于等待状态的线程这样会造成很⼤的效率问题，⽽Condition实例的signalAll()⽅法 只会唤醒注册在该Condition实例中的所有等待线程。
2. volatile关键字
2.1. 讲⼀下Java内存模型
在 JDK1.2 之前，Java的内存模型实现总是从主存(即共享内存)读取变量，是不需要进⾏特别的注意的。⽽在当前的 Java 内存模型下，线程可以把变量保存本地内存⽐如机器的寄存器)中，⽽不是直接在主存中进⾏读写。这就可能造成⼀个线程在主存中修改了⼀个变量的值，⽽另外⼀个线程还继续使⽤它在寄存器中的变量值的拷贝，造成数据的不⼀致。
要解决这个问题，就需要把变量声明为volatile，这就指⽰ JVM，这个变量是不稳定的，每次使⽤它都到主存中进⾏读取。
说⽩了， volatile 关键字的主要作⽤就是保证变量的可见性然后还有⼀个作⽤是防⽌指令重排序。
2.2. 说说 synchronized 关键字和 volatile 关键字的区别
synchronized关键字和volatile关键字⽐较
volatile关键字是线程同步的轻量级实现，所以volatile性能肯定⽐synchronized关键字要好。但是volatile关键字只能⽤于变量⽽synchronized关键字可以修饰⽅法以及代码块。synchronized关键字在JavaSE1.6之后进⾏了主要包括为了减少获得锁和释放锁带来的性能消耗⽽引⼊的偏向锁和轻量级锁以及其它各种优化之后执⾏效率有了显著提升，实际开发中使⽤ synchronized 关键字的场景还是更多⼀些。
多线程访问volatile关键字不会发⽣阻塞，⽽synchronized关键字可能会发⽣阻塞
volatile关键字能保证数据的可见性，但不能保证数据的原⼦性。synchronized关键字两者都能保证。
volatile关键字主要⽤于解决变量在多个线程之间的可见性，⽽ synchronized关键字解决的是多个线程之间访问资源的同步性。
3.1. ThreadLocal简介
通常情况下，我们创建的变量是可以被任何⼀个线程访问并修改的。如果想实现每⼀个线程都有⾃⼰的专属本地变量该如何解决呢？ JDK中提供的ThreadLocal类正是为了解决这样的问题。 ThreadLocal类主要解决的就是让每个线程绑定⾃⼰的值，可以将ThreadLocal类形象的⽐喻成存放数据的盒⼦，盒⼦中可以存储每个线程的私有数据。
如果你创建了⼀个ThreadLocal变量，那么访问这个变量的每个线程都会有这个变量的本地副本，这也是ThreadLocal变量名的由来。他们可以使⽤ get() 和 set() ⽅法来获取默认值或将其值更改为当前线程所存的副本的值，从⽽避免了线程安全问题。
3.3. ThreadLocal原理
从 Thread类源代码⼊⼿。
public class Thread implementsRunnable {
......//与此线程有关的ThreadLocal值。由ThreadLocal类维护
ThreadLocal.ThreadLocalMap threadLocals = null;//与此线程有关的InheritableThreadLocal值。由InheritableThreadLocal类维护
ThreadLocal.ThreadLocalMap inheritableThreadLocals = null;
......
}
从上⾯Thread类 源代码可以看出Thread 类中有⼀个 threadLocals 和 ⼀个 inheritableThreadLocals 变量，它们都
是 ThreadLocalMap 类型的变量，我们可以把 ThreadLocalMap 理解为ThreadLocal 类实现的定制化的 HashMap。默认情况下这两个变量都是null，只有当前线程调⽤ ThreadLocal 类的 set或get⽅法时才创建它们，实际上调⽤这两个⽅法的时候，我们调⽤的是ThreadLocalMap类对应的 get()、set()⽅法。
ThreadLocal类的set()⽅法
public voidset(T value) {
Thread t=Thread.currentThread();
ThreadLocalMap map=getMap(t);if (map != null)
map.set(this, value);elsecreateMap(t, value);
}
ThreadLocalMap getMap(Thread t) {returnt.threadLocals;
}
通过上⾯这些内容，我们⾜以通过猜测得出结论：最终的变量是放在了当前线程的 ThreadLocalMap 中，并不是存
在 ThreadLocal 上，ThreadLocal 可以理解为只是ThreadLocalMap的封装，传递了变量值。 ThrealLocal 类中可以通过
Thread.currentThread()获取到当前线程对象后，直接通过getMap(Thread t)可以访问到该线程的ThreadLocalMap对象。
每个Thread中都具备⼀个ThreadLocalMap，⽽ThreadLocalMap可以存储以ThreadLocal为key的键值对。 ⽐如我们在同⼀个线程中声明了两个 ThreadLocal 对象的话，会使⽤ Thread内部都是使⽤仅有那个ThreadLocalMap 存放数据的，ThreadLocalMap的 key 就
是 ThreadLocal对象，value 就是 ThreadLocal 对象调⽤set⽅法设置的值。ThreadLocal 是 map结构是为了让每个线程可以关联多
个 ThreadLocal变量。这也就解释了 ThreadLocal 声明的变量为什么在每⼀个线程都有⾃⼰的专属本地变量。
4.1. 为什么要⽤线程池？
线程池提供了⼀种限制和管理资源(包括执⾏⼀个任务)。 每个线程池还维护⼀些基本统计信息，例如已完成任务的数量。
这⾥借⽤《Java并发编程的艺术》提到的来说⼀下使⽤线程池的好处：
降低资源消耗。 通过重复利⽤已创建的线程降低线程创建和销毁造成的消耗。
提⾼响应速度。 当任务到达时，任务可以不需要的等到线程创建就能⽴即执⾏。
提⾼线程的可管理性。 线程是稀缺资源，如果⽆限制的创建，不仅会消耗系统资源，还会降低系统的稳定性，使⽤线程池可以进⾏统⼀的分配，调优和监控。
4.4. 如何创建线程池
⽅式⼀：通过ThreadPoolExecutor构造⽅法实现
packagejava_guide;urrent.ArrayBlockingQueue;urrent.BlockingQueue; classThreadPoolTest {public static voidmain(String[] args) {jvm面试题总结及答案
BlockingQueue blockingQueue= new ArrayBlockingQueue(20);
ThreadPoolExecutor threadPoolExecutor= new ThreadPoolExecutor(10, 15,60, TimeUnit.SECONDS, blockingQueue);for (int
i = 0; i < 30; i++) {
}
threadPoolExecutor.shutdown();
}
}class TaskWithoutResult implementsRunnable {private int sleepTime = 1000;//默认睡眠时间1s
public TaskWithoutResult(intsleepTime) {this.sleepTime =sleepTime;
}
@Overridepublic voidrun() {
System.out.println("线程" + Thread.currentThread() + "开始运⾏");try{
Thread.sleep(sleepTime);
}catch (InterruptedException e) {//捕捉中断异常
System.out.println("线程" + Thread.currentThread() + "被中断");
}
System.out.println("线程" + Thread.currentThread() + "结束运⾏");
}
}
View Code
⽅式⼆：通过Executor 框架的⼯具类Executors来实现 我们可以创建三种类型的ThreadPoolExecutor：
FixedThreadPool ： 该⽅法返回⼀个固定线程数量的线程池。该线程池中的线程数量始终不变。当有⼀个新的任务提交时，线程池中若有
空闲线程，则⽴即执⾏。若没有，则新的任务会被暂存在⼀个任务队列中，待有线程空闲时，便处理在任务队列中的任务。
SingleThreadExecutor： ⽅法返回⼀个只有⼀个线程的线程池。若多余⼀个任务被提交到该线程池，任务会被保存在⼀个任务队列中，待
线程空闲，按先⼊先出的顺序执⾏队列中的任务。
CachedThreadPool： 该⽅法返回⼀个可根据实际情况调整线程数量的线程池。线程池的线程数量不确定，但若有空闲线程可以复⽤，则
会优先使⽤可复⽤的线程。若所有线程均在⼯作，⼜有新的任务提交，则会创建新的线程处理任务。所有线程在当前任务执⾏完毕后，将返
回线程池进⾏复⽤。
5.1. 介绍⼀下Atomic 原⼦类
Atomic 翻译成中⽂是原⼦的意思。在化学上，我们知道原⼦是构成⼀般物质的最⼩单位，在化学反应中是不可分割的。在我们这⾥
Atomic 是指⼀个操作是不可中断的。即使是在多个线程⼀起执⾏的时候，⼀个操作⼀旦开始，就不会被其他线程⼲扰。
所以，所谓原⼦类说简单点就是具有原⼦/原⼦操作特征的类。
并发包 urrent 的原⼦类都存放在urrent.atomic下，如下图所⽰。
5.2. JUC 包中的原⼦类是哪4类?
基本类型
使⽤原⼦的⽅式更新基本类型
AtomicInteger：整形原⼦类
AtomicLong：长整型原⼦类
AtomicBoolean：布尔型原⼦类
数组类型
使⽤原⼦的⽅式更新数组⾥的某个元素
AtomicIntegerArray：整形数组原⼦类
AtomicLongArray：长整形数组原⼦类
AtomicReferenceArray：引⽤类型数组原⼦类
引⽤类型
AtomicReference：引⽤类型原⼦类
AtomicStampedReference：原⼦更新引⽤类型⾥的字段原⼦类
AtomicMarkableReference ：原⼦更新带有标记位的引⽤类型
对象的属性修改类型
AtomicIntegerFieldUpdater：原⼦更新整形字段的更新器
AtomicLongFieldUpdater：原⼦更新长整形字段的更新器
AtomicStampedReference：原⼦更新带有版本号的引⽤类型。该类将整数值与引⽤关联起来，可⽤于解决原⼦的更新数据和数据的版本号，可以解决使⽤ CAS 进⾏原⼦更新时可能出现的 ABA 问题。
AtomicInteger 类常⽤⽅法
public final int get() //获取当前的值
public final int getAndSet(int newValue)//获取当前的值，并设置新的值
public final int getAndIncrement()//获取当前的值，并⾃增

版权声明：本站内容均来自互联网，仅供演示用，请勿用于商业和其他非法用途。如果侵犯了您的权益请与我们联系QQ:729038198，我们将在24小时内删除。