Stack on pipo's site

RuntimeDataArea

Thu, 25 Sep 2025 00:00:00 +0000

Java Virtual Machine Stacks

是一块内存区域,用于存放存放单个线程的数据如方法和局部变量,一个Stack里有多个Stack Frame.

更大的栈内存设置不会提高效率，会减少最大同时运行线程数量
栈内存可固定也可以动态变化
static变量可以被多个线程同时调用，需要考虑线程安全
私有局部变量只存在在该栈内只能被这个栈调用，通常认为是安全的。
当局部变量发生Escape时，不再线程安全，如参数传递，返回值泄露
即使没有递归也有可能发生StackOverFlow,比如循环引用.

Heap

最大的一块内存空间,被所有线程共享,存放着大部分的对象实例,就是new出来的对象.

Heap分为三大类,新生区,老年区和元空间(永久代).

Young Generation

新生代由Eden和两组Survivor空间组成,通常eden要远大于Survivor区域,而Survivor中s0 : s1 == 1 : 1

当有新的对象加入 Heap 时通常首先进入 Eden.
当发生 [[GC(Garbage Collectors)#^Young GC|Young GC]] 时Eden尝试会将Eden和 s1/s0 中全部对象移入s0或s1,并给这些对象年龄加1
当对象进行多次 GC 后年龄达到阈值会被移入** Old Generation **
如果新加入的对象过大会直接进入 Old Generation
Survivor Space的 from 和 to 指的是在复制整理对象时的原位置和复制位置.

Old Generation

老年代存放着大对象和长期存活的对象

大对象就是需要大量连续内存空间的对象（比如：字符串、数组）。

大对象直接进入老年代的行为是由虚拟机动态决定的，它与具体使用的垃圾回收器和相关参数有关。大对象直接进入老年代是一种优化策略，旨在避免将大对象放入新生代，从而减少新生代的垃圾回收频率和成本。

当对象经历过多次 Young GC 依旧存活达到阈值(通常是15/8) 将被移入 Old Generation.

Method Area

是JVM运行时内存结构中的一块区域, 被所有JVM线程共享, 存储每个类的结构信息.

run-time constant pool, field and method data, and the code for methods and constructors, including the special methods used in class and interface initialization and in instance initialization.

StirngTable

StringTable(String Pool) 在Java7之前存放在 ConstantPool,之后Method Area移动到本地内存实现,但是 StringTable 依旧在堆中.

String 存放在 StringTable中,是不可变对象,能够被多个对象引用.

String s1 = "a";
String s2 = "b";

String s3 = s1 + s2; 
//StirngBuilder().append(s1).append.(s2).toString(); new String("ab");

String s4 = "ab"

// s3 != s4

String s5 = "a" + "b"
//s4 == s5

因为s3 相当于new了一个新对象存储,所以存储在堆中.

而s4则是存储在 StringPool 当中.

两者指向的对象不同, 而 == 是比较的引用地址,所以flase

如果使用.equals() 就相同.

在拼接s5时编译器进行优化,直接从StringPool找到 a b 进行拼接,发现结果是已有的 ab,

于是直接指向ab.

intern方法 1.8

调用字符串对象的 intern 方法，会将当前**堆中字符串对象的引用注册**到串池中

检查字符串常量池中是否已存在该字符串
如果不存在，则将当前堆中字符串对象的引用注册到字符串常量池中
如果存在，直接返回池中的引用,不更新引用.

public class Main {
	public static void main(String[] args) {
		// "a" "b" 被放入串池中，str 则存在于堆内存之中
		String str = new String("a") + new String("b");
		// 调用 str 的 intern 方法，这时串池中没有 "ab" ，则会将堆中字符串对象的引用注册到串池，此时堆内存与串池中的 "ab" 是同一个对象
		String st2 = str.intern();
		// 给 str3 赋值，因为此时串池中已有 "ab" ，则直接将串池中的内容返回
		String str3 = "ab";
		// 因为堆内存与串池中的 "ab" 是同一个对象，所以以下两条语句打印的都为 true
		System.out.println(str == st2);
		System.out.println(str == str3);
	}
}

Native Method Stack

PC Register

Escape

public static StringBuffer craeteStringBuffer(String s1, String s2) {
   StringBuffer sb = new StringBuffer();
   sb.append(s1);
   sb.append(s2);
   return sb;
}

创建的局部变量 sb 通过return方法传递,将sb脱离了自己掌控,线程逃逸.

来源

JVM 基础 - JVM 内存结构

21_堆_内存诊断_jvirsualvm_哔哩哔哩_bilibili

Chapter 2. The Structure of the Java Virtual Machine

JVM垃圾回收详解（重点）

Stack 基础总结

Sun, 29 Sep 2024 00:00:00 +0000

栈

栈(Stack)属于线性数据结构，它遵循着先进后出(FILO)原则,就像是在杠铃上的杠铃片，要想拿到最开始放进去的片必须把在它之后的所有杠铃片全部弹出(pop),而每次加新片只能在末尾压入(push),通常我们把最后一个入栈元素的位置叫做`栈顶`,最先入栈的元素叫做`栈底`.

栈的实现

在CPP中有内置的栈包含在stack头文件中，但这里我们分别用数组和链表来模拟栈的基本功能。

基于数组的实现方式

class Stack{
    private:
        std::vector<int> st;
        
    public: 
        //获取栈的大小
        int getSize(){
            return st.size();
        }

        //检查是否为空
        bool isEmpty(){
            return st.empty();
        }

        //返回栈顶元素
        int peek(){
            if (isEmpty()) throw std::out_of_range("栈为空");
            return st.back();        
        }

        //添加元素
         void push(int val){
            st.push_back(val);
         }

         //弹出元素
         void pop(){
            if (isEmpty()) throw std::out_of_range("栈为空");
            st.pop_back();
         }


};

基于链表的实现方式

class Stack{
    private:
        Node* st;
    
    public:

        Stack() : st(nullptr) {} 

    // 析构函数，防止内存泄漏
    ~Stack() {
        while (!isEmpty()) {
            pop(); 
        }
    }
        //获取栈的大小
        int getSize(){
            Node* tmp = st;
            int size;
            for(size = 0; tmp != nullptr; size++){
                tmp = tmp->next;
            }
            return size;
        }

        //检查是否为空
        bool isEmpty(){
            if(st == nullptr) return true;

            else return false;
        }

        //返回栈顶元素
        int peek(){
            if (isEmpty()) throw std::out_of_range("栈为空");
            return st->val;        
        }

        //添加元素
        void push(int val){
            Node* nd = new Node(val);
            nd->next = st;
            st = nd;
            
         }
        

         //弹出元素
         void pop(){
            if (isEmpty()) throw std::out_of_range("栈为空");
            auto tmp = st->next;
            delete st;
            st = tmp;
         }


};

Node的详细实现详见链表,此处只简单实现。

class Node{
	public:
		int val;
		Node* next;
		Node(int value): val(value), next(nullptr) {}
}

值得注意的是此处新元素的插入与链表直接在尾部插入不同，而是在头部插入，并将新的节点作为头节点。

*两种实现的对比

支持操作

两种实现都支持栈定义中的各项操作。数组实现额外支持随机访问，但这已超出了栈的定义范畴，因此一般不会用到。

时间效率

在基于数组的实现中，入栈和出栈操作都在预先分配好的连续内存中进行，具有很好的缓存本地性，因此效率较高。然而，如果入栈时超出数组容量，会触发扩容机制，导致该次入栈操作的时间复杂度变为 O(n) 。

在基于链表的实现中，链表的扩容非常灵活，不存在上述数组扩容时效率降低的问题。但是，入栈操作需要初始化节点对象并修改指针，因此效率相对较低。不过，如果入栈元素本身就是节点对象，那么可以省去初始化步骤，从而提高效率。

综上所述，当入栈与出栈操作的元素是基本数据类型时，例如 int 或 double ，我们可以得出以下结论。

基于数组实现的栈在触发扩容时效率会降低，但由于扩容是低频操作，因此平均效率更高。

基于链表实现的栈可以提供更加稳定的效率表现。

空间效率

在初始化列表时，系统会为列表分配“初始容量”，该容量可能超出实际需求；并且，扩容机制通常是按照特定倍率（例如 2 倍）进行扩容的，扩容后的容量也可能超出实际需求。因此，基于数组实现的栈可能造成一定的空间浪费。

然而，由于链表节点需要额外存储指针，因此链表节点占用的空间相对较大。

综上，我们不能简单地确定哪种实现更加节省内存，需要针对具体情况进行分析。

栈相关练习题

二叉树的迭代法进行前中后序遍历