面试必问!多线程并发问题
多线程并发问题,基本是面试必问的。
大部分同学应该都知道Synchronized
,Lock
,部分同学能说到volatile
、并发包
,优秀的同学则能在前面的基础上,说出Synchronized、volatile的原理,以及并发包中常用的数据结构,例如ConcurrentHashMap的原理。
这篇文章将总结多线程并发的各种处理方式,希望对大家有所帮助。
一、多线程为什么会有并发问题
为什么多线程同时访问(读写)同个变量,会有并发问题?
- Java 内存模型规定了所有的变量都存储在主内存中,每条线程有自己的工作内存。
- 线程的工作内存中保存了该线程中用到的变量的主内存副本拷贝,线程对变量的所有操作都必须在工作内存中进行,而不能直接读写主内存。
- 线程访问一个变量,首先将变量从主内存拷贝到工作内存,对变量的写操作,不会马上同步到主内存。
- 不同的线程之间也无法直接访问对方工作内存中的变量,线程间变量的传递均需要自己的工作内存和主存之间进行数据同步进行。
二、Java 内存模型(JMM)
Java 内存模型(JMM) 作用于工作内存(本地内存)和主存之间数据同步过程,它规定了如何做数据同步以及什么时候做数据同步,如下图。
三、并发三要素
原子性:在一个操作中,CPU 不可以在中途暂停然后再调度,即不被中断操作,要么执行完成,要么就不执行。
可见性:多个线程访问同一个变量时,一个线程修改了这个变量的值,其他线程能够立即看得到修改的值。
有序性:程序执行的顺序按照代码的先后顺序执行。
四、怎么做,才能解决并发问题?(重点)
下面结合不同场景分析解决并发问题的处理方式。
一、volatile
1.1 volatile 特性
保证可见性,不保证原子性
- 当写一个volatile变量时,JVM会把本地内存的变量强制刷新到主内存中
- 这个写操作导致其他线程中的缓存无效,其他线程读,会从主内存读。volatile的写操作对其它线程实时可见。
禁止指令重排序 指令重排序是指编译器和处理器为了优化程序性能对指令进行排序的一种手段,需要遵守一定规则:
- 不会对存在依赖关系的指令重排序,例如 a = 1;b = a; a 和b存在依赖关系,不会被重排序
- 不能影响单线程下的执行结果。比如:a=1;b=2;c=a+b这三个操作,前两个操作可以重排序,但是c=a+b不会被重排序,因为要保证结果是3
1.2 使用场景
对于一个变量,只有一个线程执行写操作,其它线程都是读操作,这时候可以用 volatile 修饰这个变量。
1.3 单例双重锁为什么要用到volatile?
public class TestInstance {private static volatile TestInstance mInstance;public static TestInstance getInstance(){ //1if (mInstance == null){ //2synchronized (TestInstance.class){ //3if (mInstance == null){ //4mInstance = new TestInstance(); //5}}}return mInstance;
}
复制代码
}
假如没有用volatile,并发情况下会出现问题,线程A执行到注释5 new TestInstance()
的时候,分为如下几个几步操作:
- 分配内存
- 初始化对象
- mInstance 指向内存
这时候如果发生指令重排,执行顺序是132,执行到第3的时候,线程B刚好进来了,并且执行到注释2,这时候判断mInstance 不为空,直接使用一个未初始化的对象。所以使用volatile关键字来禁止指令重排序。
1.4 volatile 原理
在JVM底层volatile是采用内存屏障来实现的,内存屏障会提供3个功能:
- 它确保指令重排序时不会把其后面的指令排到内存屏障之前的位置,也不会把前面的指令排到内存屏障的后面;即在执行到内存屏障这句指令时,在它前面的操作已经全部完成;
- 它会强制将缓存的修改操作立即写到主内存
- 写操作会导致其它CPU中的缓存行失效,写之后,其它线程的读操作会从主内存读。
1.5 volatile 的局限性
volatile 只能保证可见性,不能保证原子性写操作对其它线程可见,但是不能解决多个线程同时写的问题。
二、Synchronized
2.1 Synchronized 使用场景
多个线程同时写一个变量。
例如售票,余票是100张,窗口A和窗口B同时各卖出一张票, 假如余票变量用 volatile 修饰,是有问题的。
A窗口获取余票是100,B窗口获取余票也是100,A卖出一张变成99,刷新回主内存,同时B卖出一张变成99,也刷新回主内存,会导致最终主内存余票是99而不是98。
前面说到 volatile 的局限性,就是多个线程同时写的情况,这种情况一般可以使用Synchronized。
Synchronized 可以保证同一时刻,只有一个线程可执行某个方法或某个代码块。
2.2 Synchronized 原理
public class SynchronizedTest {public static void main(String[] args) {synchronized (SynchronizedTest.class) {System.out.println("123");}method();
}private static void method() {}
}
复制代码
将这段代码先用javac
命令编译,再java p -v SynchronizedTest.class
命令查看字节码,部分字节码如下
public static void main(java.lang.String[]);
descriptor: ([Ljava/lang/String;)V
flags: ACC_PUBLIC, ACC_STATIC
Code:stack=2, locals=3, args_size=10: ldc #2 // class com/lanshifu/opengldemo/test/SynchronizedTest2: dup3: astore_14: monitorenter5: getstatic #3 // Field java/lang/System.out:Ljava/io/PrintStream;8: ldc #4 // String 12310: invokevirtual #5 // Method java/io/PrintStream.println:(Ljava/lang/String;)V13: aload_114: monitorexit15: goto 2318: astore_219: aload_120: monitorexit21: aload_222: athrow23: invokestatic #6 // Method method:()V26: return
复制代码
可以看到 4: monitorenter
和 14: monitorexit
,中间是打印的语句。
执行同步代码块,首先会执行monitorenter
指令,然后执行同步代码块中的代码,退出同步代码块的时候会执行monitorexit
指令 。
使用Synchronized进行同步,其关键就是必须要对对象的监视器monitor进行获取,当线程获取monitor后才能继续往下执行,否则就进入同步队列,线程状态变成BLOCK,同一时刻只有一个线程能够获取到monitor,当监听到monitorexit被调用,队列里就有一个线程出队,获取monitor。详情参考:www.jianshu.com/p/d53bf830f…
每个对象拥有一个计数器,当线程获取该对象锁后,计数器就会加一,释放锁后就会将计数器减一,所以只要这个锁的计数器大于0,其它线程访问就只能等待。
2.3 Synchronized 锁的升级
大家对Synchronized的理解可能就是重量级锁,但是Java1.6对 Synchronized 进行了各种优化之后,有些情况下它就并不那么重,Java1.6 中为了减少获得锁和释放锁带来的性能消耗而引入的偏向锁和轻量级锁。
偏向锁: 大多数情况下,锁不仅不存在多线程竞争,而且总是由同一线程多次获得,为了让线程获得锁的代价更低而引入了偏向锁。
当一个线程A访问加了同步锁的代码块时,会在对象头中存 储当前线程的id,后续这个线程进入和退出这段加了同步锁的代码块时,不需要再次加锁和释放锁。
轻量级锁: 在偏向锁情况下,如果线程B也访问了同步代码块,比较对象头的线程id不一样,会升级为轻量级锁,并且通过自旋的方式来获取轻量级锁。
重量级锁: 如果线程A和线程B同时访问同步代码块,则轻量级锁会升级为重量级锁,线程A获取到重量级锁的情况下,线程B只能入队等待,进入BLOCK状态。
2.4 Synchronized 缺点
- 不能设置锁超时时间
- 不能通过代码释放锁
- 容易造成死锁
三、ReentrantLock
上面说到Synchronized
的缺点,不能设置锁超时时间和不能通过代码释放锁,ReentranLock
就可以解决这个问题。
在多个条件变量和高度竞争锁的地方,用ReentrantLock更合适,ReentrantLock还提供了Condition
,对线程的等待和唤醒等操作更加灵活,一个ReentrantLock可以有多个Condition实例,所以更有扩展性。
3.1 ReentrantLock 的使用
lock 和 unlock
ReentrantLock reentrantLock = new ReentrantLock();System.out.println("reentrantLock->lock");reentrantLock.lock();try {System.out.println("睡眠2秒...");Thread.sleep(2000);} catch (InterruptedException e) {e.printStackTrace();}finally {reentrantLock.unlock();System.out.println("reentrantLock->unlock");}
复制代码
实现可定时的锁请求:tryLock
public static void main(String[] args) {ReentrantLock reentrantLock = new ReentrantLock();Thread thread1 = new Thread_tryLock(reentrantLock);thread1.setName("thread1");thread1.start();Thread thread2 = new Thread_tryLock(reentrantLock);thread2.setName("thread2");thread2.start();
}static class Thread_tryLock extends Thread {ReentrantLock reentrantLock;public Thread_tryLock(ReentrantLock reentrantLock) {this.reentrantLock = reentrantLock;}@Overridepublic void run() {try {System.out.println("try lock:" + Thread.currentThread().getName());boolean tryLock = reentrantLock.tryLock(3, TimeUnit.SECONDS);if (tryLock) {System.out.println("try lock success :" + Thread.currentThread().getName());System.out.println("睡眠一下:" + Thread.currentThread().getName());Thread.sleep(5000);System.out.println("醒了:" + Thread.currentThread().getName());} else {System.out.println("try lock 超时 :" + Thread.currentThread().getName());}} catch (InterruptedException e) {e.printStackTrace();} finally {System.out.println("unlock:" + Thread.currentThread().getName());reentrantLock.unlock();}}}复制代码
打印的日志:
try lock:thread1
try lock:thread2
try lock success :thread2
睡眠一下:thread2
try lock 超时 :thread1
unlock:thread1
Exception in thread "thread1" java.lang.IllegalMonitorStateExceptionat java.util.concurrent.locks.ReentrantLock$Sync.tryRelease(ReentrantLock.java:151)at java.util.concurrent.locks.AbstractQueuedSynchronizer.release(AbstractQueuedSynchronizer.java:1261)at java.util.concurrent.locks.ReentrantLock.unlock(ReentrantLock.java:457)at com.lanshifu.demo_module.test.lock.ReentranLockTest$Thread_tryLock.run(ReentranLockTest.java:60)
醒了:thread2
unlock:thread2复制代码
上面演示了trtLock
的使用,trtLock
设置获取锁的等待时间,超过3秒直接返回失败,可以从日志中看到结果。 有异常是因为thread1获取锁失败,不应该调用unlock。
3.2 Condition 条件
public static void main(String[] args) {Thread_Condition thread_condition = new Thread_Condition();thread_condition.setName("测试Condition的线程");thread_condition.start();try {Thread.sleep(2000);} catch (InterruptedException e) {e.printStackTrace();}thread_condition.singal();}static class Thread_Condition extends Thread {@Overridepublic void run() {await();}private ReentrantLock lock = new ReentrantLock();public Condition condition = lock.newCondition();public void await() {try {System.out.println("lock");lock.lock();System.out.println(Thread.currentThread().getName() + ":我在等待通知的到来...");condition.await();//await 和 signal 对应//condition.await(2, TimeUnit.SECONDS); //设置等待超时时间System.out.println(Thread.currentThread().getName() + ":等到通知了,我继续执行>>>");} catch (Exception e) {e.printStackTrace();} finally {System.out.println("unlock");lock.unlock();}}public void singal() {try {System.out.println("lock");lock.lock();System.out.println("我要通知在等待的线程,condition.signal()");condition.signal();//await 和 signal 对应Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();} finally {System.out.println("unlock");lock.unlock();}}}
复制代码
运行打印日志
lock
测试Condition的线程:我在等待通知的到来...
lock
我要通知在等待的线程,condition.signal()
unlock
测试Condition的线程:等到通知了,我继续执行>>>
unlock
复制代码
上面演示了Condition的 await 和 signal
使用,前提要先lock。
3.3 公平锁与非公平锁
ReentrantLock 构造函数传true表示公平锁。
公平锁表示线程获取锁的顺序是按照线程加锁的顺序来分配的,即先来先得的顺序。而非公平锁就是一种锁的抢占机制,是随机获得锁的,可能会导致某些线程一致拿不到锁,所以是不公平的。
3.4 ReentrantLock 注意点
- ReentrantLock使用lock和unlock来获得锁和释放锁
- unlock要放在finally中,这样正常运行或者异常都会释放锁
- 使用condition的await和signal方法之前,必须调用lock方法获得对象监视器
四、并发包
通过上面分析,并发严重的情况下,使用锁显然效率低下,因为同一时刻只能有一个线程可以获得锁,其它线程只能乖乖等待。
Java提供了并发包解决这个问题,接下来介绍并发包里一些常用的数据结构。
4.1 ConcurrentHashMap
我们都知道HashMap是线程不安全的数据结构,HashTable则在HashMap基础上,get方法和put方法加上Synchronized修饰变成线程安全,不过在高并发情况下效率底下,最终被ConcurrentHashMap
替代。
ConcurrentHashMap 采用分段锁,内部默认有16个桶,get和put操作,首先将key计算hashcode,然后跟16取余,落到16个桶中的一个,然后每个桶中都加了锁(ReentrantLock),桶中是HashMap结构(数组加链表,链表过长转红黑树)。
所以理论上最多支持16个线程同时访问。
4.2 LinkBlockingQueue
链表结构的阻塞队列,内部使用多个ReentrantLock
/** Lock held by take, poll, etc */private final ReentrantLock takeLock = new ReentrantLock();/** Wait queue for waiting takes */private final Condition notEmpty = takeLock.newCondition();/** Lock held by put, offer, etc */private final ReentrantLock putLock = new ReentrantLock();/** Wait queue for waiting puts */private final Condition notFull = putLock.newCondition();private void signalNotEmpty() {final ReentrantLock takeLock = this.takeLock;takeLock.lock();try {notEmpty.signal();} finally {takeLock.unlock();}}/*** Signals a waiting put. Called only from take/poll.*/private void signalNotFull() {final ReentrantLock putLock = this.putLock;putLock.lock();try {notFull.signal();} finally {putLock.unlock();}}复制代码
源码不贴太多,简单说一下LinkBlockingQueue
的逻辑:
- 从队列获取数据,如果队列中没有数据,会调用
notEmpty.await();
进入等待。- 在放数据进去队列的时候会调用
notEmpty.signal();
,通知消费者,1中的等待结束,唤醒继续执行。- 从队列里取到数据的时候会调用
notFull.signal();
,通知生产者继续生产。- 在put数据进入队列的时候,如果判断队列中的数据达到最大值,那么会调用
notFull.await();
,等待消费者消费掉,也就是等待3去取数据并且发出notFull.signal();
,这时候生产者才能继续生产。
LinkBlockingQueue
是典型的生产者消费者模式,源码细节就不多说。
4.3 原子操作类:AtomicInteger
内部采用CAS(compare and swap)保证原子性
举一个int自增的例子
AtomicInteger atomicInteger = new AtomicInteger(0);atomicInteger.incrementAndGet();//自增
复制代码
源码看一下
/*** Atomically increments by one the current value.** @return the updated value*/public final int incrementAndGet() {return U.getAndAddInt(this, VALUE, 1) + 1;}
复制代码
U 是 Unsafe,看下 Unsafe#getAndAddInt
public final int getAndAddInt(Object var1, long var2, int var4) {int var5;do {var5 = this.getIntVolatile(var1, var2);} while(!this.compareAndSwapInt(var1, var2, var5, var5 + var4));return var5;}
复制代码
通过compareAndSwapInt
保证原子性。
五、小结
面试中问到多线程并发问题,可以这么答:
- 当只有一个线程写,其它线程都是读的时候,可以用
volatile
修饰变量- 当多个线程写,那么一般情况下并发不严重的话可以用
Synchronized
,Synchronized并不是一开始就是重量级锁,在并发不严重的时候,比如只有一个线程访问的时候,是偏向锁;当多个线程访问,但不是同时访问,这时候锁升级为轻量级锁;当多个线程同时访问,这时候升级为重量级锁。所以在并发不是很严重的情况下,使用Synchronized是可以的。不过Synchronized有局限性,比如不能设置锁超时,不能通过代码释放锁。ReentranLock
可以通过代码释放锁,可以设置锁超时。- 高并发下,Synchronized、ReentranLock 效率低,因为同一时刻只有一个线程能进入同步代码块,如果同时有很多线程访问,那么其它线程就都在等待锁。这个时候可以使用并发包下的数据结构,例如
ConcurrentHashMap
,LinkBlockingQueue
,以及原子性的数据结构如:AtomicInteger
。
面试的时候按照上面总结的这个思路回答基本就ok了。既然说到并发包,那么除了ConcurrentHashMap
,其它一些常用的数据结构的原理也需要去了解下,例如HashMap、HashTable、TreeMap
原理,ArrayList、LinkedList
对比,这些都是老生常谈的,自己去看源码或者一些博客。
关于多线程并发就先总结到这里,如果是应付面试的话按照这篇文章的思路来准备应该是没太大问题的。
六、最后
为了方便有面试需要的朋友们,更加系统方便的学习刷题,拿到自己理想的offer。我将各大厂历年的常见、难点面试题做了系列整理,有需要的朋友,可以点赞+关注后,点击这里直接获取!
面试必问!多线程并发问题相关推荐
- 线程同步有几种方法_架构师面试必问的多线程状态切换及常用方法
架构师面试必问的多线程状态切换及常用方法 一.问题背景 Java架构师面试中,多线程状态切换及常用方法几乎是必问的,要掌握创建多线程的方式和方法. 二.创建多线程的几种方式 2.1方式一继承Threa ...
- 面试必问:多线程与线程池
前言 前几章都在讲一些锁的使用和原理,主要是为了保证多线程情况下变量的原子性,但这并不是说多线程不好,合理利用还是有好处的.至于什么好处,看下面内容就懂了,先打个比方吧(谁叫比方,上来挨打):假如你体 ...
- 面试必问的 CAS ,要多了解
转载自 面试必问的 CAS ,要多了解 前言 CAS(Compare and Swap),即比较并替换,实现并发算法时常用到的一种技术,Doug lea大神在java同步器中大量使用了CAS技术,鬼斧 ...
- Android面试必问框架原理
Android面试必问框架原理 volatile的实现原理 synchronized的实现原理 join方法实现原理 CAS无锁编程的原理 ReentrantLock的实现原理 AQS的大致实现思路 ...
- 看完946页“JAVA高级架构面试必问”,金九银十社招全拿下
前言 我本科毕业后在老东家干了两年多,老东家算是一家"小公司"(毕竟这年头没有 BAT 或 TMD 的 title 都不好意思报出身),毕业这两年多我也没有在大厂待过,因此找坑的时 ...
- 互联网公司面试必问的mysql题目(下)
这是mysql系列的下篇,上篇文章地址我附在文末. 什么是数据库索引?索引有哪几种类型?什么是最左前缀原则?索引算法有哪些?有什么区别? 索引是对数据库表中一列或多列的值进行排序的一种结构.一个非常恰 ...
- 互联网公司面试必问的mysql题目(上)
又到了招聘的旺季,被要求准备些社招.校招的题库. 介绍:MySQL是一个关系型数据库管理系统,目前属于 Oracle 旗下产品.虽然单机性能比不上oracle,但免费开源,单机成本低且借助于分布式集群 ...
- linux驱动工程面试必问知识点
linux内核原理面试必问(由易到难) 简单型 1:linux中内核空间及用户空间的区别?用户空间与内核通信方式有哪些? 2:linux中内存划分及如何使用?虚拟地址及物理地址的概念及彼此之间的转化, ...
- 面试必问的CAS,你懂了吗?
微信搜索[程序员囧辉],关注这个坚持分享技术干货的程序员. 我的最新文章:BAT 老兵的经验之谈,成长路上这个道理越早知道越好 目录 概述 案例 CAS是什么? 源码分析 intel手册对lock前缀 ...
最新文章
- shell基础二十篇 一些笔记
- 2013年完美世界校园招聘笔试题
- linux查找应用主机,Linux 主机和服务器基本性能检查命令和工具
- CF98E Help Shrek and Donkey(纳什博弈 + 大讨论)
- 华为云MySQL数据库外网使用
- 印度 语言简称_保存印度的语言和文化:图卢维基百科的诞生
- 2012021401
- vs cpp生成h文件_lib 和 dll 的区别、生成以及使用详解
- 发布文章自动上传图片并生成水印
- oracle to date mysql_mysql中怎么实现oracle中的to_char和to_date
- 语音识别模块解决方案
- 复制集结合分片架构搭建以及监控
- CentOS7和Ubuntu16设置静态ip的方法
- 论文研究结论怎么写?
- Android Studio打造一个小说阅读App
- 国产芯片传来好消息,纯国产CPU测试数据“曝光”
- 2019/2/3摄氏一华氏温度转换表
- Android Hawk数据库 github开源项目,字节跳动社招面试记录
- kvm 安装 windows 虚拟机
- 刚刚结束一家公司的战略规划项目的感想