2024年安卓最新阿里面试官：说说多线程并发问题(1)，2024华为Android面试真题解

2401_84564025

于 2024-05-08 03:20:05 发布

阅读量282

点赞数 5

分类专栏：程序员文章标签： android 华为面试

本文链接：https://blog.csdn.net/2401_84564025/article/details/138553193

版权

程序员专栏收录该内容

183 篇文章 1 订阅

订阅专栏

最后

分享一份工作1到5年以上的Android程序员架构进阶学习路线体系，希望能对那些还在从事Android开发却还不知道如何去提升自己的，还处于迷茫的朋友！

阿里P7级Android架构师技术脑图；查漏补缺，体系化深入学习提升
**全套体系化高级架构视频；**七大主流技术模块，视频+源码+笔记

有任何问题，欢迎广大网友一起来交流

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

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

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


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

不能设置锁超时时间
不能通过代码释放锁
容易造成死锁

三、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();，这时候生产者才能继续生产。

最后

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

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

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

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

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

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

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

工程师而言，想要提升技能，往往是自己摸索成长，不成体系的学习效果低效漫长且无助。

[外链图片转存中…(img-fHjg2mvx-1715109594373)]

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

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

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

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

2401_84564025

关注

5
点赞
踩
3

收藏

觉得还不错? 一键收藏
0
评论
2024年安卓最新阿里面试官：说说多线程并发问题(1)，2024华为Android面试真题解

分享一份工作1到5年以上的Android程序员架构进阶学习路线体系，希望能对那些还在从事Android开发却还不知道如何去提升自己的，还处于迷茫的朋友！阿里P7级Android架构师技术脑图；查漏补缺，体系化深入学习提升**全套体系化高级架构视频；**七大主流技术模块，视频+源码+笔记有任何问题，欢迎广大网友一起来交流网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。需要这份系统化学习资料的朋友，可以戳这里获取。
复制链接

扫一扫