匿名内存生命周期

最新推荐文章于 2024-06-21 19:22:45 发布
最新推荐文章于 2024-06-21 19:22:45 发布
阅读量283 收藏
点赞数
分类专栏： linux 文章标签： linux kernel malloc
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/ltuse_csdn/article/details/77152641
版权 
 

 
 
前文再接，现在来说说，linux操作系统的内存管理部分. 当然， 这里主要是描述匿名内存部分
 

 

内存简介
 

 
 
可能有一种误解，内存申请完之后，在初始化之前是匿名内存，初始化后就不是了。但是对于内核而言，这是错误的。
 
 
某位作者
 

 

内存映射可以分成两类src，匿名内存映射和文件内存映射。简单而言，有文件作为备份的内存都是作为文件内存映射,没有则是匿名内存映射。
 

我们常用的malloc申请的内存显然就是匿名内存。下面主要讲述我们是怎么linux内核交互来获取和释放这些内存的。
 

申请
 

对于linux而言，一般都是使用malloc来进行申请。当然也有一些所谓的自己的设计，但是都是通过系统调用do_brk进行内存申请。
 

当然，这里的”申请“，并不是直接获得内存。而只是打出申请。虽然会通过，但系统不一定给的。只是一张信用不明的支票。
 

do_brk通过扩充申请程序的vma，malloc中是堆空间，或者说是虚地址范围。让程序能够访问这些虚拟地址。意味着当你需要的时候可以去银行找柜员。
 

初始化
 

当你尝试第一次访问这些申请好内存的时候，会触发缺页中断，进入linux内核来进行处理。
 

do_page_fault会首先检查进程对应的mm包含的vma的范围，也就是程序中打好申请的虚地址是否包含当前尝试访问的页。如果发现这是一张”假支票“ 越界访问，将直接报错结束进程，也就是segment fault。
 

而正常情况下，将构造结构体struct vm_fault然后最终进入handle_pte_fault进行处理。对于我们当前状态，因为还没有初始化，连pte都不存在，自然进入do_anonymous_page进行处理。
 

里面将申请一个空闲页面并挂接映射，设置pte。这个时候程序就能够正常访问这个内存页了。
 

退出，告辞。
 

 

交换
 

这里，可以参考上一篇文章里面有一个大概的介绍。
 

 

退出
 

 
 
那这个内存怎么返回到系统中呢？
 

 

主动调用munmap或者程序退出的时候统一释放。
 

 

munmap主要是对vma的范围进行限制，跟do_brk相反。
 

程序退出，是通过调用do_exit实现的。里面会调用exit_mm最终会遍历vma，对虚地址映射的所有页面进行释放。内存最终回到操作系统。
 

 

 

其他
 

可能有小伙伴，问了，那具体是怎么进行映射，解除映射，系统怎么分配内存和回收内存呢？
 

敬请期待后续：
 

内存映射二三
 

内存收发
 

 

引流之主
 

点点收藏我(作者)的个人博客, 获取第一时间的更新呀~
 

如果对什么内容感兴趣，也可以跟我交流、催更~
 

不定时更新哦~
 

 

参考资料
 

linux-4.11.0代码
 

《奔跑吧！linux内核》
 

《计算机体系结构》胡伟武
 

 


                

        

    

  



    


                



	

		

			

				
					
Android四大组件：Activity详解（一）基础概念与生命周期

				
			

			

				

					Ya-Jun 的博客
				

				

					03-08
					
					202
					
				

			

		

		

			
				
Activity是Android应用程序的核心组件之一，它提供了一个用户界面，让用户可以与应用程序进行交互。从用户体验的角度来看，Activity就像是应用程序的"窗口"或"页面"。一个Android应用通常由多个Activity组成，它们之间可以相互跳转，共同构成了应用的用户界面流程。Activity的生命周期是指从创建到销毁的整个过程，Android系统通过一系列回调方法来管理Activity的生命周期。了解这些生命周期方法对于开发高质量的Android应用至关重要。onCreate()

			
		

	



                

            
              



	

		

			

				
					
C++异常变量的生命周期，以及可能会遇到的坑

				
			

			

				

					u010632547的博客
				

				

					04-22
					
					1457
					
				

			

		

		

			
				
先看如下代码


class MyException
{
public:
	MyException()
	{
		cout << "MyException的默认构造" << endl;
	}
	MyException(const MyException & e)
	{
		cout << "MyException的拷贝构造" << endl;...

			
		

	



              


  
              

                


	

		

			

				
					
由匿名内存看swap分区

				
			

			

				

					云计算?
				

				

					02-02
					
					233
					
				

			

		

		

			
				
 看代码的时候，从能看到通过mmap映射一段匿名内存，但是为什么非要映射一段匿名内存呢，匿名内存到底是干啥用的？对这个问题一直不解，今天google了很多资料，总结一下自己理解的内容。
 1 匿名内存的定义
 匿名内存是指那些在文件系统里没有相对应的”储备文件“的那些内存，堆和栈空间的内存都属于匿名内存。
2 匿名内存的用途
 匿名内存来源于交换分区，即linux下的swap分区。
 S...

			
		

	





	

		

			

				
					
java 匿名内部类生命周期_java 匿名内部类

				
			

			

				

					weixin_39927144的博客
				

				

					03-02
					
					966
					
				

			

		

		

			
				
匿名内部类的创建形式：new 父类构造器(参数列表)| 实现接口(){}匿名内部类必须要继承一个父类或者实现一个接口。当父类是抽象类或者接口时，匿名内部类需要实现所有的抽象方法并且不能定义构造函数，由编译器自动生成。匿名内部类仅仅能够被使用一次，创建匿名内部类时他会立即创建一个该类的实例，该类的定义会立即消失，不能被重复使用。方法的形参被内部类使用时，该形参必须为final！，为何？？内部类在编译...

			
		

	



		

			
		



	

		

			

				
					
匿名对象的生命周期

				
			

			

				

					蜀沐的博客
				

				

					11-09
					
					649
					
				

			

		

		

			
				
1、匿名对象想的生命周期
class  ABCD
{
   public:
         ABCD(int _a,in t_b)
       {
            a=_a;
             b=_b
           cout<<"ABCD的构造函数"<<endl;
      }
    ~ ABCD()
       {
           cout<<"ABCD的析构函数"<<endl;
      }
private：
 

			
		

	





	

		

			

				
					
匿名内存

				
			

			

				

					知了112的专栏
				

				

					07-18
					
					2960
					
				

			

		

		

			
				
1,匿名内存的概念


匿名内存是指那些在文件系统里没有相对应的”储备文件“的那些内存，堆和栈空间的内存都属于匿名内存。

匿名内存的用途：当一个程序很久没有运行的时候，需要要将程序占用的堆 栈交换到swap分区，而程序打开的文件则不需要放到swap分区，因为打开的文件直接可以放到其文件系统，swap分区还包括堆栈中的一些状态和变量数据等










2,A

			
		

	





	

		

			

				
					
3.1_15 JavaSE入门 P14 【多线程】同步、匿名内部类、死锁、生命周期

				
			

			

				

					GroupiesM的博客
				

				

					05-18
					
					4135
					
				

			

		

		

			
				
JavaSE入门  P14 【进阶】多线程、同步、匿名内部类、死锁、生命周期
1.概述
2.多线程实现（模拟卖票）
3.多线程安全问题&解决方案
4.匿名内部类
5.同步
6.死锁，多线程生命周期
7.面试题

			
		

	





	

		

			

				
					
Activity生命周期管理

				
			

			

				

					08-17
				

			

		

		

			
				
Activity的生命周期管理是Android开发中的核心概念，对于确保应用程序的稳定性和性能至关重要。本知识点主要聚焦于如何高效地管理和控制Activity的生命周期。  Activity的生命周期包括了创建（onCreate()）、启动...

			
		

	





	

		

			

				
					
30、Go语言揭秘：变量作用域与生命周期深度解析

				
			

			

				

					silenceallat的博客
				

				

					06-21
					
					770
					
				

			

		

		

			
				
本文深入解析了Go语言中变量的作用域与生命周期，通过理论阐述与实战案例相结合的方式，让读者掌握了如何合理使用变量作用域和生命周期，以提高代码的可读性、可维护性，并避免潜在的编程错误。文章强调了理解这两个概念对于编写清晰和高效的Go代码至关重要。

			
		

	





	

		

			

				
					
Linux mmap读/写触发共享文件页生命周期

				
			

			

				

					GetnextWindow的专栏
				

				

					09-11
					
					507
					
				

			

		

		

			
				
Linux的mm内存子系统的核心功能就要要管理各种类型的page，确保能高效分配和释放，让物理内存得以最大化使用。初识内存系统往往关注的是page的申请和管理流程，容易忽略page的释放回收流程，其实理解mm中的内存回收和释放也是最核心的机制。

			
		

	





	

		

			

				
					
内部类，匿名内部类

				
			

			

				

					liuxiaohui_dh的专栏
				

				

					01-27
					
					484
					
				

			

		

		

			
				
内部类：
概念：(自己想到的)
内部类是一种可以直接访问外部类的一类事物
 
内部类访问外部类中的成员，包括私有。
之所以可以访问外部类的成员，是因为内部类持有了外部类的一个引用，
格式为：Outer.this.x
外部类访问内部类成员，需要声明内部类的对象。

其他类访问内部类方法：
当内部类处在成员变量的位置时，就可以被其他的类访问到。
格式：
Outer.Inner 

			
		

	





	

		

			

				
					
Linux内存管理之匿名内存

				
			

			

				

					蓝蓝的天空专栏
				

				

					08-20
					
					494
					
				

			

		

		

			
				
在通常情况下，匿名内存规定了程序能够访问的虚拟内存域。当读取数据时，会创建一个匿名页表的对象（），该对象映射到一块空白物理内存页面（被格式化，填满0）。当执行写操作时，数据被写入到与之匹配物理内存页面中。匿名页面将被定义为脏页，脏页能够被系统回收复用。匿名内存的创建方式有两种，一种是通过程序的堆或栈来创建；另一种方式是通过系统调 用来产生（如系统间的请求、接收网络数据、发送数据等）。匿名内存又叫匿名映射，是指内存中的数据并不来自系统文件的内存。

			
		

	





	

		

			

				
					
匿名内存 | shm

				
			

			

				

					weixin_30650039的博客
				

				

					04-24
					
					288
					
				

			

		

		

			
				
page_is_file_cache是和ｓｗａｐｂａｃｋｅｄ互斥的，所以说对于匿名页来说，分配的时候就就会把PageSwapBacked给设置上，page->mapping_address = 0x1
swap_backed和page->mapping_address貌似是重复的呢？感觉swapbacked是page->mapping_adddres超集。
今天和公司的内存管...

			
		

	





	

		

			

				
					
内部类详解————匿名内部类

				
			

			

				

					Morty的技术乐园
				

				

					05-05
					
					2913
					
				

			

		

		

			
				
内部类三连击：

《内部类详解————匿名内部类》

《内部类详解————局部内部类》

《内部类详解————静态嵌套类》

应用场景

由于匿名内部类不利于代码的重用，因此，一般在确定此内部类只会使用一次时，才会使用匿名内部类。

形式


public class OutterClass {
    public Runnable task() {
        return new Run...

			
		

	





	

		

			

				
					
java匿名内部类详解

				
			

			

				

					菜到怀疑人生的博客
				

				

					02-06
					
					7854
					
				

			

		

		

			
				
匿名内部类，顾名思义，就是没有名字的类，匿名内部类格式如下：

new name（parameter）
{
   ......
}

name：父类或是接口的名字。

parameter：若name为父类，则parameter为父类构造函数的参数。


匿名内部类具有一系列的限制，原因待会解释：
1、不能具有static成员域和成员函数和类。
2、不能具有static fin

			
		

	





	

		

			

				
					
Android 匿名内存解析

				
			

			

				

					Arthas的博客
				

				

					10-20
					
					875
					
				

			

		

		

			
				
有了binder机制为什么还需要匿名内存来实现IPC呢？我觉得很大的原因就是binder传输是有大小限制的，不说应用层的限制。在驱动中binder的传输大小被限制在了4M，分享一张图片可能就超过了这个限制。匿名内存的主要解决思路就是通过binder传输文件描述符，使得两个进程都能访问同一个地址来实现共享。

			
		

	





	

		

			

				
					
Android 匿名内存深入分析

				
			

			

				

					Dream It Possible
				

				

					11-23
					
					1522
					
				

			

		

		

			
				
共享简单的实现方式就是通过mmap同一个文件来实现。但是真实文件的读写速度实在是太慢了，所以利用tmpfs这个虚拟文件系统，创建了一个虚拟文件来读写。同时这块虚拟内存在上面也写到重写了vm_ops。当有进程操作这个虚拟内存的时候会触发缺页错误，接着会去查找Page缓存，由于是第一次所以没有缓存，读取物理内存，同时加入Page缓存，当第二个进程进来的时也触发缺页错误时就能找到Page缓存了，那么他们操作的就是同一块物理内存了。看完之后发现AshMemory是基于Linux的共享内存实现的。做了几点改造。

			
		

	





	

		

			

				
					
Android 匿名共享内存基础数据结构篇（二）

				
			

			

				

					camel@Y blog
				

				

					03-04
					
					803
					
				

			

		

		

			
				
Android匿名共享内存系统架构图

如上图所示，Android系统匿名共享内存（以下以Ashmem代替）以Ashmem驱动为基础，在运行时库提供了cutils library来对Ashmem驱动进行访问，同时又在Framework层提供了C++和Java类接口来访问cutils。

 这篇文章主要学习kernel层ashmem的基础数据结构，先来看看Ashmem到底是什么！源码版本An...

			
		

	





	

		

			

				
					
linux内存管理笔记(三十四）----匿名映射

				
			

			

				

					奇小葩
				

				

					01-03
					
					7128
					
				

			

		

		

			
				
匿名内存是用户空间的概念，不涉及内核态内存。匿名内存的概念是指一段虚拟内存映射是否与之相关联的对象，如果没有关联对象就称为匿名的。本章就主要学习缺页异常的匿名映射，其中涉及到以下内容

匿名映射的概念
匿名映射的流程

1. 概念
由于应用程序申请内存后，内核分配了虚拟内存，当访问所需要的的内存时候，才会分配实际的物理内存，才能节省实际内存的使用。我们来看看匿名映射和文件映射的区别

匿名页面，是指那些没有关联到文件页，如进程堆、栈、数据段和任务已修改的共享库等，不是以文件形式存在，因此无法和磁盘文件交换


			
		

	





	

		

			

				
					
成员函数的线程生命周期

					
最新发布

				
			

			

				

					03-18
				

			

		

		

			
				
<think>好的，我现在需要回答用户关于成员函数在线程环境中的生命周期和管理方式的问题，涵盖C++、Java和Python，同时要考虑调用行为、并发和安全性。首先，我需要分别整理这三个语言中成员函数在线程中的处理方式。

对于C++，线程通常使用std::thread创建，成员函数作为线程入口时需要绑定对象实例。要确保对象的生命周期长于线程，避免悬空引用。可以使用智能指针如shared_ptr来管理对象生命周期。此外，thread_local变量和互斥锁（如std::mutex）用于处理线程安全和数据隔离。记得提到detach()和join()的区别，detach后线程在后台运行，主线程不再等待，但需要谨慎使用以免资源泄漏。

在Java中，线程通过实现Runnable或继承Thread类来创建。成员函数作为线程任务时，需注意对象实例的有效性。使用synchronized关键字或Lock接口来保证并发安全。Java的垃圾回收机制会自动管理对象生命周期，但要避免在线程中持有对象的强引用导致无法回收。可以引用用户提供的关于sleep()和wait()方法的区别，特别是wait()会释放锁，而sleep()不会。

Python方面，由于GIL的存在，多线程在CPU密集型任务中效率不高，但在IO密集型任务中有效。使用threading模块创建线程，成员函数作为目标函数时，同样需要注意对象生命周期。由于Python是动态语言，需确保在线程运行期间对象未被意外修改或销毁。并发安全可通过Lock来实现，同时考虑使用队列（Queue）进行线程间通信。需要提到Python解释型语言的执行效率问题，以及可能的优化方法如Cython，引用用户提供的资料[^4]。

接下来要比较各语言的特点：C++需要显式管理对象和线程的生命周期，Java依赖垃圾回收但需注意线程安全，Python受GIL限制但编码简单。并发安全性方面，三者都需要同步机制，但实现方式不同。生命周期管理上，C++更手动，Java和Python更自动，但各有注意事项。

最后生成相关问题，覆盖各语言的生命周期管理、线程安全方法、优缺点比较以及实际应用场景。确保引用用户提供的参考资料，如[^1]关于sleep和wait的区别，[^2]关于detach()，[^3]关于thread_local，[^4]关于Python的执行效率。

检查是否符合用户的要求：使用正确的中文，行内公式用$...$，独立公式用$$...$$，虽然当前问题可能不涉及数学公式，但需注意如果有的话。引用标识是否正确添加，如关于sleep和wait的部分引用，detach()引用，thread_local引用[^3]，Python效率引用。确保回答结构清晰，分语言阐述，比较总结，相关问题相关且覆盖不同方面。</think>### 成员函数在线程环境中的生命周期与管理方式

#### 1. C++ 中的实现与行为
在 C++ 中，成员函数作为线程入口时，需通过绑定对象实例来调用。例如：
```cpp
class MyClass {
public:
    void memberFunc() { /* 线程任务 */ }
};

MyClass obj;
std::thread t(&MyClass::memberFunc, &obj);
```
- **生命周期管理**：必须确保对象 `obj` 的生命周期覆盖线程执行时间。若对象被提前销毁，会导致未定义行为。可通过 `std::shared_ptr` 管理对象生命周期[^3]。
- **并发安全性**：需使用互斥锁（如 `std::mutex`）保护共享数据，避免竞态条件。
- **线程局部存储**：通过 `thread_local` 关键字声明变量，每个线程拥有独立副本，适用于线程特定的数据存储[^3]。

#### 2. Java 中的实现与行为
在 Java 中，成员函数通常通过实现 `Runnable` 接口或继承 `Thread` 类来启动线程：
```java
class MyRunnable implements Runnable {
    public void run() { /* 线程任务 */ }
}

MyRunnable task = new MyRunnable();
Thread thread = new Thread(task);
thread.start();
```
- **生命周期管理**：线程对象的生命周期由 JVM 垃圾回收机制管理，但需注意线程执行期间对象被引用的风险（如匿名内部类隐式持有外部类引用）。
- **并发安全性**：使用 `synchronized` 关键字或 `ReentrantLock` 实现同步。注意 `wait()` 方法会释放锁，而 `sleep()` 不会[^1]。
- **线程分离**：Java 不提供显式的 `detach()` 方法，主线程需通过 `join()` 等待子线程结束。

#### 3. Python 中的实现与行为
在 Python 中，成员函数可通过 `threading` 模块启动线程：
```python
import threading

class MyClass:
    def member_func(self):
        pass

obj = MyClass()
thread = threading.Thread(target=obj.member_func)
thread.start()
```
- **生命周期管理**：Python 的线程生命周期由解释器管理，但需注意全局解释器锁（GIL）对多线程性能的限制，尤其在 CPU 密集型任务中。
- **并发安全性**：使用 `threading.Lock` 保护共享资源，或通过队列（`queue.Queue`）实现线程间通信。
- **执行效率**：Python 线程适用于 I/O 密集型任务，若需高性能计算，可结合多进程或 Cython 优化。

---

### 语言特性对比
| 特性                | C++                      | Java                    | Python                  |
|---------------------|--------------------------|-------------------------|-------------------------|
| **生命周期管理**    | 需显式控制对象生命周期  | 依赖垃圾回收机制        | 自动管理，受 GIL 限制   |
| **线程安全机制**    | `std::mutex`, `atomic`   | `synchronized`, `Lock`  | `threading.Lock`        |
| **性能特点**        | 高效，手动内存控制       | 平衡，依赖 JVM 优化     | 低效于 CPU 密集型任务   |
| **线程局部存储**    | `thread_local`[^3]       | `ThreadLocal` 类        | `threading.local()`     |

---

### 安全性建议
1. **避免悬空引用**（C++）：使用智能指针管理对象。
2. **释放锁**（Java）：优先用 `wait()` 而非 `sleep()` 以释放锁资源。
3. **分离线程**（C++）：谨慎使用 `detach()`，可能导致资源泄漏。
4. **GIL 限制**（Python）：多线程适合 I/O 任务，多进程适合计算任务。

---

			
		

	



              




          




        



    





    



      

      

        
      

      





	

		评论	
	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

                
 1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
 2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

              

            

          

      

      余额充值