new：最常见的方式、单例类中调用getInstance的静态类方法，XXXFactory的静态方法。
Class的newInstance方法：反射的方式，在JDK9中被标记为过时的方法，因为只能调用空参的构造方法，权限必须是public。
Constructor的newInstance(xxx)：反射的方式，可以调用空参、有参的构造器，任意权限。
clone()：不调用任何构造器，当前类需要实现Cloneable接口，实现clone()方法。
反序列化：从文件中、网络中获取一个对象的二进制流。
public class ObjectTest {
public static void main(String[] args) {
Object o = new Object();
}
}
javap -c -p ObjectTest.class查看方法对应的字节码，-v：会输出所有字节码信息
new指令后找到#2位置字符串常量池，找到了Object类，首先判断方法区中是否将类加载了，如果没有加载需要使用类加载器将类进行加载。然后调用Object类的init()方法。
Classfile /D:/IdeaProbject/JVM/target/classes/day5/ObjectTest.class
Last modified 2021-9-11; size 430 bytes
MD5 checksum 5eb0fa7172fbe9c882683b37b9a32a50
Compiled from "ObjectTest.java"
public class day5.ObjectTest
minor version: 0
major version: 52
flags: ACC_PUBLIC, ACC_SUPER
Constant pool:
#1 = Methodref #2.#19 // java/lang/Object."<init>":()V
#2 = Class #20 // java/lang/Object
#3 = Class #21 // day5/ObjectTest
#4 = Utf8 <init>
#5 = Utf8 ()V
#6 = Utf8 Code
#7 = Utf8 LineNumberTable
#8 = Utf8 LocalVariableTable
#9 = Utf8 this
#10 = Utf8 Lday5/ObjectTest;
#11 = Utf8 main
#12 = Utf8 ([Ljava/lang/String;)V
#13 = Utf8 args
#14 = Utf8 [Ljava/lang/String;
#15 = Utf8 o
#16 = Utf8 Ljava/lang/Object;
#17 = Utf8 SourceFile
#18 = Utf8 ObjectTest.java
#19 = NameAndType #4:#5 // "<init>":()V
#20 = Utf8 java/lang/Object
#21 = Utf8 day5/ObjectTest
{
public day5.ObjectTest();
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 7: 0
LocalVariableTable:
Start Length Slot Name Signature
0 5 0 this Lday5/ObjectTest;
public static void main(java.lang.String[]);
descriptor: ([Ljava/lang/String;)V
flags: ACC_PUBLIC, ACC_STATIC
Code:
stack=2, locals=2, args_size=1
0: new #2 // class java/lang/Object
3: dup
4: invokespecial #1 // Method java/lang/Object."<init>":()V
7: astore_1
8: return
LineNumberTable:
line 9: 0
line 10: 8
LocalVariableTable:
Start Length Slot Name Signature
0 9 0 args [Ljava/lang/String;
8 1 1 o Ljava/lang/Object;
}
new指令时，首先将去检查这个指令的参数是否能在Matespace的常量池中定位到 一个类的符号引用，并且检查这个符号引用代表的类是否已被加载、解析和初始化过。
双亲委派模式下，使用当前类加载器以ClassLoader+包名+类名作为Key进行查找定位到对应的.class文件。如果没有找到class文件，则抛出ClassNotFoundException异常；如果找到，则进行类加载，并生成对应的Class类对象。
指针碰撞（Bump The Pointer）方式分配内存
空闲列表（Free List）方式分配内存
由Java堆是否规整决定，而Java堆是否规整又由所采用的垃圾收集器是否带有空间压缩整理（Compact）的能力决定
Serial、ParNew等带压缩整理过程的收集器时，系统采用的分配算法是指针碰撞，既简单又高效；
CMS这种基于清除（Sweep）算法的收集器时，理论上就只能采用较为复杂的空闲列表来分配内存。
标记清除算法：GC之后就会出现很多内存碎片。
标记压缩算法：GC之后会整理内存碎片。
-XX:+/-UseTLAB参数来设定是否使用TLAB。
<init>()方法还没有执行，所有的字段都为默认的零值，对象需要的其他资源和状态信息也还没有按照预定的意图构造好。一般来说（由字节码流中new指令后面是否跟随invokespecial指令所决定，Java编译器会在遇到new关键字的地方同时生成这两条字节码指令，但如果直接通过其他方式产生的则不一定如此），new指令之后会接着执行<init>() 方法，按照程序员的意愿对对象进行初始化，这样一个真正可用的对象才算完全被构造出来。
/**
* 测试对象创建过程：
* 1、加载类元信息；2、为对象分配内存；3、处理并发问题；4、属性的默认初始化（零值初始化）
* 5、设置对象头信息；6、属性的显式初始化、代码块中初始化、构造器中初始化
* 给对象属性赋值操作：
* 1、属性的默认初始化
* 2、显式初始化/代码块中初始化（并列关系，谁先谁后看代码编写的顺序）
* 3、构造器初始化
*/
public class CreateObject {
int id = 1001;
String name;
Users users;
{
name = "匿名用户";
}
public CreateObject() {
users = new Users();
}
}
在HotSpot虚拟机里，对象在堆内存中的存储布局可以划分为三个部分：对象头（Header）、实例 数据（Instance Data）和对齐填充（Padding）。
2、对象头（Header）
运行时元数据（Mark Word）与类型指针。
-XX：FieldsAllocationStyle参数）和字段在Java源码中定义顺序的影响。
longs/doubles、ints、shorts/chars、bytes/booleans、oops（Ordinary Object Pointers，OOPs），从以上默认的分配策略中可以看到，相同宽度的字段总是被分配到一起存放，在满足这个前提条件的情况下，在父类中定义的变量会出现在子类之前。如果HotSpot虚拟机的+XX：CompactFields参数值为true（默认就为true），那子类之中较窄的变量也允许插入父类变量的空隙之中，以节省出一点点空间。
它仅仅起着占位符的作用。由于HotSpot虚拟机的自动内存管理系统要求对象起始地址必须是8字节的整数倍，换句话说就是任何对象的大小都必须是8字节的整数倍。对象头部分已经被精心设计成正好是8字节的倍数（1倍或者2倍），因此，如果对象实例数据部分没有对齐的话，就需要通过对齐填充来补全。
public class CreateObject {
int id = 1001;
String name;
Users users;
{
name = "匿名用户";
}
public CreateObject() {
users = new Users();
}
}
public class Users {
}
public class CreateObjTest {
public static void main(String[] args) {
CreateObject create = new CreateObject();
}
}
reference数据来操作堆上的具 体对象。由于reference类型在《Java虚拟机规范》里面只规定了它是一个指向对象的引用，并没有定义这个引用应该通过什么方式去定位、访问到堆中对象的具体位置，所以对象访问方式也是由虚拟机实现而定的，主流的访问方式主要有使用句柄和直接指针两种。
Java堆中将可能会划分出一块内存来作为句柄池，reference中存储的就是对象的句柄地址，而句柄中包含了对象实例数据与类型数据各自具体的地址信息
优点：
缺点：
reference中存储的直接就是对象地址，直接指向堆中的实例，在对象实例中有类型指针，指向的是方法区中的对象类型数据。
优点：
/**
* 直接内存的占用与释放
*/
public class BufferTest {
private static final int BUFFER = 1024 * 1024 * 1024;//1GB
public static void main(String[] args){
//直接分配本地内存空间
ByteBuffer byteBuffer = ByteBuffer.allocateDirect(BUFFER);
System.out.println("直接内存分配完毕，请求指示！");
Scanner scanner = new Scanner(System.in);
scanner.next();
System.out.println("直接内存开始释放！");
byteBuffer = null;
System.gc();
scanner.next();
}
}
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;
/**
* 分别使用NIO和BIO复制大文件
*/
public class CopyFileWithNio {
private static final String TO = "D:\\Project\\lifecycle-lib.zip";
private static final int _100Mb = 1024 * 1024 * 100;
public static void main(String[] args) {
long sum = 0;
String src = "D:\\Project\\lifecycle-lib.zip";
for (int i = 0; i < 3; i++) {
String dest = "D:\\lifecycle-lib_" + i + ".zip";
//使用传统方式复制文件
// sum += io(src,dest);//1673
//使用NIO方式复制文件
sum += directBuffer(src, dest);//957
}
System.out.println("总花费的时间为：" + sum);
}
/**
* 使用NIO方式
* @param src
* @param dest
* @return
*/
private static long directBuffer(String src, String dest) {
long start = System.currentTimeMillis();
FileChannel inChannel = null;
FileChannel outChannel = null;
try {
inChannel = new FileInputStream(src).getChannel();
outChannel = new FileOutputStream(dest).getChannel();
ByteBuffer byteBuffer = ByteBuffer.allocateDirect(_100Mb);
while (inChannel.read(byteBuffer) != -1) {
//修改为读数据模式
byteBuffer.flip();
outChannel.write(byteBuffer);
//清空
byteBuffer.clear();
}
} catch (IOException e) {
e.printStackTrace();
} finally {
if (inChannel != null) {
try {
inChannel.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if (outChannel != null) {
try {
outChannel.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
long end = System.currentTimeMillis();
return end - start;
}
/**
* 使用传统方式
* @param src
* @param dest
* @return
*/
private static long io(String src, String dest) {
long start = System.currentTimeMillis();
FileInputStream fis = null;
FileOutputStream fos = null;
try {
fis = new FileInputStream(src);
fos = new FileOutputStream(dest);
byte[] buffer = new byte[_100Mb];
while (true) {
int len = fis.read(buffer);
if (len == -1) {
break;
}
fos.write(buffer, 0, len);
}
} catch (IOException e) {
e.printStackTrace();
} finally {
if (fis != null) {
try {
fis.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if (fos != null) {
try {
fos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
long end = System.currentTimeMillis();
return end - start;
}
}
直接内存也可能导致OutofMemoryError异常
直接内存在Java堆外，因此它的大小不会直接受限于-Xmx指定的最大堆大小，但是系统内存是有限的，Java堆和直接内存的总和依然受限于操作系统能给出的最大内存。
缺点：
-XX:MaxDirectMemorySize设置，如果不指定，默认与堆的最大值-Xmx参数值一致
/**
* 测试本地内存的OOM
* java.lang.OutOfMemoryError: Direct buffer memory
*/
public class DirectOOM {
private static final int BUFFER = 1024 * 1024 * 20;//20MB
public static void main(String[] args) {
ArrayList<ByteBuffer> list = new ArrayList<>();
int count = 0;
try {
while(true){
ByteBuffer byteBuffer = ByteBuffer.allocateDirect(BUFFER);
list.add(byteBuffer);
count++;
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
} finally {
System.out.println(count);
}
}
}
ByteBuffer.allocateDirect()方法中new DirectByteBuffer()中使用Unsafe类分配本地内存
/**
* -Xmx20m -XX:MaxDirectMemorySize=10m
* 设置最大堆内存20M，直接内存10M
*/
public class MaxDirectMemorySizeTest {
private static final long _1MB = 1024 * 1024;
public static void main(String[] args) throws IllegalAccessException {
Field unsafeField = Unsafe.class.getDeclaredFields()[0];
unsafeField.setAccessible(true);
Unsafe unsafe = (Unsafe) unsafeField.get(null);
while(true){
unsafe.allocateMemory(_1MB);
}
}
}