苹果的成长日记

下面是我自己的一些注释：
1.private 只有本类内的方法才具有访问权。
protected 只有本类内的方法、子类以及同一包内的其他类才具有访问权。
public 公开访问
final 一个常量或者一个不能被重载的类或方法
finally 一个try块中总会被执行的部分  回复  更多评论
  

2.HashMap和Hashtable基本相同，只是HashMap是非同步的，并且允许空值。
ArrayList和Vector的区别也是ArrayList是非同步的(unsyncronized). Hashtable和HashMap的区别： 1.Hashtable是Dictionary的子类，HashMap是Map接口的一个实现类； 2.Hashtable中的方法是同步的，而HashMap中的方法在缺省情况下是非同步的。即是说，在多线程应用程序中，不用专门的操作就安全地可以使用Hashtable了；而对于HashMap，则需要额外的同步机制。但HashMap的同步问题可通过Collections的一个静态方法得到解决： Map Collections.synchronizedMap(Map m) 这个方法返回一个同步的Map，这个Map封装了底层的HashMap的所有方法，使得底层的HashMap即使是在多线程的环境中也是安全的。 3.在HashMap中，null可以作为键，这样的键只有一个；可以有一个或多个键所对应的值为null。当get()方法返回null值时，即可以表示HashMap中没有该键，也可以表示该键所对应的值为null。因此，在HashMap中不能由get()方法来判断HashMap中是否存在某个键，而应该用containsKey()方法来判断。 Hashtable和HashMap采用的hash/rehash算法都大概一样，所以性能不会有很大的差异。  回复  更多评论
  

内部类
内部类的主要优点之一是内部类实例与外部类实例共享一种“特殊关系”。这种特殊关系为内部类中的代码提供对封装（外部）类成员的访问，就好象内部类是外部类的一部分。不仅是“一部分”，而且是外部类一个羽翼丰满、带着卡片的成员。内部类实例可以访问外部类的所有成员，甚至哪些被标识为private的成员。  回复  更多评论
  

Java线程及同步（synchronized）样例代码

--------------------------------------------------------------------------------

Java线程及同步（synchronized）样例代码


import java.io.*;
import java.util.*;
import java.text.SimpleDateFormat;

public class TestThread extends Thread
{
private static Integer threadCounterLock; //用于同步，防止数据被写乱
private static int threadCount; //本类的线程计数器

static
{
threadCount = 0;
threadCounterLock = new Integer(0);
}

public TestThread()
{
super();
}

public synchronized static void incThreadCount()
{
threadCount++;
System.out.println("thread count after enter: " + threadCount);
}

public synchronized static void decThreadCount()
{
threadCount--;
System.out.println("thread count after leave: " + threadCount);
}

public void run()
{
synchronized(threadCounterLock) //同步
{
threadCount++;
System.out.println("thread count after enter: " + threadCount);
}

//incThreadCount(); //和上面的语句块是等价的

final long nSleepMilliSecs = 1000; //循环中的休眠时间

long nCurrentTime = System.currentTimeMillis();
long nEndTime = nCurrentTime + 30000; //运行截止时间
SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

try
{
while (nCurrentTime < nEndTime)
{
nCurrentTime = System.currentTimeMillis();
System.out.println("Thread " + this.hashCode() + ", current time: " + simpleDateFormat.format(new Date(nCurrentTime)));

try
{
sleep(nSleepMilliSecs);
}
catch(InterruptedException ex)
{
ex.printStackTrace();
}
}
}
finally
{
synchronized(threadCounterLock) //同步
{
threadCount--;
System.out.println("thread count after leave: " + threadCount);
}

//decThreadCount(); //和上面的语句块是等价的
}
}

public static void main(String[] args)
{
TestThread[] testThread = new TestThread[2];
for (int i=0; i {
testThread[i] = new TestThread();
testThread[i].start();
}
}
}

同步就是简单的说我用的时候你不能用，大家用的要是一样的就这样！
比如说有只苹果很好吃，我拉起来咬一口，放下，你再拉起咬一口，这就同步了，要是大家一起咬，呵呵，那就结婚吧，婚礼上常能看到这个，也不怕咬着嘴，嘻嘻嘻！

举个例子，现在有个类，类中有一个私有成员一个苹果，两个方法一个看，一个吃。
现在不同步，我一“看”，哈哈一个苹果，我“吃”四分之一了
你一“看”，哈哈一个苹果，也“吃”四分之一了。
可能的情况就是都是看到一个苹果但我的吃方法用在你的之前，所以可能你只能吃到3/4的1/4也就是3/16个而不是1/4个苹果了。
现在加入同步锁，我在吃的时候你看被锁，等吃完了，你再看，啊3/4个苹果，吃1/3好了了，就这样！  回复  更多评论
  

垃圾收集器
java的垃圾收集器为内存管理提供了一种自动解决方案。在多数情况下，它把你从必须为应用程序添加所有内存管理中解脱出来。自动垃圾收集的缺点是不能完全控制它什么时候执行以及什么时候不执行。
堆是java对象所在的内存部分，它是垃圾收集处理所涉及的一块也是唯一的一块内存。所有的垃圾收集考虑的是要确保堆有尽可能多的自由空间。问题的核心就是要删除运行的java程序不能再到达的任何对象。当垃圾收集器运行时，其目的时查找和删除不能被访问的对象，如果把java程序看作是处于一个这样的固定循环中：创建它所需的对象（这要占用堆上的空间），之后当不再需要他们时废弃它们，创建新的对象，再废弃它们，如此循环，这个问题中缺少的一部分是垃圾收集器。当它运行时，它从内存中查找那些被废弃的对象，并删除它们，这样使使用内存和释放内存的循环能够继续。
1。垃圾收集器什么时候运行？
垃圾收集器受JVM控制，JVM决定什么时候运行垃圾收集器。从Java程序内可以请求JVM运行垃圾收集器，但是，在任何情况下都无法保障JVM会答应你的请求。JVM通常会在它感到内存减少时运行垃圾收集器。经验告诉我们：当java程序请求进行垃圾收集时，JVM通常会在短期内响应请求，但这没有任何保障。刚好在你认为可以依靠它时，JVM可能会忽略你的请求。
2.GC怎样工作？
什么时候对象变得符合垃圾收集条件？每个java程序有一个或多个线程，每个线程都有其自己的小执行栈。通常，在一个java程序中至少要运行一个线程，即栈底部main()方法的线程。出了有其自己的小执行栈外，每个线程都有其自己的生命周期。线程可以是死的或活的，当没有任何活线程能够访问一个对象时，该对象就符合垃圾收集条件。
根据这一定义，GC做一些不可思议的未知操作，当它发现一个对象不能被任何活线程访问时，它将认为该对象符合删除条件，它可能在某时删除它（它也可能不删除它）。所谓到达一个对象，实际上是有一个可到达的引用变量引用所讨论的对象。如果我们的java程序有一个引用变量引用一个对象，并且该引用变量可用于一个活线程，则该对象被认为是可到达的。
注意：一个java程序能够耗尽内存。垃圾收集系统尝试在对象不被使用时把它们从内存中删除。然而，如果保持太多活对象（被其他活对象引用的对象），系统则会耗尽内存。垃圾收集不能保证有足够的内存，它只能保证可以使用的内存将尽可能被有效地管理。
3.编写代码明确使对象符合搜集条件
怎样使对象符合垃圾收集条件，怎样在必要时强制执行垃圾收集，怎样执行额外地清理？
1）空引用 把引用该对象的引用变量设置为null，使没有对它的可到达引用
public class GarbageTruck {
public static void main(String[] args) {
StringBuffer sb = new StringBuffer("hello");
System.out.println(sb);
//The StringBuffer object is not eligible for collection
sb = null;
//Now the StringBuffer object is eligible for collection
}
}
2）重新为引用变量赋值
可以通过设置引用变量引用另一个对象来解除该引用变量与一个对象间的引用关系。
class GarbageTruck {
public static void main(String [] args) {
StringBuffer s1= new StringBuffer("hello");
StringBuffer s2= new StringBuffer(goodbye");
System.out.println(s1);
//At this point the StringBuffer "hello" is not eligible
s1=s2;//Redirects s1 to refer to the "goodbye" object
//Now the StringBuffer "hello" is eligible for collection
在方法内创建对象也要考虑一下。当调用方法时，所创建的任何局部变量只在该方法期间存在。一旦该方法返回，在这个方法那创建的对象就符合垃圾收集条件。然而，有一种明显的例外情况，如果一个对象从一个方法被返回，其引用可能在调用它的方法内被赋予一个引用变量，因此它不符合搜集条件。请看下面代码：
import java.util.Date;
public class GarbageFactory {
public static void main(String[] args) {
Date d = getDate();
doComplicatedStuff();
System.out.println("d = "+d);
}
public static getDate() {
Date d2 = new Date();
String now = d2.toString();
System.out.println(now);
return d2;
}
}
在方法getDate()中，创建了两个对象，一个Date对象和一个包含日期信息的String对象。因为该方法返回Date对象，所以它将不符合搜集条件，即使在该方法完成之后。然而String对象将符合条件，即使没有明确把now变量设置为null。
3.隔离引用  回复  更多评论