面试必问！多线程并发问题，2024年最新安卓面试项目包装-CSDN博客

本文链接：https://blog.csdn.net/2301_78399550/article/details/137899564

先自我介绍一下，小编浙江大学毕业，去过华为、字节跳动等大厂，目前阿里P7

深知大多数程序员，想要提升技能，往往是自己摸索成长，但自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年最新Android移动开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友。

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上Android开发知识点，真正体系化！

由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新

如果你需要这些资料，可以添加V获取：vip204888 （备注Android）

正文

2: dup

3: astore_1

4: monitorenter

5: getstatic #3 // Field java/lang/System.out:Ljava/io/PrintStream;

8: ldc #4 // String 123

10: invokevirtual #5 // Method java/io/PrintStream.println:(Ljava/lang/String;)V

13: aload_1

14: monitorexit

15: goto 23

18: astore_2

19: aload_1

20: monitorexit

21: aload_2

22: athrow

23: invokestatic #6 // Method method:()V

26: 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;

}

@Override

public 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.IllegalMonitorStateException

at 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 {

@Override

public 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 是典型的生产者消费者模式，源码细节就不多说。

文末

好了，今天的分享就到这里，如果你对在面试中遇到的问题，或者刚毕业及工作几年迷茫不知道该如何准备面试并突破现状提升自己，对于自己的未来还不够了解不知道给如何规划，可以来看看同行们都是如何突破现状，怎么学习的，来吸收他们的面试以及工作经验完善自己的之后的面试计划及职业规划。

这里放上一部分我工作以来以及参与过的大大小小的面试收集总结出来的相关的几十套腾讯、头条、阿里、美团等公司21年的面试专题，其中把技术点整理成了视频和PDF（实际上比预期多花了不少精力），包含知识脉络 + 诸多细节，由于篇幅有限，这里以图片的形式给大家展示一部分免费分享给大家，主要还是希望大家在如今大环境不好的情况下面试能够顺利一点，希望可以帮助到大家~

还有 高级架构技术进阶脑图、Android开发面试专题资料，高级进阶架构资料帮助大家学习提升进阶，也节省大家在网上搜索资料的时间来学习，也可以分享给身边好友一起学习。

【Android核心高级技术PDF文档，BAT大厂面试真题解析】