面试官：说说多线程并发问题，安卓面试题库app-CSDN博客

本文链接：https://blog.csdn.net/rdytfuygiohi/article/details/137899218

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

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

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

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

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

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

正文

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

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对比，这些都是老生常谈的，自己去看源码或者一些博客。