synchronized面试题总结.

朱雀 2023-09-29 08:45 106阅读 0赞

###  **第一题：** ###

package com.bipowernode.javase.thread.syn;
    /*
        面试题： doOver方法执行的时候需要等待doSome方法的结束吗？
            // 不需要,因为doOver()方法没有synchronized关键字
     */
    
    // 测试程序
    public class Exam01 {
        public static void main(String[] args) {
            // 创建MyClass对象  // 一个对象 ”一把锁“,当线程跑代码的时候碰到synchronized关键字的时候需要进行抢锁
            MyClass myClass =new MyClass();
            // 创建两个线程
            MyThread t1 =new MyThread(myClass);
            MyThread t2 =new MyThread(myClass);
    
            // 设置name
            t1.setName("t1");
            t2.setName("t2");
    
            // 开启线程
            t1.start();
            // 这里睡眠5s保证t1线程先执行
            // t1线程执行结束需要10s
            
           
            try {
                Thread.sleep(1000*5);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            
            // // 5s 后t2线程执行doOver方法的代码 可以进行验证是否需要抢锁
            t2.start();
    
        }
    }
    
    
    
    
    class MyThread extends Thread{
        MyClass myClass;
        // 通过构造方法把MyClass对象传过来
    
        public MyThread(MyClass myClass) {
            this.myClass =myClass;
        }
    
        // 重写run()方法
        @Override
        public void run() {
            if (Thread.currentThread().getName().equals("t1")){
                myClass.doSome();   // t1线程执行doSome()方法的时候碰到了synchronized关键字,因为有一个共享对象所以有一把锁,此时t1进行抢锁执行同步代码块中的代码
            }
            if (Thread.currentThread().getName().equals("t2")){
                myClass.doOver();   // doOver()方法没有被synchronized关键字修饰,所以不用进行抢对象锁,直接跑程序
                //验证： (t1抢到锁后10s后释放锁,如果t2也需要抢锁的话 那么就不会执行在t1代码之前了,所以说明t2 doOver()方法、线程过来的时候不需要抢锁)
            }
        }
    }
    
    class MyClass{
        public synchronized void doSome(){
            System.out.println("doSome begin~");
            // 睡眠10s
            try {
                Thread.sleep(1000*10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("doSome over~");
        }
    
        public void doOver(){
            System.out.println("doOver begin~");
            System.out.println("doOver over~");
        }
    }

![watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAbHdqXzA3_size_20_color_FFFFFF_t_70_g_se_x_16][]

### **第二题： 当doSome()方法 和 doOver()方法 都被synchronized修饰时** ###

package com.bipowernode.javase.thread.syn;
    /*
        面试题： doOver方法执行的时候需要等待doSome方法的结束吗？
            // 需要,因为doSome()方法 和 doOver()方法都被synchronized关键字修饰,
            // 共享对象MyClass只有一个,所以锁也就只有一把, 当doSome()方法执行的时候碰到
            synchronized关键字开始抢对象的这把锁,执行doSome()方法中的同步代码块代码
            线程跑到doOver()方法的时候发现没有锁了,对象锁被doSome()方法占着呢 10s才释放锁,
            所以doOver()方法就等着这把锁,等到后再执行代码
     */
    
    // 测试程序
    public class Exam01 {
        public static void main(String[] args) {
            // 创建MyClass对象  // 一个对象 ”一把锁“,当线程跑代码的时候碰到synchronized关键字的时候需要进行抢锁
            MyClass myClass =new MyClass();
            // 创建两个线程
            MyThread t1 =new MyThread(myClass);
            MyThread t2 =new MyThread(myClass);
    
            // 设置name
            t1.setName("t1");
            t2.setName("t2");
    
            // 开启线程
            t1.start();
            // 这里睡眠5s保证t1线程先执行
            try {
                Thread.sleep(1000*5);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            t2.start();
    
        }
    }
    
    
    
    
    class MyThread extends Thread{
        MyClass myClass;
        // 通过构造方法把MyClass对象传过来
    
        public MyThread(MyClass myClass) {
            this.myClass =myClass;
        }
    
        // 重写run()方法
        @Override
        public void run() {
            if (Thread.currentThread().getName().equals("t1")){
                myClass.doSome();
            }
            if (Thread.currentThread().getName().equals("t2")){
                myClass.doOver();
    
            }
        }
    }
    
    class MyClass{
        public synchronized void doSome(){
            System.out.println("doSome begin~");
            // 睡眠10s
            try {
                Thread.sleep(1000*10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("doSome over~");
        }
        
        // 等doSome()占用的对象锁释放后,拿到锁再开始执行代码
        public synchronized void doOver(){
            System.out.println("doOver begin~");
            System.out.println("doOver over~");
        }
    }

![watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAbHdqXzA3_size_20_color_FFFFFF_t_70_g_se_x_16 1][]

###  **第三题：当有两个对象的时候,那么就有两把锁** ###

package com.bipowernode.javase.thread.syn;
    /*
        面试题： doOver方法执行的时候需要等待doSome方法的结束吗？
            // 不需要 两个对象有两把锁
     */
    
    // 测试程序
    public class Exam01 {
        public static void main(String[] args) {
            // 创建MyClass对象
            // 当创建两个MyClass对象的时候,那么就有两把锁
            MyClass myClass =new MyClass();
            MyClass myClass1 =new MyClass();
            // 创建两个线程
            MyThread t1 =new MyThread(myClass); // t1线程跑doSome()方法的时候遇到synchronized关键字可以拿myClass对象的锁
            MyThread t2 =new MyThread(myClass1); // t2线程跑doOver()方法的时候遇到synchronized关键字可以拿myClass1对象的锁
            // t2线程不需要等t1锁释放 因为t2有锁
    
            // 设置name
            t1.setName("t1");
            t2.setName("t2");
    
            // 开启线程
            t1.start();
            // 这里睡眠5s保证t1线程先执行
            try {
                Thread.sleep(1000*5);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            t2.start();
    
        }
    }
    
    
    class MyThread extends Thread{
        MyClass myClass;
        // 通过构造方法把MyClass对象传过来
    
        public MyThread(MyClass myClass) {
            this.myClass =myClass;
        }
    
        // 重写run()方法
        @Override
        public void run() {
            if (Thread.currentThread().getName().equals("t1")){
                myClass.doSome();
            }
            if (Thread.currentThread().getName().equals("t2")){
                myClass.doOver();
    
            }
        }
    }
    
    class MyClass{
        public synchronized void doSome(){
            System.out.println("doSome begin~");
            // 睡眠10s
            try {
                Thread.sleep(1000*10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("doSome over~");
        }
    
    
        // 等doSome()占用的对象锁释放后,拿到锁再开始执行代码
        public synchronized void doOver(){
            System.out.println("doOver begin~");
            System.out.println("doOver over~");
        }
    }

![watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAbHdqXzA3_size_20_color_FFFFFF_t_70_g_se_x_16 2][]

### 第四题：当synchronized出现在静态方法上是类锁,类锁无论创建几个对象都只有一把类锁 ###

package com.bipowernode.javase.thread.syn;
    /*
        面试题： doOver方法执行的时候需要等待doSome方法的结束吗？
            // 需要,因为synchronized出现在静态方法上的时候 无论有几个对象 都只有一把类锁
     */
    
    // 测试程序
    public class Exam01 {
        public static void main(String[] args) {
            // 创建MyClass对象
            // 当创建两个MyClass对象的时候,那么就有两把锁
            // 但是synchronized出现在静态方法上的时候 所以无论有几个对象 都只有一把类锁
            MyClass myClass =new MyClass();
            MyClass myClass1 =new MyClass();
            // 创建两个线程
            MyThread t1 =new MyThread(myClass);
            MyThread t2 =new MyThread(myClass1);
    
    
            // 设置name
            t1.setName("t1");
            t2.setName("t2");
    
            // 开启线程
            t1.start();
            // 这里睡眠5s保证t1线程先执行
            try {
                Thread.sleep(1000*5);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            t2.start();
    
        }
    }
    
    
    class MyThread extends Thread{
        MyClass myClass;
        // 通过构造方法把MyClass对象传过来
    
        public MyThread(MyClass myClass) {
            this.myClass =myClass;
        }
    
        // 重写run()方法
        @Override
        public void run() {
            if (Thread.currentThread().getName().equals("t1")){
                myClass.doSome();
            }
            if (Thread.currentThread().getName().equals("t2")){
                myClass.doOver();
    
            }
        }
    }
    
    class MyClass{
        // synchronized出现在静态方法上是类锁
        // 无论创建几个对象 都只有一把锁
        public synchronized static void doSome(){
            System.out.println("doSome begin~");
            // 睡眠10s
            try {
                Thread.sleep(1000*10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("doSome over~");
        }
    
    
        // 等doSome()占用的对象锁释放后,拿到锁再开始执行代码
        public synchronized static void doOver(){
            System.out.println("doOver begin~");
            System.out.println("doOver over~");
        }
    }

![watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAbHdqXzA3_size_20_color_FFFFFF_t_70_g_se_x_16 3][]

[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAbHdqXzA3_size_20_color_FFFFFF_t_70_g_se_x_16]: https://img-blog.csdnimg.cn/358d70056f854242a274c245fe8e1098.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBAbHdqXzA3,size_20,color_FFFFFF,t_70,g_se,x_16
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAbHdqXzA3_size_20_color_FFFFFF_t_70_g_se_x_16 1]: https://img-blog.csdnimg.cn/4e7054e01b66445a9673315037b9ebe8.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBAbHdqXzA3,size_20,color_FFFFFF,t_70,g_se,x_16
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAbHdqXzA3_size_20_color_FFFFFF_t_70_g_se_x_16 2]: https://img-blog.csdnimg.cn/7668aebf21b44241ae48be43f2aea2d6.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBAbHdqXzA3,size_20,color_FFFFFF,t_70,g_se,x_16
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAbHdqXzA3_size_20_color_FFFFFF_t_70_g_se_x_16 3]: https://img-blog.csdnimg.cn/74838f7fdcd544a88837679c80c8fdfd.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBAbHdqXzA3,size_20,color_FFFFFF,t_70,g_se,x_16

发表评论取消回复

表情：

评论列表（有 0 条评论，106人围观）

还没有评论，来说两句吧...

相关阅读

相关面试题总结

edis sds实现 b+树非聚集和聚集b+树区别 mysql事物隔离级别，底层实现 mysql，innodb synchronized ,以及升级过程 A...

超、凢脫俗/ 2024年04月20日 00:22/ 0 赞/ 101 阅读

相关 synchronized面试题总结.

第一题： package com.bipowernode.javase.thread.syn; / 面试题： doOver方法执行的时候

朱雀/ 2023年09月29日 08:45/ 0 赞/ 107 阅读

相关并发编程|Synchronized相关面试题

并发编程前言并发编程在面试过程肯定会问到的，但是这块准备起来没有之前知识点繁琐并发编程考察深度知识比较多，那这小节我们整理下关于Synchroniz

ゝ一纸荒年。/ 2023年06月30日 08:56/ 0 赞/ 17 阅读

相关面试题——vue面试题总结

vue面试题总结 1.vue的特点是什么 1.国人开发的轻量级框架 2.双向数据绑定，在数据操作方面更为简单 3.视图，数据，结构分析，不需要进行逻辑代码的修改

た入场券/ 2023年01月18日 11:29/ 0 赞/ 444 阅读

相关 2021面试题——vue面试题总结

vue面试题总结 1.vue的特点是什么 1.国人开发的轻量级框架 2.双向数据绑定，在数据操作方面更为简单 3.视图，数据，结构分析，不需要进行逻辑代码的修改

我不是女神ヾ/ 2022年11月13日 00:51/ 0 赞/ 439 阅读

相关面试题总结

详情参考： [https://zhuanlan.zhihu.com/p/379414908?utm\_source=wechat\_timeline&utm\_medi

本是古典何须时尚/ 2022年10月08日 15:22/ 0 赞/ 358 阅读

相关面试题总结

一、谈谈bfc？一、什么是BFC BFC(block formatting context）：简单来说，BFC 就是一种属性，这种属性会影响着元素的定位以及与其兄弟元

清疚/ 2022年05月27日 11:46/ 0 赞/ 316 阅读

相关总结面试题

1.HTML与XHTML——二者有什么区别最主要的不同：XHTML 元素必须被正确地嵌套。XHTML 元素必须被关闭。标签名必须用小写字母。XHTML 文档必须拥有根元

今天药忘吃喽~/ 2022年05月14日 16:14/ 0 赞/ 882 阅读

相关面试题总结

[面试题总结][Link 1] 1.\include、@class 、\import区别使用\include引入同一个类2次的时候编译器会报错：因为\include相

太过爱你忘了你带给我的痛/ 2022年03月22日 11:09/ 0 赞/ 333 阅读

相关面试题总结

上周抽空去两家规模不错的公司刷了一下笔试题和面试题，好东西当然是要拿出来分享的，小伙伴们也可以借此复习一下iOS基础知识，要是打算跳槽的，那就更有必要看一下了。 1.

Bertha 。/ 2022年01月19日 01:19/ 0 赞/ 357 阅读