synchronized面试题总结.

朱雀 2023-09-29 08:45 100阅读 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 条评论，100人围观）

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

相关阅读

相关面试题总结

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

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

相关 synchronized面试题总结.

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

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

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

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

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

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

css面试题总结 1.介绍一下标准的css的盒子模型，与低版本IE的盒子模型有什么不同？标准盒子模型：宽度=内容的宽度（content）+border+paddi

我不是女神ヾ/ 2023年01月15日 11:27/ 0 赞/ 318 阅读

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

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

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

相关面试题总结

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

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

相关面试题总结

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

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

相关总结面试题

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

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

相关面试题总结

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

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

相关面试题总结

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

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