正文
Java的结构之美【2】——销毁对象
提示：扫一扫查出行【扫一扫了解最新限行尾号】
复制提示
先来看一段代码：
import java.util.Arrays;
import java.util.EmptyStackException; /**
* 2014年6月28日09:31:59
* @author 阳光小强
*
*/
public class Stack {
private Object[] elements;
private int size = 0;
private static final int DEFAULT_INITAL_CAPACITY = 15; public Stack(){
elements = new Object[DEFAULT_INITAL_CAPACITY];
} public void push(Object obj){
ensureCapacity();
elements[size++] = obj;
} public Object pop(){
if(size == 0){
throw new EmptyStackException();
}
return elements[--size];
} /**
* 假设长度超出了默认长度则加倍
*/
private void ensureCapacity(){
if(elements.length == size){
elements = Arrays.copyOf(elements, 2 * size + 1);
}
}
}
这段程序表面上看是没有不论什么错误的，可是它隐藏着一个“内存泄露”问题，随然每次都有pop()从栈里弹出对象，可是栈中的对象还是被引用着，所以不能够及时释放。将上面代码改动例如以下：
public Object pop(){
if(size == 0){
throw new EmptyStackException();
}
Object result = elements[--size];
elements[size] = null;
return result;
}
再来看一段代码：
import java.io.BufferedInputStream;
import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStreamReader; public class IOTest {
public static void main(String[] args) {
try {
FileInputStream fis = new FileInputStream("test.xml");
InputStreamReader isr = new InputStreamReader(fis);
BufferedReader br = new BufferedReader(isr);
if(br.ready()){
System.out.println(br.readLine());
}
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
成功输出结果例如以下：
这段代码看似没有不论什么问题，可是却存在着内存泄露问题，我们没有关闭对应的资源
再来思考一个问题，代码例如以下：
public class IOTest {
public static void main(String[] args) {
IOTest test = new IOTest();
IOTest.MyThread myThread = test.new MyThread();
myThread.start();
test = null; //这个对象能释放吗？
myThread = null; //线程能自己主动结束吗？为什么？
}
class MyThread extends Thread{
private int i = 0;
@Override
public void run() {
while(true){
try {
sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(i++);
}
}
}
}
上面对象能释放吗？线程能自己主动结束吗？
在搞清楚上面问题之前，我们将上面代码进行改动，先看例如以下代码：
public class IOTest {
private String data = "阳光小强";
public static void main(String[] args) {
IOTest test = new IOTest();
/*IOTest.MyThread myThread = test.new MyThread();
myThread.start();*/
test = null; //这个对象能释放吗？
//myThread = null; //线程能自己主动结束吗？为什么？
System.gc(); //启动垃圾回收器
while(true){
}
}
class MyThread extends Thread{
private int i = 0;
@Override
public void run() {
while(true){
try {
sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(i++);
System.out.println(data);
}
}
}
@Override
protected void finalize() throws Throwable {
super.finalize();
System.out.println("对象销毁了");
}
}
在上面代码中我们重写了IOTest对象的finalize()方法，该方法是Object类的方法（protected），作用是当对象的垃圾回收器执行的时候回调该方法。
上面我们使用了System.gc()方法来通知垃圾回收器进行垃圾回收，执行的结果是输出了“对象销毁了".以下我们将上面代码中的凝视去掉，启动线程后再来执行一次。
public class IOTest {
private String data = "阳光小强";
public static void main(String[] args) {
IOTest test = new IOTest();
IOTest.MyThread myThread = test.new MyThread();
myThread.start();
test = null; //这个对象能释放吗？
myThread = null; //线程能自己主动结束吗？为什么？
System.gc(); //启动垃圾回收器
while(true){
}
}
class MyThread extends Thread{
private int i = 0;
@Override
public void run() {
while(true){
try {
sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(i++);
System.out.println(data);
}
}
}
@Override
protected void finalize() throws Throwable {
super.finalize();
System.out.println("对象销毁了");
}
}
能够看到”对象销毁了“这句话没有被输出到控制台，说明我们创建的IOTest对象没有被销毁，在非常多书上都会说，给一个对象赋null值，这个对象就会成为无主对象，就会被垃圾回收器回收，可是为什么这个线程和IOTest对象还是存在的？假设是这种话，我们应该考虑怎样节省我们的内存？再来看一段代码：
public class IOTest {
private String data = "阳光小强";
public static void main(String[] args) {
IOTest test = new IOTest();
IOTest.MyThread myThread = test.new MyThread();
myThread.start();
test = null; //这个对象能释放吗？
myThread = null; //线程能自己主动结束吗？为什么？
while(true){
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.gc(); //启动垃圾回收器
}
}
class MyThread extends Thread{
private int i = 0;
@Override
public void run() {
while(i<5){
try {
sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(i++);
System.out.println(data);
}
}
@Override
protected void finalize() throws Throwable {
super.finalize();
System.out.println("线程对象销毁了");
}
}
public void testUsed(){
while(true){
}
}
@Override
protected void finalize() throws Throwable {
super.finalize();
System.out.println("外部类对象销毁了");
}
}
输出结果：
从上面结果中我们能够看到，仅仅有当线程结束后，线程对象和启动线程的对象才干真正的被垃圾回收器回收，所以在内部类中定义线程类，启动线程，会一直持有外部类的引用。如今我们又会产生一个疑问，是不是全部的内部类都持有外部类的引用呢？以下我们再来做个试验：
public class IOTest {
private String data = "阳光小强";
public static void main(String[] args) {
IOTest test = new IOTest();
IOTest.MyThread myThread = test.new MyThread();
//myThread.start();
test = null; //这个对象能释放吗？
//myThread = null; //线程能自己主动结束吗？为什么？
while(true){
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.gc(); //启动垃圾回收器
}
}
class MyThread extends Thread{
private int i = 0;
@Override
public void run() {
while(i<5){
try {
sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(i++);
System.out.println(data);
}
}
@Override
protected void finalize() throws Throwable {
super.finalize();
System.out.println("线程对象销毁了");
}
}
public void testUsed(){
while(true){
}
}
@Override
protected void finalize() throws Throwable {
super.finalize();
System.out.println("外部类对象销毁了");
}
}
在上面的代码中我没有启动线程，所以此时的MyThread就能够当成一个普通的内部类了，我将外部类的引用置为空，会发现没有不论什么结果输出（说明外部类没有被销毁）
public class IOTest {
private String data = "阳光小强";
public static void main(String[] args) {
IOTest test = new IOTest();
IOTest.MyThread myThread = test.new MyThread();
//myThread.start();
test = null; //这个对象能释放吗？
myThread = null; //线程能自己主动结束吗？为什么？
while(true){
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.gc(); //启动垃圾回收器
}
}
class MyThread extends Thread{
private int i = 0;
@Override
public void run() {
while(i<5){
try {
sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(i++);
System.out.println(data);
}
}
@Override
protected void finalize() throws Throwable {
super.finalize();
System.out.println("线程对象销毁了");
}
}
public void testUsed(){
while(true){
}
}
@Override
protected void finalize() throws Throwable {
super.finalize();
System.out.println("外部类对象销毁了");
}
}
我再将内部类的引用和外部类的引用都置为空，则输出了以下结果：
至少我能够从上面现象中这样觉得，全部内部类都持有外部类的引用。这个结论还有待进一步的验证。。。
感谢你对“阳光小强"的关注，我的还有一篇博文非常荣幸參加了CSDN举办的博文大赛，假设你觉的小强的博文对你有帮助，请为小强投上你宝贵的一票，投票地址：http://vote.blog.csdn.net/Article/Details?articleid=30101091
