直接赋值 null 会将将 $a 所指向的内存区域置空，并将引用计数归零，内存便被释放。

脚本执行结束

PHP是脚本语言，当脚本执行结束之后，脚本内使用的所有内存都会被释放。

c# 的析构以及垃圾回收2、3事！

看书时，自己写的例子代码，了解到几个知识点，记载下来。同时发现自己手写代码的能力比较弱，还是得多写一下。

using System;
namespace ConsoleApplication
{
    public class Program
    {
        public static void Main(string[] args)
        {
            Console.WriteLine("Hello World!");
            fun();
            GC.Collect();                               //4、若不显式回收，则控制台不打印回收行。
            Console.WriteLine("end!");
        }
        public static void  fun(){                        //1、此处必须有static
            A a=new A();
            a.Dispose();
            //GC.Collect();                              //3、此处回收无效，因为a还没释放
        }
        public class A:IDisposable{
          /*  protected override void Finalize(){         //2、析构实际是重载Finalize，但不能直接写重载。编译器自动重写Finalize，所以代码中，只能用  析构函数。       
                 Console.WriteLine("some one disposed!");
            }*/
             ~A(){
                 Console.WriteLine("some one Finalize!");
            }
            public void Dispose(){
                 Console.WriteLine("some one disposed!");
            }
        }
    }
}

5、该代码的输出为：

Hello World!                                                                                 
some one disposed!                                                                              
end!                                                                                            
some one Finalize!  

这个回收像极了异步调用！ 

6、IDisposable接口的Dispose方法，目的是“不用户不再使用对象时，要手工调用它”
比如文件打开，数据库访问等。需要及时释放。
明显这个概念和垃圾回收是两个概念。释放后，该对象仍然存在，有待运行环境来回收，见最后一行。

C# 的析构以及垃圾回收实例分析

C# 的析构以及垃圾回收实例分析

看书时，自己写的例子代码，了解到几个知识点，记载下来。同时发现自己手写代码的能力比较弱，还是得多写一下。

using System;
namespace ConsoleApplication
{
  public class Program
  {
    public static void Main(string[] args)
    {
      Console.WriteLine("Hello World!");
      fun();
      GC.Collect();                //4、若不显式回收，则控制台不打印回收行。
      Console.WriteLine("end!");
    }
    public static void fun(){            //1、此处必须有static
      A a=new A();
      a.dispose();
      //GC.Collect();               //3、此处回收无效，因为a还没释放
    }
    public class A:Idisposable{
     /* protected override void Finalize(){     //2、析构实际是重载Finalize，但不能直接写重载。编译器自动重写Finalize，所以代码中，只能用 析构函数。    
         Console.WriteLine("some one disposed!");
      }*/
       ~A(){
         Console.WriteLine("some one Finalize!");
      }
      public void dispose(){
         Console.WriteLine("some one disposed!");
      }
    }
  }
}

1、该代码的输出为：

Hello World!                                         
some one disposed!                                       
end!                                              
some one Finalize! 

这个回收像极了异步调用！

2、Idisposable接口的dispose方法，目的是“不用户不再使用对象时，要手工调用它”
比如文件打开，数据库访问等。需要及时释放。

明显这个概念和垃圾回收是两个概念。释放后，该对象仍然存在，有待运行环境来回收，见最后一行。

感谢阅读，希望能帮助到大家，谢谢大家对本站的支持！

flash垃圾回收机制，内存泄漏的常见情况及内存释放优化的原则

Java 内存分配及垃圾回收机制初探

一、运行时内存分配

Java虚拟机在执行Java程序的过程中会把它所管理的内存划分为若干个不同的数据区域。
这些区域都有各自的用途，以及创建和销毁的时间，有的区域随着虚拟机进程的启动而存在，有些区域则依赖用户线程的启动和结束而建立和销毁。

线程私有区域（生命周期与线程相同）

a) 虚拟机栈

虚拟机栈描述的是Java方法执行的内存模型：每个方法在执行的同时都会创建一个栈帧（Stack Frame[1]）用于存储局部变量表、 操作数栈、 动态链接、 方法出口等信息。 每一个方法从调用直至执行完成的过程，就对应着一个栈帧在虚拟机栈中入栈到出栈的过程。

虚拟机栈中有一个局部变量表，存放了编译期可知的各种基本数据类型（boolean、 byte、 char、 short、 int、float、 long、 double）、 对象引用（reference类型，它不等同于对象本身，可能是一个指向对象起始地址的引用指针，也可能是指向一个代表对象的句柄或其他与此对象相关的位置）和returnAddress类型（指向了一条字节码指令的地址）。

b）本地方法栈

本地方法栈（Native Method Stack）与虚拟机栈所发挥的作用是非常相似的，它们之间的区别不过是虚拟机栈为虚拟机执行Java方法（也就是字节码）服务，而本地方法栈则为虚拟机使用到的Native方法服务。

c） 程序计数器

由于Java虚拟机的多线程是通过线程轮流切换并分配处理器执行时间的方式来实现的，在任何一个确定的时刻，一个处理器（对于多核处理器来说是一个内核）都只会执行一条线程中的指令。 因此，为了线程切换后能恢复到正确的执行位置，每条线程都需要有一个独立的程序计数器，各条线程之间计数器互不影响，独立存储，我们称这类内存区域为“线程私有”的内存。

共享数据区

a）堆

对于大多数应用来说，Java堆（Java Heap）是Java虚拟机所管理的内存中最大的一块。Java堆是被所有线程共享的一块内存区域，在虚拟机启动时创建。 此内存区域的唯一目的就是存放对象实例，几乎所有的对象实例都在这里分配内存。

根据Java虚拟机规范的规定，Java堆可以处于物理上不连续的内存空间中，只要逻辑上是连续的即可，就像我们的磁盘空间一样。 在实现时，既可以实现成固定大小的，也可以是可扩展的，不过当前主流的虚拟机都是按照可扩展来实现的（通过-Xmx和-Xms控制）。

b）方法区

方法区（Method Area）与Java堆一样，是各个线程共享的内存区域，它用于存储已被虚
拟机加载的类信息、 常量、 静态变量、 即时编译器编译后的代码等数据。

相对而言，垃圾收集行为在这个区域是比较少出现的，但并非数据进入了方法区就如永久代的名字一样“永久”存在了。 这区域的内存回收目标主要是针对常量池的回收和对类型的卸载，一般来说，这个区域的回收“成绩”比较难以令人满意，尤其是类型的卸载，条件相当苛刻，但是这部分区域的回收确实是必要的。

Java对象创建过程

a） 虚拟机遇到一条new指令时，首先将去检查这个指令的参数是否能在常量池中定位到一个类的符号引用，并且检查这个符号引用代表的类是否已被加载、 解析和初始化过。 如果没有，那必须先执行相应的类加载过程。

b) 为对象分配内存（对象所需内存大小在类加载完成后便完全确定），对象所需内存的大小在类加载完成后便可完全确定（如何确定将在2.3.2节中介绍），为对象分配空间的任务等同于把一块确定大小的内存从Java堆中划分出来。

二、垃圾对象判定

1. 引用计数法

每个对象都有一个引用计数的属性，用来保存该对象被引用的次数。当引用次数为0时，就意味着该对象没有被引用了，也就不会在使用这个对象了，可以判定为垃圾对象。但是，这种方式有一个很大的Bug，就是无法解决对象间相互引用或者循环引用的问题：当两个对象相互引用，他们两个和其他任何对象也没有引用关系，它俩的引用次数都不为0，因此不会被回收，但实际上这两个对象已经不再有用了。

2. 可达性分析（根搜索法）

在主流的商用程序语言（Java、 C#，甚至包括前面提到的古老的Lisp）的主流实现中，都是称通过可达性分析（Reachability Analysis）来判定对象是否存活的。这个算法的基本思路就是通过一系列的称为“GC Roots”的对象作为起始点，从这些节点开始向下搜索，搜索所走过的路径称为引用链（Reference Chain），当一个对象到GC Roots没有任何引用链相连（用图论的话来说，就是从GC Roots到这个对象不可达）时，则证明此对象是不可用的。 如图3-1所示，对象object 5、 object 6、 object 7虽然互相有关联，但是它们到GC Roots是不可达的，所以它们将会被判定为是可回收的对象。

这里的GC Roots对象包括以下几种：

虚拟机栈（栈帧中的本地变量表）中引用的对象。
方法区中类静态属性引用的对象。
方法区中常量引用的对象。
本地方法栈中JNI（即一般说的Native方法）引用的对象。

注： 这里涉及Java中到四种引用，不再细说。

在此我向大家推荐一个架构学习交流群。交流学习群号：478030634 里面会分享一些资深架构师录制的视频录像：有Spring，MyBatis，Netty源码分析，高并发、高性能、分布式、微服务架构的原理，JVM性能优化、分布式架构等这些成为架构师必备的知识体系。还能领取免费的学习资源，目前受益良多

三、典型的垃圾收集算法

在确定了哪些垃圾可以被回收后，垃圾收集器要做的事情就是开始进行垃圾回收，但是这里面涉及到一个问题是：如何高效地进行垃圾回收。由于Java虚拟机规范并没有对如何实现垃圾收集器做出明确的规定，因此各个厂商的虚拟机可以采用不同的方式来实现垃圾收集器，所以在此只讨论几种常见的垃圾收集算法的核心思想。

1.Mark-Sweep（标记-清除）算法

这是最基础的垃圾回收算法，之所以说它是最基础的是因为它最容易实现，思想也是最简单的。标记-清除算法分为两个阶段：标记阶段和清除阶段。标记阶段的任务是标记出所有需要被回收的对象，清除阶段就是回收被标记的对象所占用的空间。具体过程如下图所示：

从图中可以很容易看出标记-清除算法实现起来比较容易，但是有一个比较严重的问题就是容易产生内存碎片，碎片太多可能会导致后续过程中需要为大对象分配空间时无法找到足够的空间而提前触发新的一次垃圾收集动作。

　2.Copying（复制）算法

为了解决Mark-Sweep算法的缺陷，Copying算法就被提了出来。它将可用内存按容量划分为大小相等的两块，每次只使用其中的一块。当这一块的内存用完了，就将还存活着的对象复制到另外一块上面，然后再把已使用的内存空间一次清理掉，这样一来就不容易出现内存碎片的问题。具体过程如下图所示：

这种算法虽然实现简单，运行高效且不容易产生内存碎片，但是却对内存空间的使用做出了高昂的代价，因为能够使用的内存缩减到原来的一半。

很显然，Copying算法的效率跟存活对象的数目多少有很大的关系，如果存活对象很多，那么Copying算法的效率将会大大降低。

3.Mark-Compact（标记-整理）算法

为了解决Copying算法的缺陷，充分利用内存空间，提出了Mark-Compact算法。该算法标记阶段和Mark-Sweep一样，但是在完成标记之后，它不是直接清理可回收对象，而是将存活对象都向一端移动，然后清理掉端边界以外的内存。具体过程如下图所示：

4.Generational Collection（分代收集）算法

分代收集算法是目前大部分JVM的垃圾收集器采用的算法。它的核心思想是根据对象存活的生命周期将内存划分为若干个不同的区域。一般情况下将堆区划分为老年代（Tenured Generation）和新生代（Young Generation），老年代的特点是每次垃圾收集时只有少量对象需要被回收，而新生代的特点是每次垃圾回收时都有大量的对象需要被回收，那么就可以根据不同代的特点采取最适合的收集算法。

目前大部分垃圾收集器对于新生代都采取Copying算法，因为新生代中每次垃圾回收都要回收大部分对象，也就是说需要复制的操作次数较少，但是实际中并不是按照1：1的比例来划分新生代的空间的，一般来说是将新生代划分为一块较大的Eden空间和两块较小的Survivor空间，每次使用Eden空间和其中的一块Survivor空间，当进行回收时，将Eden和Survivor中还存活的对象复制到另一块Survivor空间中，然后清理掉Eden和刚才使用过的Survivor空间。

而由于老年代的特点是每次回收都只回收少量对象，一般使用的是Mark-Compact算法。

注意，在堆区之外还有一个代就是永久代（Permanet Generation），它用来存储class类、常量、方法描述等。对永久代的回收主要回收两部分内容：废弃常量和无用的类。

大家觉得文章对你还是有一点点帮助的，大家可以点击下方二维码进行关注。 《Java烂猪皮》 公众号聊的不仅仅是Java技术知识，还有面试等干货，后期还有大量架构干货。大家一起关注吧！关注烂猪皮，你会了解的更多..............

今天关于总结PHP内存释放以及垃圾回收和总结php内存释放以及垃圾回收过程的介绍到此结束，谢谢您的阅读，有关c# 的析构以及垃圾回收2、3事！、C# 的析构以及垃圾回收实例分析、flash垃圾回收机制，内存泄漏的常见情况及内存释放优化的原则、Java 内存分配及垃圾回收机制初探等更多相关知识的信息可以在本站进行查询。