码迷，mamicode.com
首页 > 编程语言 > 详细

Java的结构之美【2】——销毁对象

时间：2014-06-30 08:45:00      阅读：220      评论：0      收藏：0      [点我收藏+]

标签：java   对象销毁   线程   

先来看一段代码：

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();
		}
	}
}
成功输出结果如下：

bubuko.com,布布扣

这段代码看似没有任何问题，但是却存在着内存泄露问题，我们没有关闭相应的资源

bubuko.com,布布扣


再来思考一个问题，代码如下：

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），作用是当对象的垃圾回收器执行的时候回调该方法。

bubuko.com,布布扣

上面我们使用了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("外部类对象销毁了");
	}
}

输出结果：

bubuko.com,布布扣

从上面结果中我们可以看到，只有当线程结束后，线程对象和启动线程的对象才能真正的被垃圾回收器回收，所以在内部类中定义线程类，启动线程，会一直持有外部类的引用。现在我们又会产生一个疑问，是不是所有的内部类都持有外部类的引用呢？下面我们再来做个试验：

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("外部类对象销毁了");
	}
}
我再将内部类的引用和外部类的引用都置为空，则输出了以下结果：

bubuko.com,布布扣
至少我可以从上面现象中这样认为，所有内部类都持有外部类的引用。这个结论还有待进一步的验证。。。

感谢你对“阳光小强"的关注，我的另一篇博文很荣幸参加了CSDN举办的博文大赛，如果你觉的小强的博文对你有帮助，请为小强投上你宝贵的一票，投票地址：http://vote.blog.csdn.net/Article/Details?articleid=30101091

Java的结构之美【2】——销毁对象,布布扣,bubuko.com

Java的结构之美【2】——销毁对象

标签：java   对象销毁   线程   

原文地址：http://blog.csdn.net/dawanganban/article/details/35550399
踩
(0)
赞
(0)
   
举报
评论 一句话评论（0）
登录后才能评论！
分享档案
更多>
2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)
周排行
mamicode.com排行更多图片
更多
友情链接
兰亭集智   国之画   百度统计   站长统计   阿里云   chrome插件   新版天听网
关于我们 - 联系我们 - 留言反馈
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码！