JVM01

1.data areas 有生命周期的 jvm启动的时候被创建 jvm退出的时候被销毁
2.有些data areas是线程独有的      当线程创建的时候被创建 线程退出的时候被销毁

总结：	
1）JVM创建时创建，退出时销毁
2）每个Thread独有，Thread创建时创建，Thread退出时销毁
	==> 有一些区是共享，有一些区是独享    从线程的角度

运行时数据区有哪些呢？
运行时数据区
	1） The pc Register        程序计数器
	2） Java Virtual Machine Stacks
	3） Heap          
	4） Method Area                   方法区
	5） Run-Time Constant Pool      这个一般是在方法区里面的
	6） Native Method Stacks

每一个区做什么事情 下面依次讲解

The pc Register  程序计数器
	1.占用一小块的内存       (指的是占用运行时数据区总的内存 毕竟他是在运行时数据区的内部的)
	2.作用：当前线程所执行的字节码的行号指示器
		什么意思呢？
			在java里可能是以单线程的方式运行的 也有可能以多线程的方式运行的 那么问题来了
			比如说 多线程的方式  你这个线程的在跑 此时另外一个线程它拿到了cpu的执行权 它开始执行的时候
			那么前一个线程肯定会停下来  就是优先级高的调度到的 先执行。等它运行完了再抢占。这个时候如果前面的线程回来了
			问题是 回来的这个线程从什么地方开始执行 它知道吗？这就是当前线程所执行的字节码都是有一个的行号指示器的
			意思就是说 它会从字节码里的某一个行号开始往下继续执行

什么是字节码？
	 eg：
[double_happy@hadoop101 jvm]$ cat Hello.java 
public class Hello{
        public static void  main(String[] args){
                System.out.println("hello..");
        }
}
[double_happy@hadoop101 jvm]$ 

Hello.java 这个东西对于jvm来说不知道是什么东西 这仅仅是我们开发的应用程序java源代码而已 系统是不能识别的
系统识别的是class文件  所以需要把Hello.java文件编译成class文件

[double_happy@hadoop101 jvm]$ javac Hello.java 
[double_happy@hadoop101 jvm]$ ll
total 8
-rw-rw-r-- 1 double_happy double_happy 411 Nov  5 19:18 Hello.class
-rw-rw-r-- 1 double_happy double_happy 100 Nov  5 19:18 Hello.java
[double_happy@hadoop101 jvm]$ rm -rf Hello.class 
[double_happy@hadoop101 jvm]$ java Hello
Error: Could not find or load main class Hello
[double_happy@hadoop101 jvm]$ javac Hello.java 
[double_happy@hadoop101 jvm]$ java Hello
hello..
[double_happy@hadoop101 jvm]$

Hello.class 是一个class字节码文件  可以通过命令查看他的字节码

[double_happy@hadoop101 jvm]$ javap -verbose Hello.class >> Hello.txt
[double_happy@hadoop101 jvm]$ cat Hello.txt 
Classfile /home/double_happy/script/jvm/Hello.class
  Last modified Nov 5, 2019; size 411 bytes
  MD5 checksum 6f1c4345f8677c12ec8d3eb12da54cda
  Compiled from "Hello.java"
public class Hello         //下面就是他的字节码文件
  minor version: 0         //jdk版本
  major version: 52      ////jdk版本     
  flags: ACC_PUBLIC, ACC_SUPER
Constant pool:
   #1 = Methodref          #6.#15         // java/lang/Object."<init>":()V
   #2 = Fieldref           #16.#17        // java/lang/System.out:Ljava/io/PrintStream;
   #3 = String             #18            // hello..
   #4 = Methodref          #19.#20        // java/io/PrintStream.println:(Ljava/lang/String;)V
   #5 = Class              #21            // Hello
   #6 = Class              #22            // java/lang/Object
   #7 = Utf8               <init>
   #8 = Utf8               ()V
   #9 = Utf8               Code
  #10 = Utf8               LineNumberTable
  #11 = Utf8               main
  #12 = Utf8               ([Ljava/lang/String;)V
  #13 = Utf8               SourceFile
  #14 = Utf8               Hello.java
  #15 = NameAndType        #7:#8          // "<init>":()V
  #16 = Class              #23            // java/lang/System
  #17 = NameAndType        #24:#25        // out:Ljava/io/PrintStream;
  #18 = Utf8               hello..
  #19 = Class              #26            // java/io/PrintStream
  #20 = NameAndType        #27:#28        // println:(Ljava/lang/String;)V
  #21 = Utf8               Hello
  #22 = Utf8               java/lang/Object
  #23 = Utf8               java/lang/System
  #24 = Utf8               out
  #25 = Utf8               Ljava/io/PrintStream;
  #26 = Utf8               java/io/PrintStream
  #27 = Utf8               println
  #28 = Utf8               (Ljava/lang/String;)V
{
  public Hello();     //自带空的构造器 
    descriptor: ()V     
    flags: ACC_PUBLIC
    Code:
      stack=1, locals=1, args_size=1
         0: aload_0     //字节码的指令
         1: invokespecial #1                  // Method java/lang/Object."<init>":()V
         4: return
      LineNumberTable:      //行号   在程序或者线程的执行过程当中 它就能知道我这次运行到字节码里面的多少行 
        line 1: 0

  public static void main(java.lang.String[]);
    descriptor: ([Ljava/lang/String;)V
    flags: ACC_PUBLIC, ACC_STATIC
    Code:
      stack=2, locals=1, args_size=1
         0: getstatic     #2                  // Field java/lang/System.out:Ljava/io/PrintStream;
         3: ldc           #3                  // String hello..
         5: invokevirtual #4                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V
         8: return
      LineNumberTable:
        line 3: 0
        line 4: 8
}
SourceFile: "Hello.java"
[double_happy@hadoop101 jvm]$

字节码
	 aload_0    字节码指令   
	  我们的应用程序最后拿到的是一堆的机器的指令  jvm就可以通过我们这些指令 它就知道你开发的应用程序想做一个什么事情 
	  (java 代码一定会被编译成字节码 不同的字节码 干不同的事情）就是这一步.java =>.class 

那么字节码和 程序计数器有什么关系呢？
程序计数器：
	记录当前线程目前执行到你的代码所对应的哪一条字节码指令

多线程的情况下执行你的代码？
	可能是多个线程并发的执行   那么多个线程共同执行的时候 就有可能出现
	你每一个线程当前运行到的字节码指令行数是不一样的      多线程就是cpu抢占的问题
	也就是说：每个线程都有自己的程序计数器      
		专门用来记录我们所执行的这个线程现在到了哪一步了 

所以：**
程序计数器   属于  运行时数据区  的第二类       即  每个Thread独有

public class Hello {

    public static void main(String[] args) {

        Hello hello = new Hello(); 
        hello.hello();
    }
    
    public  void hello(){
        String name = "double_happy";   //局部变量     它的生命周期是在 这个hello函数里面的 
        System.out.println("Hello: " + name);  
                
    }
}

在main方法里面调用hello这个方法  我们在执行的过程当中 一定是有一个线程在 执行这段代码 去调用hello这个方法

这里来说是 main这个线程  执行main方法里面的代码   
那么对于 局部变量来说 它到时候会存在 jvm 数据运行区 的哪一个部分呢？

存在Java Virtual Machine Stacks   jvm的一个栈

Each Java Virtual Machine thread has a private Java Virtual Machine stack, created at the same time as the thread
A Java Virtual Machine stack stores frames 

Java Virtual Machine Stacks  
	1.方法里面的一些局部变量......   它就是存在 frames里的 
	2.存的是frames: 栈帧
	A new frame is created each time a method is invoked. 方法调用的时候被创建
		对于上面的代码来说  main方法被调用 会创建一个 frame  hello方法被调用 也会创建一个  frame 
	A frame is destroyed when its method invocation completes  方法执行完毕的时候被销毁
		
	栈的特性 ：先进后出 
	栈：main==>hello    入栈：就是方法被调用的时候   出栈 ： 方法执行完毕的时候
	可能会抛出的异常：StackOverflowError
		这个很好理解 我们这些区 都是属于jvm运行时的区 每个区肯定都是有大小的 
		你的线程计算时需要的大小 比我们 Java Virtual Machine Stacks   大 会抛出StackOverflowError 这个异常
	
	调用方法时，会为每个方法创建Frame，入栈
	方法执行完毕后，Frame出栈

The Java Virtual Machine has a heap that is shared among all Java Virtual Machine threads
所有线程共享的一块区域

Heap ：
	创建对象  是存在Heap里面的
	可能会抛出的异常：OutOfMemoryError
		什么场景下？你new出来的一些东西 最终放在heap里  比你默认的heap的大小大 

eg：
public class Hello {

    public static void main(String[] args) {

        Hello hello = new Hello();
        hello.hello();
    }

    public  void hello(){
        String name = "double_happy";
        System.out.println("Hello: " + name);

        BasketballPlayer player = new BasketballPlayer("波兰名宿");
        player.xxx();
    }
}

class BasketballPlayer{
    String name;
    
    public BasketballPlayer(){}
    public BasketballPlayer(String name){
        this.name = name;
    }  
    public void xxx(){
        System.out.println(name + "发边线球....");
    }
}

在我们的hello方法里面 new 了一个对象  它是在堆里面的

The Java Virtual Machine has a method area that is shared among all Java Virtual Machine threads.
所有线程共享的一块区域   1.8之后叫做 Metaspace

Method Area/Metaspace里面存的是：
	constant pool, 常量池
	field and method data,  属性和方法数据
	and the code for methods and constructors   方法代码和构造器代码
	就是：
		class文件加载进来放这里
	可能会抛出的异常：OutOfMemoryError
    什么场景下发生呢？

Native Method Stacks
	native修饰的方法 是调用本地操作系统里面的方法 c语言或者 一些底层类库等等
	可能会抛出的异常：StackOverflowError/OutOfMemoryError

那么在调用 native修饰的方法 的时候 每个线程就会创建一个 本地方法栈

所以方法分为两种：
	native的      放在Native Method Stacks
	非native的   放在 Java Virtual Machine Stacks

还有一个区：是干嘛的呢？
	Area: 不属于JVM   
		eg： 通过nio 直接创建一些内存   就是堆外内存  这块是直接操作内存空间的 性能方面是好的 （Spark里面是有的  得调整堆外内存的空间的）
			但是 如果不节制 会有可能会出现什么场景呢？
			你大量的去这么干肯定是不行的  建议 你如果 去调用底层源码是可以的  自己的代码直接操作堆外内存是不合适的

 public static void main(String[] args) {
        String s1 = new String("double happy");
    }

问这句话产生了几个对象？
	2个：哪两个呢？
		1.s1   局部变量 存的是对象的地址  在stack里 
		2.  new String     在Heap 里面  
		3.  方法区里面的常量池 存一个对象 叫 double happy 

测试：
	    public static void main(String[] args) {
        String s1 = new String("double happy");
        String s2 = "double happy";

        System.out.println(s1 == s2);
    }

结果是false 
	因为s1 指向heap 里的 new String
	s2 指向的method area 里的常量池里的 double happy

测试：
	    public static void main(String[] args) {
        String s1 = new String("double happy");
        String s2 = "double happy";

        System.out.println(s1 == s2); //比较的是 引用地址
        System.out.println(s1.equals(s2));// equals 比较的是内容
    }
  结果是：
  	false
  	true

    public static void main(String[] args) {
        String s1 = "双喜";
        String s2 = "男的";
        String s3 = "双喜" + "男的";
        String s4 = s1 + s2;
        String s5 = "双喜男的";
       String s6 = s4.intern();
        System.out.println(s3 == s4); 
        System.out.println(s3 == s5);
        System.out.println(s4 == s5);
          System.out.println(s3 == s6);
    }

结果是：
false
true
false

/**
     * Returns a canonical representation for the string object.
     * <p>
     * A pool of strings, initially empty, is maintained privately by the
     * class {@code String}.
     * <p>
     * When the intern method is invoked, if the pool already contains a
     * string equal to this {@code String} object as determined by
     * the {@link #equals(Object)} method, then the string from the pool is
     * returned. Otherwise, this {@code String} object is added to the
     * pool and a reference to this {@code String} object is returned.
     * <p>
     * It follows that for any two strings {@code s} and {@code t},
     * {@code s.intern() == t.intern()} is {@code true}
     * if and only if {@code s.equals(t)} is {@code true}.
     * <p>
     * All literal strings and string-valued constant expressions are
     * interned. String literals are defined in section 3.10.5 of the
     * <cite>The Java&trade; Language Specification</cite>.
     *
     * @return  a string that has the same contents as this string, but is
     *          guaranteed to be from a pool of unique strings.
     */
    public native String intern();
所以  intern  返回 string object. 真实的值 
所以s6 指向的是 常量池里面的东西 

 if and only if {@code s.equals(t)} is {@code true}.
 就是 equals相等  intern  就相等

比较特殊：
    public static void main(String[] args) {
   
        Integer i1 = 50;
        Integer i2 = 50;

        System.out.println(i1 == i2);
        
    }

这个东西按常理来讲是 不等的对吧  包装类 一般是new 出来的 
这是相等的
先这样 
	Integer i1 = new Integer(50);
    Integer i2 = new Integer(50);
这两个相等么？
	false


对于基本类型 包装类型 都是放在 常量池里的 new出来的肯定不是放在池子里的哈 

那么：
	        Integer i1 = 150;
            Integer i2 = 150;
         相等么？  不等的
         因为 池子里面 是有一个范围的   基本类型 包装类型都有


    /**
     * Returns an {@code Integer} instance representing the specified
     * {@code int} value.  If a new {@code Integer} instance is not
     * required, this method should generally be used in preference to
     * the constructor {@link #Integer(int)}, as this method is likely
     * to yield significantly better space and time performance by
     * caching frequently requested values.
     *
     * This method will always cache values in the range -128 to 127,
     * inclusive, and may cache other values outside of this range.
     *
     * @param  i an {@code int} value.
     * @return an {@code Integer} instance representing {@code i}.
     * @since  1.5
     */
    public static Integer valueOf(int i) {
        if (i >= IntegerCache.low && i <= IntegerCache.high)
            return IntegerCache.cache[i + (-IntegerCache.low)];
        return new Integer(i);
    }

注意：
 IntegerCache.low && i <= IntegerCache.high  
low = -128
int h = 127

明白了吧 

但是 
        Double d1 = 10.0D;
        Double d2 = 10.0D;
看源码你就知道了 


	    public static Double valueOf(double d) {
        return new Double(d);
    }

底层是 new   所以是不等的 


所以 源码面前了无密码  源码用到的时候  还是要看的