阿里面试官：说说多线程并发问题，2024年最新Android性能优化常见问题

最新推荐文章于 2024-05-09 14:29:33 发布

2401_84102956

最新推荐文章于 2024-05-09 14:29:33 发布

阅读量751

点赞数 20

分类专栏： 2024年程序员学习文章标签： android 性能优化 java

本文链接：https://blog.csdn.net/2401_84102956/article/details/137619094

版权

2024年程序员学习专栏收录该内容

180 篇文章 0 订阅

订阅专栏

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();

自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数Android工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则几千的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

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

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

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

如果你觉得这些内容对你有帮助，可以添加V获取：vip204888 （备注Android）

最后

其实Android开发的知识点就那么多，面试问来问去还是那么点东西。所以面试没有其他的诀窍，只看你对这些知识点准备的充分程度。so，出去面试时先看看自己复习到了哪个阶段就好。

上面分享的百度、腾讯、网易、字节跳动、阿里等公司2021年的高频面试题，博主还把这些技术点整理成了视频和PDF（实际上比预期多花了不少精力），包含知识脉络 + 诸多细节，由于篇幅有限，上面只是以图片的形式给大家展示一部分。

【Android思维脑图（技能树）】

知识不体系？这里还有整理出来的Android进阶学习的思维脑图，给大家参考一个方向。

【Android高级架构视频学习资源】

**Android部分精讲视频领取学习后更加是如虎添翼！**进军BATJ大厂等（备战）！现在都说互联网寒冬，其实无非就是你上错了车，且穿的少（技能），要是你上对车，自身技术能力够强，公司换掉的代价大，怎么可能会被裁掉，都是淘汰末端的业务Curd而已！现如今市场上初级程序员泛滥，这套教程针对Android开发工程师1-6年的人员、正处于瓶颈期，想要年后突破自己涨薪的，进阶Android中高级、架构师对你更是如鱼得水，赶快领取吧！

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

脉络 + 诸多细节**，由于篇幅有限，上面只是以图片的形式给大家展示一部分。

【Android思维脑图（技能树）】

知识不体系？这里还有整理出来的Android进阶学习的思维脑图，给大家参考一个方向。

[外链图片转存中…(img-9XunaOrO-1712774374954)]

【Android高级架构视频学习资源】

一个人可以走的很快，但一群人才能走的更远。不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎扫码加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！
[外链图片转存中…(img-etSPMwPA-1712774374954)]

2401_84102956

关注

20
点赞
踩
8

收藏

觉得还不错? 一键收藏
0
评论
阿里面试官：说说多线程并发问题，2024年最新Android性能优化常见问题

其实Android开发的知识点就那么多，面试问来问去还是那么点东西。所以面试没有其他的诀窍，只看你对这些知识点准备的充分程度。so，出去面试时先看看自己复习到了哪个阶段就好。上面分享的百度、腾讯、网易、字节跳动、阿里等公司2021年的高频面试题，博主还把这些技术点整理成了视频和PDF（实际上比预期多花了不少精力），包含知识脉络 + 诸多细节，由于篇幅有限，上面只是以图片的形式给大家展示一部分。【Android思维脑图（技能树）】知识不体系？
复制链接

扫一扫