精华内容
下载资源
问答
  • 下列关于for循环和while循环的说法中那个是正确的?() A、while循环能实现的操作,for循环也都能实现 B、while循环判断条件一般是程序结果,for循环判断条件一般是非程序结果 C、两种循环任何时候都可替换 D、两种...

    前言:

    最近在看面试题的时候,做到了一些关于它们的一些选择题,我也有点疑惑,所以求助于百度,然后我也没有找到确切的答案,下面给出2个选择题谈谈我个人的看法。

    选择题1:

    下列关于for循环和while循环的说法中那个是正确的?()

    A、while循环能实现的操作,for循环也都能实现

    B、while循环判断条件一般是程序结果,for循环判断条件一般是非程序结果

    C、两种循环任何时候都可替换

    D、两种循环结构中都必须有循环体,循环体不能为空

    答案:A、C

    解释:

    A:我没有找到可以反对的例子,所以A项正确

    B:如果while循环判断条件一般是程序结果,那在循环体里面会执行什么判断呢,暂时没有遇到,毕竟用while循环的情况还是比较少的,感觉B项错误

    C:这个暂时没有找到可以反对的例子,所以C项正确

    D:首先两种循环结构中都必须有循环体,如下所示:

    证明for循环必须有循环体:
    在这里插入图片描述
    证明while循环必须有循环体:
    在这里插入图片描述
    其次for循环的循环体可以为空,而while循环的循环体不一定能为空,如下所示:

    证明for循环循环体可以为空:
    在这里插入图片描述
    证明while循环循环体不一定能为空:

    在这里插入图片描述
    在这里插入图片描述

    选择题2:

    说法中正确的是()

    A、for循环完全可以用while循环替代。

    B、while循环完全可以用do{}while循环替代。

    C、while循环完全可以用for循环替代。

    D、do{}while循环完全可以用while循环替代。

    E、do{}while循环和while循环均完全可以用for循环替代。

    答案:A、C、D、E

    解释:

    A:没有找到可以反对的例子,所以A正确

    B:有些while循环不能用do while循环代替,如下所示:

    int a = 1;
    while (a != 1) {
        System.out.println(a);
    }
    

    上述的while循环根本不会执行,由于do while循环是循环一次在判断,因此无法替换,所以B错误

    C:没有找到可以反对的例子,所以C正确

    D:do while循环不过是先执行在判断,while循环完全可以做到,来一个do while循环的特例吧,如下所示:

    int a = 1;
    do{
        System.out.println(1);
    } while (a!=1);
    

    上述例子中只会执行一次循环体,接下来看我用while循环怎么替代它,如下所示:

    int a = 1;
    while(a!=2){
        System.out.println(1);
        a++;
    }
    

    虽然样子不一样,但是实现的功能是一样的,都是一次循环,所以D正确

    E:既然while循环都能替代do while循环,那for循环和while循环可以相互转换,所以for循环也能替代do while循环,所以E正确

    展开全文
  • 人 数 人 性别 看 书 踢球 看电视 画画 跳绳 玩电子游戏 男生 5 3 2 1 1 12 女生 12 0 4 1 3 2 活动 男女生最喜欢活动 合计 24 22 总计 观察统计表中三届奥运会情况判断下面说法是否正确 1中国获得金牌一届比一...
  • 根据如下贝叶斯网络,判断下面说法是否正确4.高斯混合模型表示以及使用EM算法求解流程5.叙述Q-learning算法流程计算机学院试题 1.叙述批处理K-means算法流程 2.请写出二分类支持向量机在线性不可分情况下...

    1.叙述批处理的K-means算法流程

    2.请写出二分类的支持向量机在线性不可分情况下的目标函数以及优化函数

    3.根据如下贝叶斯网络,判断下面说法是否正确

    在这里插入图片描述听大佬说FTTFF

    4.高斯混合模型的表示以及使用EM算法求解的流程

    5.叙述Q-learning的算法流程

    计算机学院试题

    在这里插入图片描述

    相比计院,感觉我们考得温和很多。万万没想到的是都考了高斯混合模型,上课都没讲,这就很离谱!!上次面试也是问啥是高斯混合模型,两次都不会…

    展开全文
  • 题一: 如果一个二叉树前序遍历结果是abcdefg,下面哪一个是可能中序遍历结果?...判断下列说法是否正确:已知完全二叉树第七层中有10个叶子结点,则整个二叉树中最多有73个结点。() 正确答案: B 你答案:

    题一:
    如果一个二叉树的前序遍历结果是abcdefg,下面哪一个是可能的中序遍历结果?
    正确答案: A B C E 你的答案: A B C D E (错误)
    abcdefg
    gfedcba
    bcdefga
    bceadfg
    bcdaefg
    解答:
    有两种方法:1,综合起来看是否能构成一棵二叉树;2、设abcdefg为进栈的顺序,符合出栈顺序的则可能是中序遍历的结果
    题二:
    判断下列说法是否正确:已知完全二叉树的第七层中有10个叶子结点,则整个二叉树中最多有73个结点。()
    正确答案: B 你的答案: A (错误)
    正确
    错误
    解答:
    根据完全二叉树的性质,第七层最多能容2^6=64个结点。
    根据题意,第7层有10个叶子结点。
    ①结点最少的情况:第七层仅有10个结点。前六层共有2^6-1=63个结点。加上第7层的10个叶子结点,就是73个结点。即题中描述的二叉树最少有73个结点。
    ②结点最多的情况:第七层有64个结点,其中有54个结点有孩子结点,剩下的10个结点为叶子结点。前七层总计结点数为2^7-1=127个结点。第八层有54*2=108个结点。两者相加为235个结点。即题中描述的二叉树最多有235个结点。

    题三:
    某二叉树的前序序列和后序序列正好相反,则该二叉树一定是()的二叉树
    正确答案: B 你的答案: A (错误)
    空或只有一个结点
    高度等于其结点数
    任一结点无左孩子
    任一结点无右孩子
    解答:
    一棵具有N个结点的二叉树的前序序列和后序序列正好相反 ,则该二叉树一定满足该二叉树只有左子树或只有右子树,即该二叉树一定是一条链(二叉树的高度为N,高度等于结点数)

    题四:
    设森林F中有三棵树,第一,第二,第三棵树的结点个数分别为M1,M2和M3。与森林F对应的二叉树根结点的右子树上的结点个数是( )。
    正确答案: D 你的答案: A (错误)
    M1
    M1+M2
    M3
    M2+M3

    解答:
    在这里插入图片描述

    展开全文
  • 1/8第三单元达标测试卷一、下面是某服装店某一天销售数量统计表,根据统计表判断下列说法是否正确。(每题2分,共12分)某服装店某一天销售数量统计表1.卖出服装黑色比红色多。( )2.卖出服装
  • 第2章-习题解答.doc

    2020-05-02 01:11:08
    第二章 质点动力学 2.1 思考下面的几个问题 1物体...2.2 判断下列说法是否正确并说明理由 1内力不能改变系统的总动量 2内力不能改变习题的总动能 3内力不能改变系统的机械能 2.3 有人说牛顿第一定律只是牛顿第二定律在
  • 今天本小白将亲自去验证下网上各种大神的说法是否正确。百度前面的几篇文章我都看了下,感觉写的都差不多偏向于概念性的分析。没看到有人真的去验证种种说法是否真的正确。 对象组成 在分析synchronize时肯定避不开...

    网上synchronize分析太多了,但是真正去证明的很少。今天本小白将亲自去验证下网上各种大神的说法是否正确。百度前面的几篇文章我都看了下,感觉写的都差不多偏向于概念性的分析。没看到有人真的去验证种种说法是否真的正确。

    Java中提供了两种实现同步的基础语义:synchronized方法和synchronized块。被编译成class文件的时候,synchronized关键字和synchronized方法的字节码略有不同,我们可以用javap -v 命令查class
    文件对应的JVM字节码信息:

    public class SynchronizedDemo2 {
        public  void sync1(){
            synchronized (this){
                System.out.println("synchronized1");
            }
        }
        public static synchronized void sync2(){
            System.out.println("synchronized2");
        }
    }
    

    字节码

     public void sync1();
        descriptor: ()V
        flags: ACC_PUBLIC
        Code:
          stack=2, locals=3, args_size=1
             0: aload_0
             1: dup
             2: astore_1
             3: monitorenter
             4: getstatic     #2                  // Field java/lang/System.out:Ljava/io/PrintStream;
             7: ldc           #3                  // String synchronized1
             9: invokevirtual #4                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V
            12: aload_1
            13: monitorexit
            14: goto          22
            17: astore_2
            18: aload_1
            19: monitorexit
            20: aload_2
            21: athrow
            22: return
          Exception table:
             from    to  target type
                 4    14    17   any
                17    20    17   any
          LineNumberTable:
            line 6: 0
            line 7: 4
            line 8: 12
            line 9: 22
          LocalVariableTable:
            Start  Length  Slot  Name   Signature
                0      23     0  this   Lcom/chihai/graduation_project/synchronize/SynchronizedDemo2;
          StackMapTable: number_of_entries = 2
            frame_type = 255 /* full_frame */
              offset_delta = 17
              locals = [ class com/chihai/graduation_project/synchronize/SynchronizedDemo2, class java/lang/Object ]
              stack = [ class java/lang/Throwable ]
            frame_type = 250 /* chop */
              offset_delta = 4
    
      public static synchronized void sync2();
        descriptor: ()V
        flags: ACC_PUBLIC, ACC_STATIC, ACC_SYNCHRONIZED
        Code:
          stack=2, locals=0, args_size=0
             0: getstatic     #2                  // Field java/lang/System.out:Ljava/io/PrintStream;
             3: ldc           #5                  // String synchronized2
             5: invokevirtual #4                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V
             8: return
          LineNumberTable:
            line 11: 0
            line 12: 8
    }
    
    

    从上面可以看到,对于synchronized关键字而言,javac在编译时,会生成对应的monitorenter和monitorexit指令分别对应synchronized同步块的进入和退出,有两个monitorexit指令的原因是:为了保证抛异常的情况下也能释放锁,所以javac为同步代码块添加了一个隐式的try-finally,在finally中会调用monitorexit命令释放锁。而对于synchronized方法而言,javac为其生成了一个ACC_SYNCHR
    ONIZED关键字,在JVM进行方法调用时,发现调用的方法被ACC_SYNCHRONIZED修饰,则会先尝试获得锁。在JVM底层,对于这两种synchronized语义的实现大致相同。传统的锁(也就是下文要说的重量级锁)依赖于系统的同步函数在linux上使用mutex互斥锁,最底层实现依赖于futex。

    对象组成

    在分析synchronize时肯定避不开对象头这个最关键的点,这里我们使用openjdk提供jol-core包就能帮助我们打印出对象信息方便我们下面的判断。我这里随便创建了两个类用于演示。

    public class ChiHai {
        int age;
    }
    
    public class SynchronizeDemo {
        static ChiHai chiHai = new ChiHai();
        public static void main(String[] args) {
    
        // chiHai.hashCode();
    
            System.out.println(ClassLayout.parseInstance(chiHai).toPrintable()); //解析并打印当前对象
    
            synchronized (chiHai){ // 测试synchronized锁的是对象而不是代码
                System.out.println("locking...");
            }
    
        }
    }
    

    控制台打印信息:

    com.chihai.graduation_project.synchronize.ChiHai object internals:
     OFFSET  SIZE   TYPE DESCRIPTION                               VALUE
          0     4        (object header)                           01 00 00 00 (00000001 00000000 00000000 00000000) (1)
          4     4        (object header)                           00 00 00 00 (00000000 00000000 00000000 00000000) (0)
          8     4        (object header)                           18 0a 23 17 (00011000 00001010 00100011 00010111) (388172312)
         12     4    int ChiHai.age                                0
    Instance size: 16 bytes
    Space losses: 0 bytes internal + 0 bytes external = 0 bytes total
    
    locking...
    
    Process finished with exit code 0
    

    注释掉age字段对象信息

    com.chihai.graduation_project.synchronize.ChiHai object internals:
     OFFSET  SIZE   TYPE DESCRIPTION                               VALUE
          0     4        (object header)                           01 00 00 00 (00000001 00000000 00000000 00000000) (1)
          4     4        (object header)                           00 00 00 00 (00000000 00000000 00000000 00000000) (0)
          8     4        (object header)                           18 0a 05 17 (00011000 00001010 00000101 00010111) (386206232)
         12     4        (loss due to the next object alignment)
    Instance size: 16 bytes
    Space losses: 0 bytes internal + 4 bytes external = 4 bytes total
    
    locking...
    
    Process finished with exit code 0
    

    我们可以清晰的看到一个对象由对象头,示例数据,和对齐填充组成。至于为什么要存在对其填充,因为在我们64位的JVM中一个对象大小必须是8的整数倍。因此,当对象实例数据部分没有对齐时,就需要通过对齐填充来补全。假设一个对象只有10byte,虚拟机在分配内存时就会分配16个byte。
    这里有一点需要注意一下,市面上能见到大部分文章在介绍对象头时都说64位系统下对线头占16个字节,这里我不知道他们是从何得出。个人猜测可能是在古老的版本下是这样的,就目前我所使用的1.8环境下对象头可以清楚的看到是3X4=12这里涉及到指针压缩我暂时还不懂----------以后懂了再回来详细说明吧。希望后来能看到我这个小白博客的看官能及时纠正过来,很多文章放在当前环境已经不适用

    对象头:

    这里需要说明下JVM其实只是sun公司定义的一套规范,而我们平时使用到的hotspot是sun公司提供的一套落地实现。实际上虚拟机并非只有一种像IBM,阿里等都有自己的JVM产品。

    openJDK又是啥子呢,其实openJDK可以理解为是一个项目,它是hotspot的源码,是用C++开发的。openJDK编译后其实就是我们的java.exe

    openJDK官网,接下来我们就去官网找下有关对象头的信息

    看下官方是如何定义的

    object header

    Common structure at the beginning of every GC-managed heap object. (Every oop points to an object header.) Includes fundamental information about the heap object’s layout, type, GC state, synchronization state, and identity hash code. Consists of two words. In arrays it is immediately followed by a length field. Note that both Java objects and VM-internal objects have a common object header format.感觉自己英语实在垃圾。。。

    谷歌翻译一下好了:
    每个GC管理的堆对象开头的通用结构。 (每个oop都指向一个对象标头。)包括有关堆对象的布局,类型,GC状态,同步状态和标识哈希码的基本信息。 由两个词组成。 在数组中,紧随其后的是长度字段。 请注意,Java对象和VM内部对象都具有通用的对象标头格式。

    这里提到对象头由两部分组成,是哪两部分?Mark Word、Class Metadata Address这是网络上百分之99的答案。到底是不是这样呢?在官方文档中我找到了关于Mark Word的描述。

    Mark Word:
    The first word of every object header. Usually a set of bitfields including synchronization state and identity hash code. May also be a pointer (with characteristic low bit encoding) to synchronization related information. During GC, may contain GC state bits.

    每个对象标头的第一个单词。 通常,一组位域包括同步状态和标识哈希码。 也可以是指向与同步相关的信息的指针(具有特征性的低位编码)。 在GC期间,可能包含GC状态位。

    klass pointer:
    The second word of every object header. Points to another object (a metaobject) which describes the layout and behavior of the original object. For Java objects, the “klass” contains a C++ style “vtable”.

    每个对象标头的第二个字。 指向另一个对象(元对象),该对象描述原始对象的布局和行为。 对于Java对象,“容器”包含C ++样式“ vtable”。
    官方给出的定义是klass pointer,Class Metadata Address更像是它的解释这里基本没什么问题

    在hotspot中是如何实现的,我们需要去源码里查看:
    https://github.com/unofficial-openjdk/openjdk/blob/jdk/jdk/src/hotspot/share/oops/markWord.hpp

    下面是截取的一段关键注释

    //  32 bits:
    //  --------
    //             hash:25 ------------>| age:4    biased_lock:1 lock:2 (normal object)
    //             JavaThread*:23 epoch:2 age:4    biased_lock:1 lock:2 (biased object)
    //             size:32 ------------------------------------------>| (CMS free block)
    //             PromotedObject*:29 ---------->| promo_bits:3 ----->| (CMS promoted object)
    //
    //  64 bits:
    //  --------
    //  unused:25 hash:31 -->| unused:1   age:4    biased_lock:1 lock:2 (normal object)
    //  JavaThread*:54 epoch:2 unused:1   age:4    biased_lock:1 lock:2 (biased object)
    //  PromotedObject*:61 --------------------->| promo_bits:3 ----->| (CMS promoted object)
    //  size:64 ----------------------------------------------------->| (CMS free block)
    

    64位下Mark Word就占64 ,klass pointer32

    在了解完这些基础知识后正式进入synchronize分析

    synchronize通过修改对象头同步状态信息从而达到锁定对象的功能。那么同步状态又存储在对象头的那一部分?
    拿出源码中的注释逐步看一下:
    unused:25 hash:31 -->| unused:1 age:4 biased_lock:1 lock:2 (normal object)
    一个对象无锁的情况下:前25位什么都没有存,后面31位hashcode,再后面1位没有存,接着4位存放着我们的GC分代年龄这里其实也为我们解释了为什么young区要经过16次GC才能到达老年区四位的情况下最大数1111为15,所以在到达15后再经过一次GC就超出了限制此时就会在16次时进入老年区。所以在我们64位环境下前54位存的是hash,为什么不是31呢。因为在java当中在我们计算时是精确不到每一个位数的只能拿bit,像31我们是拿不到3bit+7位。最低只能拿4bit,这里就是将我们前56位合起来计算的原因。 biased_lock表示是否是偏向锁。最后两位是锁标示位不同类型的锁对应不同标识。下面会进行详细介绍

    下面我们拿出前56位hashcode看一下

    00000001 00000000 00000000 00000000
    00000000 00000000 00000000
    

    看到这里不知道大家有没有疑惑,这也太扯淡了一个hashcode只有一位为1。到底是哪里出问题了呢?因为此时我们的对象还没有计算过hashcode,所以这里还没有hashcode.文章开头代码部分特意将// chiHai.hashCode();注释掉了,我们取消注释重新打印看看结果:

    现在是不是正常多了

    com.chihai.graduation_project.synchronize.ChiHai object internals:
     OFFSET  SIZE   TYPE DESCRIPTION                               VALUE
          0     4        (object header)                           01 0b 35 80 (00000001 00001011 00110101 10000000) (-2144007423)
          4     4        (object header)                           5b 00 00 00 (01011011 00000000 00000000 00000000) (91)
          8     4        (object header)                           18 0a 1a 17 (00011000 00001010 00011010 00010111) (387582488)
         12     4    int ChiHai.age                                0
    Instance size: 16 bytes
    Space losses: 0 bytes internal + 0 bytes external = 0 bytes total
    
    locking...
    
    Process finished with exit code 0
    
    

    但是我们这里又出现问题了按理说前25位是unused没有使用应该都为0为什么这里不是呢?反而倒数几个字节都为0。这里涉及到我们的处理器,在我们一般的电脑上存储数据的方式叫做小端存储。Mac好像有所不同

    大端模式,是指数据的高字节保存在内存的低地址中,而数据的低字节保存在内存的高地址中,这样的存储模式有点
    儿类似于把数据当作字符串顺序处理:地址由小向大增加,而数据从高位往低位放;这和我们的阅读习惯一致。
    小端模式,是指数据的高字节保存在内存的高地址中,而数据的低字节保存在内存的低地址中,这种存储模式将地址
    的高低和数据位权有效地结合起来,高地址部分权值高,低地址部分权值低。
    

    这是百度给的例子

    小端模式
    所谓的小端模式(Little-endian),是指数据的高字节保存在内存的高地址中,而数据的低字节保存在内存的低地址
    中,这种存储模式将地址的高低和数据位权有效地结合起来,高地址部分权值高,低地址部分权值低,和我们的逻辑方法一致。
    例子:
    0000430: e684 6c4e 0100 1800 53ef 0100 0100 0000
    0000440: b484 6c4e 004e ed00 0000 0000 0100 0000
    在小端模式下,前32位应该这样读: 4e 6c 84 e6( 假设int占4个字节)
    记忆方法: 地址的增长顺序与值的增长顺序相同
    

    回到我们的实际案例中分析在我们64bit中,最高的字节就是我们unused:1 age:4 biased_lock:1 lock:2这8个bit,就对应存放在我们第一个byte中即00000001,剩余56个就保存在:

    --------------00001011 00110101 10000000
    01011011 00000000 00000000 00000000
    00011000 00001010 00011010 00010111
    

    hash中25个unused就对应最后面的00000000 00000000 00000000和01011011 中的首位0

    我们打印下对应16位hash对照一下,或者也可以单独拿出对应2进制转换为16进制进行对比。这里为了方便就一次性转换了

     System.out.println(Integer.toHexString(chiHai.hashCode()));
     打印结果:5b80350b
    

    在这里插入图片描述
    我们要研究的关键是synchronize,synchronize就是由 biased_lock:1 lock:2 这三位控制的。在这之前我们首先需要知道一个知识在我们java代码中thread.start()一个线程,底层start0()就会调用c语言中的pthread_create()函数在操作系统创建一个对应线程。在我们hotspot环境下java中的线程跟操作系统中的线程是一一对应的。当然在别的JVM中可能并不是这样。或者是别的版本中的hotspot也并非如此。但是我们的synchronize在1.6进行了重大优化,1.6之前与现在是完全不同的。1.6之前synchronize是利用操作系统(linux mutex)的同步机制群实现同步的。在ReentrantLock源码分析那篇博客中也谈到了这件事情。在1.6优化后在java级别完成锁的实现从而大大提升synchronize的性能。

    在很多时候我们会加上synchronize关键字来保证有资源竞争情况下的安全性,但是这种竞争的发生率并不是百分之百,在应用在实际运行时,很可能只有一个线程会调用相关同步方法。所以1.6之后sun公司大佬针对这一点做了优化,为了提高一个对象在一段很长的时间内都只被一个线程用做锁对象场景下的性能,引入了偏向锁,在第一次获得锁时,会有一个CAS操作,之后该线程再获取锁,只会执行几个简单的命令,而不是开销相对较大的CAS命令。还有如适应性自旋,锁消除,锁粗化等。锁又分为无锁、偏向锁、轻量级所、重量级锁,GC5种状态。

    unused:25 hash:31 -->| unused:1 age:4 biased_lock:1 lock:2 (normal object)之前我们介绍的这种情况就是无锁状态。这里前56位存储的是hash,下面就会发现当升级为偏向锁时我们的对象状态会有很大的改变。其实这里也可以理解为没有偏向任何线程的偏向锁。

    JavaThread*:54 epoch:2 unused:1 age:4 biased_lock:1 lock:2 (biased object)当有线程来第一次调用我们的对象时就会膨胀升级为偏向锁,偏向锁就像名字一样顾名思义它会偏心于某一线程。此时就不需要调用操作系统原语去进行互斥。仅仅需要把此时的对象头JavaThread*:54 epoch:2,前54位用来表示线程id。当我们线程第二次来时就不会进行CAS上锁,而是直接对比当前对象中存的线程和访问线程是否相同。如果相同则可以直接拿到锁不需要执行任何操作系统和CPU级别指令。

    JVM的开发者发现在很多情况下,在Java程序运行时,同步块中的代码都是不存在竞争的,不同的线程交替的执行同步块中的代码。这种情况下,用重量级锁是没必要的。因此JVM引入了轻量级锁,ptr_to_lock_record:62 lock:2 的概念。线程在执行同步块之前,JVM会先在当前的线程的栈帧中创建一个Lock Record,其包括一个用于存储对象头中的 mark word(官方称之为Displaced Mark Word)以及一个指向对象的指针。下图右边的部分就是一个Lock Record.

    在这里插入图片描述
    在多个线程同时竞争的情况下就会再次膨胀升级为重量级锁,也即我们1.6之前的锁,调用底层系统函数。

    我们的锁总共有5种状态而描述锁状态的只有两个bit,lock:2。2个bit我们知道最多只能有4种组合情况那么它是如何描述5种状态的呢?

    在上面我说过无锁可以看做为特殊的偏向锁,即没有指定偏向目标的偏向锁。hotspot中正式利用了这一点来区分无锁与偏向锁。无锁与偏向锁的锁状态都为01,但是无锁的biased_lock:表示为0,偏向锁表示为1这就很好的区分了无锁与偏向锁。
    无锁------------001
    偏向锁---------101
    轻量级锁------00
    重量级锁------10
    GC--------------11
    到底是不是这样我们可以去打印对象信息验证一下:
    将上面测试代码进行小的调整

    public class SynchronizeDemo {
        static ChiHai chiHai = new ChiHai();
        public static void main(String[] args) {
    
             chiHai.hashCode();
    
            System.out.println(Integer.toHexString(chiHai.hashCode()));
    
            test();
    
    //        IntStream.rangeClosed(0,10).forEach(ics ->
    //            new Thread(()->
    //                test()
    //            ).start()
    //        );
    
        }
        static void test(){
            synchronized (chiHai){ // 测试synchronized锁的是对象而不是代码
                System.out.println("locking2...");
                System.out.println(ClassLayout.parseInstance(chiHai).toPrintable()); //解析并打印当前对象
            }
        }
    }
    
    

    打印结果:

    在这里插入图片描述

    此时只有主线程一个线程调用为什么锁状态是00呢,我们知道00代表轻量级锁,按道理说这里应该是偏向锁啊???

    这里是因为JVM默认启动了偏向锁延迟功能(默认延迟4秒),JVM为什么要这么做呢?因为在我们JVM启动时,并非只有一个main线程,在JVM启动时自己也会启动很多线程来运行运行一些内核的功能。而这些功能的实现代码中也有很多采用了synchronize关键字,JVM知道这些代码大概率不会只有一个线程使用,将来还会有其他很多线程来访问。这里涉及到我们的偏向锁撤销问题,而这个撤销过程比较复杂。所以JVM在启动时就暂时取消了偏向锁来消除不必要的性能开销。

    我们可以用如下参数进行设置
    启用参数:
    -XX:+UseBiasedLocking
    关闭延迟:
    -XX:BiasedLockingStartupDelay=0
    禁用参数:
    -XX:-UseBiasedLocking

    最后我们将上面注释打开看一下当有很多线程同时竞争锁时重量级锁标识是否为10:

    在这里插入图片描述
    到这里我们差不多也证明了上面的几种规范是否真的如此,关于偏向锁,轻量级锁加锁,撤销,解锁等我感觉现在个人理解还有点困难等未来有了一定研究会单独开一篇博客来进行学习。

    展开全文
  • 二:判断下面说法是否正确 三:设计并测试一个名为Retangle矩形类,包括属性有矩形左下角与右上角两个点坐标,包括方法有计算矩形宽度和高度以及矩形面积 四:编写一个类实现复数运算 五:为一个...
  • 计数器习题答案.doc

    2019-12-30 12:09:21
    一 填空题 1.计数器? 2.二进制计数器二-十进制计数器任意进制计数器 3.加法计数器减法计数器可逆... 11N 12N 二判断下面说法是否正确用"或"表示在括号? 1? 2. 3 4 5? 6 7? 8 9? 三选择题 1.A 2.D 3.A 4.D 5.A 6.A 7
  • 数据结构:笔记-排序

    2020-05-26 00:16:43
    3、判断下列说法是否正确:就排序算法平均所用辅助空间而言,堆排序、快速排序、归并排序大小关系是堆排序<快速排序<归并排序。 4、下面()排序算法在输入数据逆序情况下排序速度最快。 正确答案: A 你...
  • 205、 jre 判断程序是否执行结束标准是()206、以下代码执行结果是多少()?207、Java网络程序设计中,下列正确的描述是()208、下面哪个语句是创建数组的正确语句?( )209、下面有关java threadlocal说法正确...
  • Java面试题(二)

    2019-09-15 19:22:25
    C. HashMap中,使用 get(key)==null可以 判断这个Hasmap是否包含这个key D. volatile关键字不保证对变量操作的原子性 解析: AD都为正确 下面的方法,当输入为2的时候返回值是多少?(D) public sta...
  • inline函数

    2017-05-11 02:35:39
    先给出一到判断题:inline函数表示编译器一定会将函数体直接插入到调用此函数地方,这样可以加快程序运行速度,上面说法是否正确.答案是false。为什么呢?下面给出解释: 首先我们要明白内联函数提出原因及...
  • 窗口”,在其属性窗口中将其objectName 改为enterBtn,在下面的Signals and slots editor 中进行信号和槽的关联,其中,Sender 设为enterBtn,Signal 设为clicked(),Receive 设为myDlg,Slot 设为accept()。这样就...
  • 下面有关java classloader说法正确的是()? 1. ClassLoader就是用来动态加载class文件到内存当中用 2. JVM在判定两个class是否相同时,只用判断类名相同即可,和类加载器无关 3. ClassLoader使用是双亲委托...
  • Java多态 练习

    2020-07-23 21:55:19
    判断类Person对象person1是否满足类Man实例特征,正确的语句A 6、在Java中,多态实现不仅能减少编码工作量,还能大大提高程序可维护性及可扩展性,那么实现多态步骤包括以下几个方面除了 B 7、下面
  • 下面有关java classloader说法错误是? 正确答案: C A Java默认提供三个ClassLoader是BootStrap ClassLoader,Extension ClassLoader,App ClassLoader B ClassLoader使用是双亲委托模型来搜索类 ...
  • R-Squared

    千次阅读 2018-07-25 00:42:49
    此时,如果增加一个特征,模型不变,则下面说法正确的是? A. 如果 R-Squared 增加,则这个特征有意义 B. 如果R-Squared 减小,则这个特征没有意义 C. 仅看 R-Squared 单一变量,无法确定这个特征是否有意义。 D...
  • flash shiti

    2014-03-14 10:32:41
    16. 下面的语句说法正确的是: □ A. 目前Flash 最新的创作平台是Flash MX,播放插件是Flash MX Player。 □ B. 目前Flash 最新的创作平台是Flash MX,播放插件是Flash 6.0 Player。 □ C. 目前Flash 最新的创作平台...
  • ; margin-right:0">1.如果a=1,b=2,c=3,d=4,则表达式a>...下面说法正确的是( C )。 ; margin-right:0">A. 一个源程序文件由一个或多...
  • 会计理论考试题

    2012-03-07 21:04:40
    4. 应用程序窗口缩成图标后,___A____是不正确的说法。 A、应用程序停止运行 B、应用程序继续运行 C、应用程序图标就放到了任务栏上 D、单击该图标,窗口就还原了 5.窗口右上角的"X"按钮是___C___。 A、最小化 B、...
  • C++复习资料之系列

    2008-12-30 21:35:45
    后,下面正确的赋值语句是( b )。 (a) *p2 = b; (b) p1 = a; (c) p2 = p1; (d) c = *p1 *(*p2); 16.执行语句 int a = 10,b;int &pa = a,&pb = b; 后,下列正确的语句是( b )。 (a) &pb = a; ...
  • 铝热反应(知识延伸)

    2013-06-23 00:36:24
    请你分析该设计是否正确(填“正确”或“不正确”) ,理由是(用离子方程式表示) (4)若要测定该熔融物中铝元素含量,请设计实验,写出所用试剂名称和实验步骤(不用写化学方程式,用文字简述)。 ① ② ...
  • JAVA面试题最全集

    2010-03-13 13:09:10
    判断一个文件或目录是否存在 如何读写文件 7.Java多态实现(继承、重载、覆盖) 8.编码转换,怎样实现将GB2312编码字符串转换为ISO-8859-1编码字符串。 9.Java中访问数据库步骤,Statement和...
  • 面试题16:程序是否正确 面试题17:指出程序错误 5.6 动态内存 面试题18:简述C、C++程序编译内存分配情况 面试题19:以下四段代码中哪段没有错误 第6章 字符串 6.1 数字字符串 面试题1:编码实现数字转化为字符...
  • -ButtonPressed属性值能够正确的反映客户端变化。 -优化Tree控件AJAX实现。 +为页面Form添加autocomplete="off"属性。 -参考http://www.cnblogs.com/sanshi/archive/2009/09/04/1560146.html#1635830 ...
  • 1.3 开发数据库应用的正确(和不正确)方法 10 1.3.1 了解Oracle体系结构 11 1.3.2 理解并发控制 19 1.3.3 多版本控制 22 1.3.4 数据库独立性 28 1.3.5 怎么能让应用运行得更快 42 1.3.6 DBA与开发人员关系...

空空如也

空空如也

1 2 3
收藏数 44
精华内容 17
关键字:

判断下面的说法是否正确