破除Java神话.doc

破除java神话之一：垃圾收集解决所有的内存问题 破除java神话之二：参数是传址的 破除java神话之三：原子操作都是线程安全的 破除java神话之四：同步代码等同于断面（critical section） 破除java神话之一：垃圾收集解决所有的内存问题 对于java程序员而言，垃圾收集功能是一个非常大的帮助，同时也是使用java语言的一个非常大的优势。 然而，实际情况应该是不能因为垃圾收集可以清除无用的内存就不去考虑内存问题。这里要指明的是， 如果忽略这个问题，那么就会导致问题。 首先，在不同的JVM上垃圾收集算法是不同的，因此，如果你想你的程序能够很好的运行在不同的JVM上， 那么就不能依赖垃圾收集的特定行为。垃圾收集是一个非常活跃的研究问题，更好、更快并且更精确的收集器总在实现中。 然而很多现代的垃圾收集器都有着同样的问题。其中一个是当他们运行时并非总是释放所有那些可以被收集的对象。 分析表明java编程中大多对象的生存期是短暂的，因此，对于需要提高性能的收集器而言，他们会减少检查那些 具有较长生命的对象的频度，这个是依据大多对象具有较短的生存期，而那些生存期较长的对象往往会被继续引用， 因此，没有必要在每次检查时都去检查这样的对象是否可以被回收。 要释放特定的对象的内存可能需要多次调用垃圾收集。你可以通过调用System.gc方法建议（注意是建议） 垃圾收集器运行。请求这个方法的结果通常导致垃圾收集器进行一次完整的收集。通常这个比VM调用垃圾收集要更彻底和完全， 也会尽可能快的完成。如果程序员显式的调用System.gc，那么推论是有更多的时间做更多的工作 （请注意是有更多的事情做更多的事情，这意味着将进行大量的检查,还记得刚才的有关对长短生命期对象的检查的频度的变化吗？ 而不是真正彻底的清除）。在任何一种情况下（显式调用垃圾收集和VM调用垃圾收集）都不要假设所有可以被收集的对象会真正的被收集。 显式的调用System.gc有更大的机会完成彻底的收集，但不是保证会完成。 另一个程序员会遇到的麻烦是他们往往保持对那些不再需要的对象的引用。这将阻止垃圾收集器释放该对象。 这种情况在你自己管理列表的时候会发生。 考虑下面的ObjStack类。这个类使用push和pop方法管理堆栈中的对象。两个方法都利用索引，该索引指明堆栈中 下一个可用的位置。push方法存储对新对象的引用并增加索引值，而pop方法减小索引值并返回堆栈最上面的元素。 实例一：没有正确实现pop方法的ObjStack class ObjStack private Object stack; private int index; public void push(Object o) stackindex = o; index+; public Object pop() index-; return stackindex; /. 现在创建一个容量为10的对象，然后调用8次push方法向它添加对象，那么此时索引值为8。 现在考虑三次调用pop方法后发生什么？此时的索引值为5，但是请注意，除了这个索引值发生变化外堆栈其实没有其它任何变化！ 虽然pop方法减小了索引值，但是实际上堆栈仍然保持着对那些对象的引用。调用pop方法往往意味着那些对象应该被收集 （大多情况是如此的，即使不是马上，也是在稍后使用完该对象后）。然而由于堆栈仍然保留有对该对象的引用， 它就不能被收集。这些对象只能在调用push后被替换才可能被收集。正确的pop的实现如下： public Object pop() index-; Object o = stackindex; stackindex = null; return o; 在这个版本的pop方法中，当引用被返回后，堆栈删除对他们的引用因此垃圾收集器在以后可以回收他们。 在你自己的编码中，对于那些不需要的对象，不要在引用它们！程序的执行极大收到可用内存的影响，可用内存越少， 那么垃圾收集的执行次数越多，这将极大的伤害性能。 破除java神话之二：参数是传址的 在不同的java新闻组中，参数是传值还是传址一直是一个经常被争辩的话题。误解的中心是以下两个事实： 1、对象是传引用的 2、参数是传值的 这两个能够同时成立吗？一个字：是！在java中，你从来没有传递对象，你传递的仅仅是对象的引用！ 一句话，java是传引用的。然而，当你传递一个参数，那么只有一种参数传递机制：传值！ 通常，当程序员讨论传值和传引用时，他们是指语言的参数传递机制，c+同时支持这两种机制， 因此，以前使用过c+的程序员开始好像不能确定的java是如何传参数的。java语言为了事情变得简单只支持参数传值的机制。 java中的变量有两种类型：引用类型和原始类型。当他们被作为参数传递给方法时，他们都是传值的。 这是一个非常重要的差别，下面的代码范例将说明这一点。在继续前，我们有必要定义一下传值和传引用。 传值意味着当参数被传递给一个方法或者函数时，方法或者函数接收到的是原始值的副本。 因此，如果方法或者函数修改了参数，受影响的只是副本，原始值保持不变。 关于java中的参数传递的混乱是因为很多java程序员是从c+转变过来的。c+有引用和非引用类型的变量， 并且分别是通过传引用和传值得。java语言有原始类型和对象引用，那么，按照逻辑，java对于原始类型使用传值而对引用是传引用的， 就像c+一样。毕竟，你会想到如果你正在传递一个引用，那么它一定是传引用的。这是一个很诱惑人的想法，但是是错误的！ 在c+和java中，当函数的参数不是引用时，你传递的是值得副本（传值）。但是对于引用类型就不同了。在c+中，当参数是引用类型， 你传递的是引用或者内存地址（传引用），而在java中，传递一个引用类型的参数的结果只是传递引用的副本（传值）而非引用自身。 这是一个非常重要的区别！java不考虑参数的类型，一律传递参数的副本。仍然不信？如果java中是传引用，那么下面的范例中的swap 方法将交换他们的参数。因为是传值，因此这个方法不是像期望的那样正常工作。 class Swap public static void main(String args) Integer a, b; int i,j; a = new Integer(10); b = new Integer(50); i = 5; j = 9; System.out.println(Before Swap, a is + a); System.out.println(Before Swap, b is + b); swap(a, b); System.out.println(After Swap a is + a); System.out.println(After Swap b is + b); System.out.println(Before Swap i is + i); System.out.println(Before Swap j is + j); swap(i,j); System.out.println(After Swap i is + i); System.out.println(After Swap j is + j); public static void swap(Integer ia, Integer ib) Integer temp = ia; ia = ib; ib = temp; public static void swap(int li, int lj) int temp = li; li = lj; lj = temp; 上面程序的输出是: Before Swap, a is 10 Before Swap, b is 50 After Swap a is 10 After Swap b is 50 Before Swap i is 5 Before Swap j is 9 After Swap i is 5 After Swap j is 9 因为swap方法接收到的是引用参数的副本（传值），对他们的修改不会反射到调用代码。 译者注：在传递引用和原始类型时还是有不同的，考虑以下的代码： class Change public static void main(String args) StringBuffer a=new StringBuffer(ok); int i; i = 5; System.out.println(Before change, a is + a); change(a); System.out.println(After change a is + a); System.out.println(Before change i is + i); change(i); System.out.println(After change i is + i); public static void change(StringBuffer ia) ia.append( ok?); public static void change(int li) li = 10; 程序的输出为： Before change, a is ok After change a is ok ok? Before change i is 5 After change i is 5 即如果传递的是引用，那么可以修改引用对象的内容，这个改变会影响到原来的对象，而传递的如果是原始类型则不会有影响。 这个也是造成误解的原因之一吧。 破除java神话之三：原子操作都是线程安全的 java中原子操作是线程安全的论调经常被提到。根据定义，原子操作是不会被打断地的操作，因此被认为是线程安全的。 实际上有一些原子操作不一定是线程安全的。 这个问题出现的原因是尽量减少在代码中同步关键字。同步会损害性能，虽然这个损失因JVM不同而不同。 另外，在现代的JVM中，同步的性能正在逐步提高。尽管如此，使用同步仍然是有性能代价的，并且程序员永远会尽力 提高他们的代码的效率，因此这个问题就延续了下来。 在java中，32位或者更少位数的赋值是原子的。在一个32位的硬件平台上，除了double和long型的其它原始类型通常都是 使用32位进行表示，而double和long通常使用64位表示。另外，对象引用使用本机指针实现，通常也是32位的。 对这些32位的类型的操作是原子的。 这些原始类型通常使用32位或者64位表示，这又引入了另一个小小的神话：原始类型的大小是由语言保证的。 这是不对的。java语言保证的是原始类型的表数范围而非JVM中的存储大小。因此，int型总是有相同的表数范围。 在一个JVM上可能使用32位实现，而在另一个JVM上可能是64位的。在此再次强调：在所有平台上被保证的是表数范围， 32位以及更小的值的操作是原子的。 那么，原子操作在什么情况下不是线程安全的？主要的一点是他们也许确实是线程安全的，但是这没有被保证！ java线程允许线程在自己的内存区保存变量的副本。允许线程使用本地的私有拷贝进行工作而非每次都使用主存的值是为了提高性能。 考虑下面的类： class RealTimeClock private int clkID; public int clockID() return clkID; public void setClockID(int id) clkID = id; /. 现在考虑RealTimeClock的一个实例以及两个线程同时调用setClockID和clockID，并发生以下的事件序列： T1 调用setClockID(5) T1将5放入自己的私有工作内存 T2调用setClockID(10) T2将10放入自己的私有工作内存 T1调用clockID,它返回5 5是从T1的私有工作内存返回的 对clockI的调用应该返回10，因为这是被T2设置的，然而返回的是5，因为读写操作是对私有工作内存的而非主存。 赋值操作当然是原子的，但是因为JVM允许这种行为，因此线程安全不是一定的，同时，JVM的这种行为也不是被保证的。 两个线程拥有自己的私有拷贝而不和主存一致。如果这种行为出现，那么私有本机变量和主存一致必须在以下两个条件下： 1、变量使用volatile声明 2、被访问的变量处于同步方法或者同步块中 如果变量被声明为volatile，在每次访问时都会和主存一致。这个一致性是由java语言保证的，并且是原子的， 即使是64位的值。(注意很多JVM没有正确的实现volatile关键字。你可以在找到更多的信息。) 另外，如果变量在同步方法或者同步块中被访问，当在方法或者块的入口处获得锁以及方法或者块退出时释放锁是变量被同步。 使用任何一种方法都可以保证ClockID返回10，也就是正确的值。变量访问的频度不同则你的选择的性能不同。 如果你更新很多变量，那么使用volatile可能比使用同步更慢。记住，如果变量被声明为volatile， 那么在每次访问时都会和主存一致。与此对照，使用同步时，变量只在获得锁和释放锁的时候和主存一致。但是同步使得代码有较少的并发性。 如果你更新很多变量并且不想有每次访问都和主存进行同步的损失或者你因为其它的原因想排除并发性时可以考虑使用同步。 破除java神话之四：同步代码等同于断面（critical section） 同步经常作为断面被引用。断面是指一次只能有一个线程执行它。多个线程同时执行同步代码是有可能的。 这个误解是因为很多程序员认为同步关键字锁住了它所包围的代码。但是实际情况不是这样的。同步加锁的是对象， 而不是代码。因此，如果你的类中有一个同步方法，这个方法可以被两个不同的线程同时执行，只要每个线程自己创建一个的该类的实例即可。 参考下面的代码： class Foo extends Thread private int val; public Foo(int v) val = v; public synchronized void printVal(int v) while(true) System.out.println(v); public void run() printVal(val); class SyncTest public static void main(String args) Foo f1 = new Foo(1); f1.start(); Foo f2 = new Foo(3); f2.start(); 运行SyncTest产生的输出是1和3交叉的。如果printVal是断面，你看到的输出只能是1或者只能是3而不能是两者同时出现。 程序运行的结果证明两个线程都在并发的执行printVal方法，即使该方法是同步的并且由于是一个无限循环而没有终止。 要实现真正的断面，你必须同步一个全局对象或者对类进行同步。下面的代码给出了一个这样的范例。 class Foo extends Thread private int val; public Foo(int v) val = v; public void printVal(int v) synchronized(Foo.class) while(true) System.out.println(v); public void run() printVal(val); 上面的类不再对个别的类实例同步而是对类进行同步。对于类Foo而言，它只有唯一的类定义，两个线程在相同的锁上同步， 因此只有一个线程可以执行printVal方法。 这个代码也可以通过对公共对象加锁。例如给Foo添加一个静态成员。两个方法都可以同步这个对象而达到线程安全。 译者注： 下面笔者给出一个参考实现，给出同步公共对象的两种通常方法： 1、 class Foo extends Thread private int val; private static Object lock=new Object(); public Foo(int v) val = v; public void printVal(int v) synchronized(lock) while(true) System.out.println(v); public void run() printVal(val); 上面的这个例子比原文给出的例子要好一些，因为原文中的加锁是