2024年安卓最新阿里面试官：说说多线程并发问题(2)，安卓面试经典100题答案

本文链接：https://blog.csdn.net/2401_84520026/article/details/138955825

最后

感谢您的阅读，在文末给大家准备一个福利。本人从事Android开发已经有十余年，算是一名资深的移动开发架构师了吧。根据我的观察发现，对于很多初中级Android工程师而言，想要提升技能，往往是自己摸索成长，不成体系的学习效果低效漫长且无助。

所以在此将我十年载，从萌新小白一步步成长为Android移动开发架构师的学习笔记，从Android四大组件到手写实现一个架构设计，我都有一一的对应笔记为你讲解。

当然我也为你们整理好了百度、阿里、腾讯、字节跳动等等互联网超级大厂的历年面试真题集锦。这也是我这些年来养成的习惯，一定要学会把好的东西，归纳整理，然后系统的消化吸收，这样才能极大的提高学习效率和成长进阶。碎片、零散化的东西，我觉得最没有价值的。就好比你给我一张扑克牌，我只会觉得它是一张废纸，但如果你给我一副扑克牌，它便有了它的价值。这和我们收集资料就要收集那些系统化的，是一个道理。

最后，赠与大家一句诗，共勉！

不驰于空想，不骛于虚声。不忘初心，方得始终。

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化学习资料的朋友，可以戳这里获取

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

}

复制代码




将这段代码先用`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=1

 0: ldc           #2                  // class com/lanshifu/opengldemo/test/SynchronizedTest

 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 缺点



1.  不能设置锁超时时间

2.  不能通过代码释放锁

3.  容易造成死锁



### []( )三、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 注意点



1.  ReentrantLock使用lock和unlock来获得锁和释放锁

2.  unlock要放在finally中，这样正常运行或者异常都会释放锁

3.  使用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();

    }

}

复制代码






## 总结

算法知识点繁多，企业考察的题目千变万化，面对越来越近的“金九银十”，我给大家准备好了一套比较完善的学习方法，希望能帮助大家在有限的时间里尽可能系统快速的恶补算法，通过高效的学习来提高大家面试中算法模块的通过率。

这一套学习资料既有文字档也有视频，里面不仅仅有关键知识点的整理，还有案例的算法相关部分的讲解，可以帮助大家更好更全面的进行学习，二者搭配起来学习效果会更好。


**部分资料展示：**

![](https://img-blog.csdnimg.cn/img_convert/f43ab47e705c0acd6c522244102d6ca8.webp?x-oss-process=image/format,png)
![](https://img-blog.csdnimg.cn/img_convert/4c0a1994b5cba2b6c2ca5bb8781309ea.webp?x-oss-process=image/format,png)
![](https://img-blog.csdnimg.cn/img_convert/31e7656cef0abbc0dc607415cb5106f0.webp?x-oss-process=image/format,png)
![](https://img-blog.csdnimg.cn/img_convert/5e41dbd5fdea20d82600d61440e209c3.webp?x-oss-process=image/format,png)

**有了这套学习资料，坚持刷题一周，你就会发现自己的算法知识体系有明显的完善，离大厂Offer的距离更加近。**




**网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。**

**[需要这份系统化学习资料的朋友，可以戳这里获取](https://bbs.csdn.net/topics/618156601)**

**一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！**

化，面对越来越近的“金九银十”，我给大家准备好了一套比较完善的学习方法，希望能帮助大家在有限的时间里尽可能系统快速的恶补算法，通过高效的学习来提高大家面试中算法模块的通过率。

这一套学习资料既有文字档也有视频，里面不仅仅有关键知识点的整理，还有案例的算法相关部分的讲解，可以帮助大家更好更全面的进行学习，二者搭配起来学习效果会更好。


**部分资料展示：**

[外链图片转存中...(img-rg61Opy6-1715832820829)]
[外链图片转存中...(img-QKOwNrgT-1715832820829)]
[外链图片转存中...(img-beFKzPpj-1715832820829)]
[外链图片转存中...(img-7gfFVS1l-1715832820829)]

**有了这套学习资料，坚持刷题一周，你就会发现自己的算法知识体系有明显的完善，离大厂Offer的距离更加近。**




**网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。**

**[需要这份系统化学习资料的朋友，可以戳这里获取](https://bbs.csdn.net/topics/618156601)**

**一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！**