最全阿里面试官：说说多线程并发问题，2024年最新腾讯三面结束多久hr面

最新推荐文章于 2024-06-17 02:07:31 发布

2401_84520150

最新推荐文章于 2024-06-17 02:07:31 发布

阅读量688

点赞数 27

分类专栏：程序员文章标签： android 面试学习

本文链接：https://blog.csdn.net/2401_84520150/article/details/138687808

版权

程序员专栏收录该内容

184 篇文章 0 订阅

订阅专栏

结语

由于篇幅限制，文档的详解资料太全面，细节内容太多，所以只把部分知识点截图出来粗略的介绍，每个小节点里面都有更细化的内容！以下是目录截图：

由于整个文档比较全面，内容比较多，篇幅不允许，下面以截图方式展示。

再附一部分Android架构面试视频讲解：

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

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

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

Java 内存模型规定了所有的变量都存储在主内存中，每条线程有自己的工作内存。

线程的工作内存中保存了该线程中用到的变量的主内存副本拷贝，线程对变量的所有操作都必须在工作内存中进行，而不能直接读写主内存。

线程访问一个变量，首先将变量从主内存拷贝到工作内存，对变量的写操作，不会马上同步到主内存。

不同的线程之间也无法直接访问对方工作内存中的变量，线程间变量的传递均需要自己的工作内存和主存之间进行数据同步进行。

二、Java 内存模型（JMM）

Java 内存模型(JMM) 作用于工作内存（本地内存）和主存之间数据同步过程，它规定了如何做数据同步以及什么时候做数据同步，如下图。

三、并发三要素

原子性：在一个操作中，CPU 不可以在中途暂停然后再调度，即不被中断操作，要么执行完成，要么就不执行。

可见性：多个线程访问同一个变量时，一个线程修改了这个变量的值，其他线程能够立即看得到修改的值。

有序性：程序执行的顺序按照代码的先后顺序执行。

四、怎么做，才能解决并发问题？（重点）

下面结合不同场景分析解决并发问题的处理方式。

一、volatile

1.1 volatile 特性

保证可见性，不保证原子性

当写一个volatile变量时，JVM会把本地内存的变量强制刷新到主内存中

这个写操作导致其他线程中的缓存无效，其他线程读，会从主内存读。volatile的写操作对其它线程实时可见。

禁止指令重排序 指令重排序是指编译器和处理器为了优化程序性能对指令进行排序的一种手段，需要遵守一定规则：

不会对存在依赖关系的指令重排序，例如 a = 1;b = a; a 和b存在依赖关系，不会被重排序

不能影响单线程下的执行结果。比如：a=1;b=2;c=a+b这三个操作,前两个操作可以重排序，但是c=a+b不会被重排序，因为要保证结果是3

1.2 使用场景

对于一个变量，只有一个线程执行写操作，其它线程都是读操作，这时候可以用 volatile 修饰这个变量。

1.3 单例双重锁为什么要用到volatile？


public class TestInstance {



private static volatile TestInstance mInstance;



public static TestInstance getInstance(){       //1

    if (mInstance == null){                     //2

        synchronized (TestInstance.class){      //3

            if (mInstance == null){             //4

                mInstance = new TestInstance(); //5

            }

        }

    }

    return mInstance;

}

复制代码

}

假如没有用volatile，并发情况下会出现问题，线程A执行到注释5 new TestInstance() 的时候，分为如下几个几步操作：

分配内存
初始化对象
mInstance 指向内存

这时候如果发生指令重排，执行顺序是132，执行到第3的时候，线程B刚好进来了，并且执行到注释2，这时候判断mInstance 不为空，直接使用一个未初始化的对象。所以使用volatile关键字来禁止指令重排序。

1.4 volatile 原理

在JVM底层volatile是采用内存屏障来实现的，内存屏障会提供3个功能：

它确保指令重排序时不会把其后面的指令排到内存屏障之前的位置，也不会把前面的指令排到内存屏障的后面；即在执行到内存屏障这句指令时，在它前面的操作已经全部完成；

它会强制将缓存的修改操作立即写到主内存

写操作会导致其它CPU中的缓存行失效，写之后，其它线程的读操作会从主内存读。

1.5 volatile 的局限性

volatile 只能保证可见性，不能保证原子性写操作对其它线程可见，但是不能解决多个线程同时写的问题。

二、Synchronized

2.1 Synchronized 使用场景

多个线程同时写一个变量。

例如售票，余票是100张，窗口A和窗口B同时各卖出一张票，假如余票变量用 volatile 修饰，是有问题的。

A窗口获取余票是100，B窗口获取余票也是100，A卖出一张变成99，刷新回主内存，同时B卖出一张变成99，也刷新回主内存，会导致最终主内存余票是99而不是98。

前面说到 volatile 的局限性，就是多个线程同时写的情况，这种情况一般可以使用Synchronized。

Synchronized 可以保证同一时刻，只有一个线程可执行某个方法或某个代码块。

2.2 Synchronized 原理


public class SynchronizedTest {



public static void main(String[] args) {

    synchronized (SynchronizedTest.class) {

        System.out.println("123");

    }

    method();

}



private static void method() {

}

}

复制代码

将这段代码先用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 缺点

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

三、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 对应



#### 最后笔者收集整理了一份Flutter高级入门进阶资料PDF

以下是资料目录和内容部分截图

> ![](https://img-blog.csdnimg.cn/img_convert/08c46e07a0beb5ee9079c304d2768681.webp?x-oss-process=image/format,png)
> ![](https://img-blog.csdnimg.cn/img_convert/a8b4285e957768ebd03b91d5409ab599.webp?x-oss-process=image/format,png)
> 里面包括详细的知识点讲解分析，带你一个星期入门Flutter。还有130个进阶学习项目实战视频教程，让你秒变大前端。



> ![](https://img-blog.csdnimg.cn/img_convert/06ada696420ea1102b03dc1db0e90611.webp?x-oss-process=image/format,png)



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

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

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

;

                System.out.println(Thread.currentThread().getName() + ":我在等待通知的到来...");

                condition.await();//await 和 signal 对应



#### 最后笔者收集整理了一份Flutter高级入门进阶资料PDF

以下是资料目录和内容部分截图

> [外链图片转存中...(img-M5rGjBqq-1715359254336)]
> [外链图片转存中...(img-ukcsCz9f-1715359254337)]
> 里面包括详细的知识点讲解分析，带你一个星期入门Flutter。还有130个进阶学习项目实战视频教程，让你秒变大前端。



> [外链图片转存中...(img-tQj1GWk5-1715359254337)]



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

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

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

2401_84520150

关注

27
点赞
踩
22

收藏

觉得还不错? 一键收藏
0
评论
最全阿里面试官：说说多线程并发问题，2024年最新腾讯三面结束多久hr面

由于篇幅限制，文档的详解资料太全面，细节内容太多，所以只把部分知识点截图出来粗略的介绍，每个小节点里面都有更细化的内容！由于整个文档比较全面，内容比较多，篇幅不允许，下面以截图方式展示。网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。需要这份系统化学习资料的朋友，可以戳这里获取一个人可以走的很快，但一群人才能走的更远！
复制链接

扫一扫