总览

1.对象创建的过程（半初始化）
2.DCL 是否需要 volatitle （指令重排）
3.对象内存结构（对象与数组的不同）
4.对象头包含什么（markword klasspointer synchronized锁信息）
5.对象如何定位（直接间接）
6.对象怎么分分配（栈本地线程 eden old）
7.Obeject o = new Object()在内存中占多少字节

1.对象创建的过程（半初始化）

public class T {
   int m=8;
   public static void main(string[] args){
      T t = new T();
  }
}

汇编码：

0 new #2<T>                            申请内存 （半初始化 int 0）
3 dup                    由于invoke
4 invokespecial # 3 <T.<init>>         设置初始值 调用T构造方法 0->8
7 astore_1                             t和 内存对象关联
8return

2.DCL 是否需要 volatitle （指令重排）

单例模式资源浪费（未使用先new）

public class T {
    private static final T INSTANCE=new T();
    private T(){};
    public static T getInstance(){ return INSTANCE;}
    public void m(){ Systrm.out.println("m");}
    public static void main(string[] args){
      T t = T.getInstance();
      T t1 = T.getInstance();
      System.out.println(t == t1)
  }
}

解决浪费按需初始化，线程不安全多次new,

public class T {
    private static T INSTANCE;
    private T(){};
    public static T getInstance(){
//  按需初始化
      if (INSTANCE == null ){
        try {
            Thread.sleep(millis: 1);
        } catch (InterruptedException e){
         e.printStackTrace();
        }
        INSTANCE = new T();
       }
       return INSTANCE;
    }
    public void m(){ Systrm.out.println("m");}

    public static void main(string[] args){
        for(int i=0; i<100;i++){
            new Thread(()-> 
                    System.out.println(T.ggetInstance().hashCode())
             ).start();
        }
    }
}

线程安全锁整个方法效率下降

public class T {
    private static T INSTANCE;
    private T(){};
// syncnronized
    public static syncnronized T getInstance(){
      if (INSTANCE == null ){
        try {
            Thread.sleep(millis: 1);
        } catch (InterruptedException e){
         e.printStackTrace();
        }
        INSTANCE = new T();
       }
       return INSTANCE;
    }
    public void m(){ Systrm.out.println("m");}

    public  static void main(string[] args){
        for(int i=0; i<100;i++){
            new Thread(()-> 
                    System.out.println(T.ggetInstance().hashCode())
             ).start();
        }
    }
}

锁整内部方法

public class T {
    private static T INSTANCE;
    private T(){};
    public static T getInstance(){
      if (INSTANCE == null ){
    //通过减小同步代码快的方式提高效率 ,可能第一个Thread判断完了 等在这，
//第二个Tread 判断完往下走，已经给T赋值了，第一个再往下走重新newT
         syncnronized （T.class）{
            try {
              Thread.sleep(millis: 1);
            } catch (InterruptedException e){
               e.printStackTrace();
            }
            INSTANCE = new T();
          }
        }
       return INSTANCE;
    }
    public void m(){ Systrm.out.println("m");}

    public  static void main(string[] args){
        for(int i=0; i<100;i++){
            new Thread(()-> 
                    System.out.println(T.ggetInstance().hashCode())
             ).start();
        }
    }
}

DCL Double Check Lock CPU指令重排序之后读取之前半初始化的值（volatile 保持Thread可见性，禁止指令重拍）

public class T {
    private static volatile T INSTANCE; 禁止指令重排
    private static T INSTANCE;
    private T(){};
    public static T getInstance(){
      //业务代码省略
      if (INSTANCE == null ){  //DCL
         //双重检查   
         syncnronized （T.class）{
           if(INSTANCE == null){
            try {
              Thread.sleep(millis: 1);
            } catch (InterruptedException e){
               e.printStackTrace();
            }
            INSTANCE = new T();
           }
          }
        }
       return INSTANCE;
    }
    public void m(){ Systrm.out.println("m");}

    public  static void main(string[] args){
        for(int i=0; i<100;i++){
            new Thread(()-> 
                    System.out.println(T.ggetInstance().hashCode())
             ).start();
        }
    }
}

DCL指令重排

4对象内存结构（对象与数组的不同）

markword +class pointer =object header

image.png

打印对象信息

import org.openjdk.jol.info.ClassLayout;
public class HelloJOL{
public  static void main(String[] args){
object o =new Object();
String s =ClassLayout.parseInstance(o).toPrintable();
System.out.println(s);
syncnroized(o){
System.out.println(ClassLayout.parseInstance(o).toPrintable());  
}
}
}

syncronized:
锁升级:
偏向锁-->自旋锁(CAS)-->重量锁
偏向锁
贴标签是我的标签直接使用内存
不是我的 CAS竞争

CAS