Java高级之内存模型分析

刘兆贤

已于 2023-12-18 10:54:50 修改

阅读量2.3k

点赞数 1

分类专栏： Java高级 Java底层探索文章标签： java 开发语言

于 2016-05-26 22:02:44 首次发布

本文链接：https://blog.csdn.net/reboot123/article/details/51507330

版权

Java高级同时被 2 个专栏收录

26 篇文章 0 订阅

订阅专栏

Java底层探索

17 篇文章 9 订阅

订阅专栏

需要了解基本变量所占内存大小，请移步：读书笔记-类结构的认识

Java存储空间有这么几块-来源于Java编程思想

寄存器：位于处理器内部，不受外层代码控制，由处理器自行分配-C/C++可以建议分配方式，使用句柄（包含引用类型和引用地址）来操作数据。

栈：位于RAM中，引用和基本数据类型存放的区块。

堆：位于RAM中对象存放的区块。指针向下生成新对象，向上释放对象（new关键字），相当于链表结构。

常量存储：位于ROM中存放于方法体中

非RAM存储：流对象和持久化数据-存储到硬盘。

JVM内存：分四块，栈、堆、方法区、程序计数器（CPU上下文切换后，要找到切换前的字节码行数）

说到存储就难免讲到JVM的垃圾回收机制，需要了解的同学可以点进去看看

如果要实现处理器的高效率，那么就要压榨它的每一寸（byte）的运行能力，I3的处理器达到3.4GHz，即每秒运算3.4亿次，因此给它划分任务块，每块分配足够多的任务，实现高并发；所以对内存的模型需要详细了解。

由于硬件的读写速度与处理器的运算速度差距过大，一般都会写一层高速缓存来作为缓冲，一边从硬盘读数据到缓存，一边把处理器的处理结果写入缓存，一边把缓存中要写入的数据写到硬盘；因此很多程序会使用到中间件。

如果多个处理器同时处理缓存，就需要拟定协议谁先谁后，对于同一个处理器中的任务也是同样如此，有sychronzied关键字来处理；同时处理器还会对一段程序丧心病狂的进行(OOOE)乱序处理，也就是顺序在前面的代码并不一定先执行，对于依赖前段程序结果的代码来说，就需要通过其他途径来保证顺序性。

sychronized关键字的原子性在于，顺序执行到这一句时，当前线程被挂起，执行完毕再唤醒。

有时见到一种单例的写法

		public Instance getInstance() {
			if (instance == null) {
				synchronized (Instance.class) {
					if (instance == null) {
						instance = new Instance();
					}
				}
			}
			return instance;
		}

这种的好处在于外层实现高性能并发，内层加if判断防止多个初始化同时进行（即第一个初始化完成，处理状态的其他线程再进去初始化一次）。

内存模型定义的关键在于第一使各处理器的操作不具有歧义第二不影响拓展各自的特性；它主要定义虚拟机存取数据的细节，定义所有变量都存储在主内存，每条线程都有自己的工作内存（主内存的副本，或者叫引用），不同线程的工作内存互不直接访问，通过主内存来影响各自对值的引用；拿虚拟机来做例子，寄存器、栈、堆缓存就像工作内存，硬件设备就是主内存。

定义了八种操作来完成上述存取过程

lock和unlock 作用于主内存，标识为某线程独占或释放，成对存在

read和load 读取和加载，从主内存将数据读给工作内存，再加载到工作内存，成对存在

use和assign 使用和赋值作用于工作内存，将变量给工作引擎，将接收到的值进行处理成对存在

store和write 存储和写入从工作内存将数据存回主内存，再写入主内存成对存在

顺序过程unlock放到write后面即可。不允许读不进工作内存，也不允许写不进主内存；新变量只能在主内存中产生，不能跳级执行，lock与unlock一样重复执行多次，只是每次lock工作内存则被清空。lock可类比为Java的Lock对象。

讲完上面的存取过程，变量的原子性就很好讲了，原子性指对变量的存取过程顺序执行，要么执行完，要么不执行，不允许其他线程对其进行污染。而带有特殊含义的sychronzied和final关键字，就可以用原子性来解释：前者由于保障了unlock之前变量已同步到主内存，这里的变量指方法体或类中所有的；后者是避免构造器把this引用传递出去，因而像惰性气体一样稳定。

另外java的先行发生原则，很有意思，有以下几种表现形式

1、程序控制流顺序执行，即代码顺序执行

2、volitale和锁顺序执行，即前一个锁执行结束，后一个得到锁

3、Thread的start方法先于run方法内的方法执行

4、通过isAlive、interrupt和join(B线程正在执行，A.join B，则先执行完A，再继续执行B)方法判断线程是否存活

   public final void join() throws InterruptedException {
        join(0);
    }

    public final synchronized void join(long millis)
    throws InterruptedException {
        long base = System.currentTimeMillis();
        long now = 0;

        if (millis < 0) {
            throw new IllegalArgumentException("timeout value is negative");
        }

        if (millis == 0) {
            while (isAlive()) {
                wait(0);
            }
        } else {
            while (isAlive()) {
                long delay = millis - now;
                if (delay <= 0) {
                    break;
                }
                wait(delay);
                now = System.currentTimeMillis() - base;
            }
        }
    }

默认join时，millis=0ms，指最长等待时间。如果这么长时间内，A仍没执行完，则B不再执行；默认为0时，则一定执行B。

	public static void main(String[] args) {
		final Thread thread1 = new Thread(new Runnable() {

			@Override
			public void run() {
				// TODO Auto-generated method stub
				for (int i = 0; i < 10; i++) {
					System.out.println("thread1:" + i);
				}
			}
		});
		final Thread thread2 = new Thread(new Runnable() {

			@Override
			public void run() {
				// TODO Auto-generated method stub
				for (int i = 0; i < 10; i++) {
					if (i == 5) {
						thread1.start();
						try {
							thread1.join();
						} catch (InterruptedException e) {
							// TODO Auto-generated catch block
							e.printStackTrace();
						}
					}
					System.out.println("thread2:" + i);
				}
			}
		});
		thread2.start();
	}

thread2:0
thread2:1
thread2:2
thread2:3
thread2:4
thread1:0
thread1:1
thread1:2
thread1:3
thread1:4
thread1:5
thread1:6
thread1:7
thread1:8
thread1:9
thread2:5
thread2:6
thread2:7
thread2:8
thread2:9

大家可以通过调整thread1的循环次数，和join的时长，来进行实验。

5、对象结束先于finilize方法执行

6、A先于B，B先于C，可得出A先于C执行的传递性。

最后再讲下volatile关键字，它有两个作用

1、保证改变后马上通知其他线程（执行write操作后，变量马上刷新），即对其他线程的可见性

2、保障上面所指丧心病狂的处理器处理此变量不被乱序操作，即禁止指令重排优化

但是volatile没有原子性（PS：原子性指read-assign-store这3组，只要一个执行，就会全部执行），不能保证作为计数器而正确存在；所以一般如果很少对它标识的变量进行改变的场景比较适用，比如多条线程共同执行多个有父类的任务，一个条件通知结束，则所有线程一起结束；就像劳动节来临，不论工程师还是设计师，都可以休息一天。

补充一点，64位的long和double无原子性，会被当成两个32位变量来处理，但一般默认为具有原子性，占用两个局部变量的位置

虚拟机运行时的数据区域有以下几种

虚拟机栈主要存放引用和基本数据类型

堆主要存放对象

方法区常见的类信息除对象以外的所有，包括类信息（数据类型），常量池，方法、接口、静态变量等

本地方法栈用来执行native方法

程序计数器存储下一条需要执行的字节码指令，每条线程都有一个

虚拟机的多线程是通过线程切换并分配执行时间，同时一个内核在任一时刻只处理一条线程的指令

虚拟机栈和堆是线程共享的数据区，方法区、本地方法栈和程序计数器是线程所不能访问到的数据区

其中数据访问的方式有两种：一种是句柄形式，引用指向句柄，句柄包含对象地址和对象类型；一种是指针，直接存储对象地址，以句柄少一步，所以访问也会快一些，而HotSpot就是用这种；前者也有一定优化，值发生改变时，引用不用变，后者要改变指针才行。

内存异常有三种表现：

一种叫OutOfMemoryError（内存不够），请求的虚拟机扩展栈已无足够空间（GCRoots过多，或者过长），分配给新对象，典型的标记-清理算法容易产品这种情况。

另一种叫StackOverFlow（栈溢出，在JDK1.5以后默认是1M,之前是256K，由虚拟机设置决定；Dalvik的寄存器空间是256K），指请求深度超过限制。在循环语句中，不断生成新对象，容易导致这种情况。

还有一种常见的Memory Leak(内存泄露)，指已经申请的内存无法被回收。

接下来对中英文分别占多少字节进行解释

public static void main(String[] args) {
String[] charsetNames = { "utf-8", "utf-16", "UTF-16BE", "UTF-16LE", "UTF-32", "UTF-32BE", "UTF-32LE", "unicode", "GBK", "GB2312", "GB18030",
"ISO8859-1", "BIG5", "ASCII" };

for (int i = 0; i < charsetNames.length; i++) {
printByteLength(charsetNames[i]);
}
}

/**
public static void printByteLength(String charsetName) {
* String类的不带参数的getBytes()方法会以程序所运行平台的默认编码方式为准来进行转换，
* 在不同环境下可能会有不同的结果，因此建议使用指定编码方式的getBytes(String charsetName)方法。
*/
String a = "a"; // 一个英文字符
String b = "啊"; // 一个中文字符
try {
System.out.println();
System.out.println(charsetName + "编码英文字符所占字节数:" + a.getBytes(charsetName).length);
System.out.println(charsetName + "编码中文字符所占字节数:" + b.getBytes(charsetName).length);
} catch (UnsupportedEncodingException e) {
System.out.println("非法编码格式！");
}
}

utf-8编码英文字符所占字节数:1
utf-8编码中文字符所占字节数:3

utf-16编码英文字符所占字节数:4
utf-16编码中文字符所占字节数:4

UTF-16BE编码英文字符所占字节数:2
UTF-16BE编码中文字符所占字节数:2

UTF-16LE编码英文字符所占字节数:2
UTF-16LE编码中文字符所占字节数:2

UTF-32编码英文字符所占字节数:4
UTF-32编码中文字符所占字节数:4

UTF-32BE编码英文字符所占字节数:4
UTF-32BE编码中文字符所占字节数:4

UTF-32LE编码英文字符所占字节数:4
UTF-32LE编码中文字符所占字节数:4

unicode编码英文字符所占字节数:4
unicode编码中文字符所占字节数:4

GBK编码英文字符所占字节数:1
GBK编码中文字符所占字节数:2

GB2312编码英文字符所占字节数:1
GB2312编码中文字符所占字节数:2

GB18030编码英文字符所占字节数:1
GB18030编码中文字符所占字节数:2

ISO8859-1编码英文字符所占字节数:1
ISO8859-1编码中文字符所占字节数:1

BIG5编码英文字符所占字节数:1
BIG5编码中文字符所占字节数:2

ASCII编码英文字符所占字节数:1
ASCII编码中文字符所占字节数:1

Linux默认可以存放100个进程，放1个跟99个是一样的，其他均为sleep状态，意思是已经开辟这么大内存，用还是不用，反正都在那里放着，不会浪费CPU时间，跟iOS一样，无需杀死后台进程。

String str1 = "hello";
String str2 = "hello";
System.out.println(str1 == str2); // 对象是否是同一个
System.out.println(str1.equals(str2)); // 字符串的话是可以直接相等，跟int等其他数据类型一样

String strObj1 = new String("hello");
String strObj2 = new String("hello");
System.out.println(strObj1 == strObj2);// 是否是同一个对象
System.out.println(strObj1.equals(strObj2));// 对象相等，因为char全相等

执行结果：

true
true
false
true

分析：拿String作为例子，其他容器类同样类似

    public boolean equals(Object anObject) {
        if (this == anObject) {
            return true;
        }
        if (anObject instanceof String) {
            String anotherString = (String)anObject;
            int n = value.length;
            if (n == anotherString.value.length) {
                char v1[] = value;
                char v2[] = anotherString.value;
                int i = 0;
                while (n-- != 0) {
                    if (v1[i] != v2[i])
                        return false;
                    i++;
                }
                return true;
            }
        }
        return false;
    }

首先判断是否是同一个对象，即两个引用指向同一个对象，那自然相等；

==判断两者的值相等（同一对象则值也相等）。

equals，先判断值是否相等；然后比较是否是同一种类型，如不等则返回false（int和Integer类型不相等），如相等则继续；

最后比较内部的值，String的char，List的value，Map的key和value，如果完全相等则相等。