语源科技BlogJava-从心开始

系统时间修改方法

飘雪 — Tue, 08 Jan 2008 15:47:00 GMT

java 修改系统时间方法

第一种方法：

需下载 jna.jar

a) 创建 Kernel32 接口

package time.test;

import com.sun.jna.Native;
import com.sun.jna.Structure;
import com.sun.jna.win32.StdCallLibrary;

public interface Kernel32 extends StdCallLibrary
{
    Kernel32 INSTANCE = (Kernel32)Native.loadLibrary( " kernel32 " , Kernel32. class );
     public SYSTEMTIME GetSystemTime();

     public void SetLocalTime(SYSTEMTIME localTime);

     public static class SYSTEMTIME extends Structure
     {
     // 必须有这么多个字段,按这个顺序定义属性
         public short wYear;
         public short wMonth;
             public short wDayOfWeek;
         public short wDay;
         public short wHour;
         public short wMinute;
         public short wSecond;
         public short wMilliseconds;
            }
}

b) 修改时间

import time.test.Kernel32.SYSTEMTIME;

public class SysTimeSettingDaoImp
{
     protected void setLocalTime(String time)
     {
       // time时间格式是14位的字符串，如"20080108152130"
        Short year = Short.parseShort(time.substring( 0 , 4 ));
        Short month = Short.parseShort(time.substring( 4 , 6 ));
        Short day = Short.parseShort(time.substring( 6 , 8 ));
        Short hour = Short.parseShort(time.substring( 8 , 10 ));
        Short minute = Short.parseShort(time.substring( 10 , 12 ));
        Short second = Short.parseShort(time.substring( 12 , 14 ));

        SYSTEMTIME ss = new SYSTEMTIME();
        ss.setWYear(year);
        ss.setWMonth(month);
        ss.setWDay(day);
        ss.setWHour(hour);
        ss.setWMinute(minute);
        ss.setWSecond(second);

        Kernel32 lib = Kernel32.INSTANCE;
        lib.SetLocalTime(ss);
    }
}

第二种方法

public class MyTimeClass
{
             // timeAndDate格式位14位的字符串表示形式。
             public void setLocalTime(String timeAndDate)
             {
                            String date = getDate(timeAndDate);
                            String time = getTime(timeAndDate);

                             // 修改系统日期和时间
                            Runtime.getRuntime().exec( " cmd /c date " + date);
                            Runtime.getRuntime().exec( " cmd /c time " + time);
            }
             public String getDate(String timeAndDate)
             {
                    String year = timeAndDate.substring( 0 , 4 );
                    String month = timeAndDate.substring( 4 , 6 );
                    String day = timeAndDate.substring( 6 , 8 );
                     return year + " - " + month + " - " + day;
            }
             public String getTime(String timeAndDate)
             {
                    String hour = timeAndDate.substring( 8 , 10 );
                    String minute = timeAndDate.substring( 10 , 12 );
                    String second = timeAndDate.substring( 12 , 14 );
                     return hour + " : " + minute + " : " + second;
            }
}

Linux系统修改时间

  String os = System.getProperty( " os.name " ).toLowerCase(); // 获取操作系统名称

if (os.indexOf( " windows " ) != - 1 )
{
    cmd = " cmd /c time " + timeStr;
    ProcessUtil.printErr(Runtime.getRuntime().exec(cmd));
    cmd = " cmd /c date " + timeStr;
    ProcessUtil.printErr(Runtime.getRuntime().exec(cmd));
   }
    else
    {
    cmd = " date " + timeStr; //timeStr时间到分，先写时间再写日期
    ProcessUtil.printErr(Runtime.getRuntime().exec(cmd));
   }

public class ProcessUtil {

    public static void printErr(Process p) {
        BufferedReader br = null;
        try {
            br = new BufferedReader(new InputStreamReader(p.getErrorStream()));
            String line = null;
            while ((line = br.readLine()) != null) {
                System.out.println(line);
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                if (br != null)
                    br.close();
            } catch (Exception e) {
                e.printStackTrace();
            }
            p.destroy();
        }
    }

    public static void printConsole(Process p) {
        BufferedReader br = null;
        try {
            br = new BufferedReader(new InputStreamReader(p.getInputStream()));
            String line = null;
            while ((line = br.readLine()) != null) {
                System.out.println(line);
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                if (br != null)
                    br.close();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

    public static String getErrInfo(Process p) {
        StringBuffer sb = new StringBuffer();
        BufferedReader br = null;
        try {
            br = new BufferedReader(new InputStreamReader(p.getErrorStream()));
            String line = null;
            while ((line = br.readLine()) != null) {
                sb.append(line).append("\n");
            }
            return sb.toString();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                if (br != null)
                    br.close();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        return null;
    }

}

飘雪 2008-01-08 23:47 发表评论

DBCP数据库连接池

飘雪 — Mon, 05 Nov 2007 10:15:00 GMT

摘要: DBCP是Apache的一个开源项目： commons.dbcp.jarhttp://jakarta.apache.org/commons/dbcp/index.htmlDBCP依赖Apache的另外2个开源项目commons.collections.jar和commons.pool.jar下载这些包并将这些包的路径添加到classpath中就可以使用dbcp做为项目中的数据库连接池使用... 阅读全文

飘雪 2007-11-05 18:15 发表评论

java多线程学习

飘雪 — Fri, 26 Oct 2007 08:10:00 GMT

一：理解多线程

??多线程是这样一种机制，它允许在程序中并发执行多个指令流，每个指令流都称为一个线程，彼此间互相独立。线程又称为轻量级进程，它和进程一样拥有独立的执行控制，由操作系统负责调度，区别在于线程没有独立的存储空间，而是和所属进程中的其它线程共享一个存储空间，这使得线程间的通信远较进程简单。

??多个线程的执行是并发的，也就是在逻辑上“同时”，而不管是否是物理上的“同时”。如果系统只有一个CPU，那么真正的“同时”是不可能的，但是由于CPU的速度非常快，用户感觉不到其中的区别，因此我们也不用关心它，只需要设想各个线程是同时执行即可。
多线程和传统的单线程在程序设计上最大的区别在于，由于各个线程的控制流彼此独立，使得各个线程之间的代码是乱序执行的，由此带来的线程调度，同步等问题，将在以后探讨。

　　二：在Java中实现多线程

??我们不妨设想，为了创建一个新的线程，我们需要做些什么？很显然，我们必须指明这个线程所要执行的代码，而这就是在Java中实现多线程我们所需要做的一切！

??真是神奇！Java是如何做到这一点的？通过类！作为一个完全面向对象的语言，Java提供了类 java.lang.Thread 来方便多线程编程，这个类提供了大量的方法来方便我们控制自己的各个线程，我们以后的讨论都将围绕这个类进行。

??那么如何提供给 Java 我们要线程执行的代码呢？让我们来看一看 Thread 类。Thread 类最重要的方法是 run() ，它为Thread 类的方法 start() 所调用，提供我们的线程所要执行的代码。为了指定我们自己的代码，只需要覆盖它！

　　方法一：继承 Thread 类，覆盖方法 run()，我们在创建的 Thread 类的子类中重写 run() ,加入线程所要执行的代码即可。下面是一个例子：

public class MyThread extends Thread {
　int count= 1, number;
　public MyThread(int num) {
　　number = num;
　　System.out.println("创建线程 " + number);
　}
　public void run() {
　　while(true) {
　　　System.out.println("线程 " + number + ":计数 " + count);
　　　if(++count== 6) return;
　　}
　}
　public static void main(String args[]) {
　　for(int i = 0; i 〈 5; i++) new MyThread(i+1).start();
　}
}

??这种方法简单明了，符合大家的习惯，但是，它也有一个很大的缺点，那就是如果我们的类已经从一个类继承（如小程序必须继承自 Applet 类），则无法再继承 Thread 类，这时如果我们又不想建立一个新的类，应该怎么办呢？

??我们不妨来探索一种新的方法：我们不创建 Thread 类的子类，而是直接使用它，那么我们只能将我们的方法作为参数传递给 Thread 类的实例，有点类似回调函数。但是 Java 没有指针，我们只能传递一个包含这个方法的类的实例。那么如何限制这个类必须包含这一方法呢？当然是使用接口！（虽然抽象类也可满足，但是需要继承，而我们之所以要采用这种新方法，不就是为了避免继承带来的限制吗？）
Java 提供了接口 java.lang.Runnable 来支持这种方法。

　　方法二：实现 Runnable 接口

??Runnable 接口只有一个方法 run()，我们声明自己的类实现 Runnable 接口并提供这一方法，将我们的线程代码写入其中，就完成了这一部分的任务。但是 Runnable 接口并没有任何对线程的支持，我们还必须创建 Thread 类的实例，这一点通过 Thread 类的构造函数public Thread(Runnable target);来实现。下面是一个例子：

public class MyThread implements Runnable {
　int count= 1, number;
　public MyThread(int num) {
　　number = num;
　　System.out.println("创建线程 " + number);
　}
　public void run() {
　　while(true) {
　　　System.out.println("线程 " + number + ":计数 " + count);
　　　if(++count== 6) return;
　　}
　}
　public static void main(String args[]) {
　　for(int i = 0; i 〈 5; i++) new Thread(new MyThread(i+1)).start();
　}
}

??严格地说，创建 Thread 子类的实例也是可行的，但是必须注意的是，该子类必须没有覆盖 Thread 类的 run 方法，否则该线程执行的将是子类的 run 方法，而不是我们用以实现Runnable 接口的类的 run 方法，对此大家不妨试验一下。

　　使用 Runnable 接口来实现多线程使得我们能够在一个类中包容所有的代码，有利于封装，它的缺点在于，我们只能使用一套代码，若想创建多个线程并使各个线程执行不同的代码，则仍必须额外创建类，如果这样的话，在大多数情况下也许还不如直接用多个类分别继承 Thread 来得紧凑。

　　综上所述，两种方法各有千秋，大家可以灵活运用。

　　下面让我们一起来研究一下多线程使用中的一些问题。
　　三：线程的四种状态

　　1. 新状态：线程已被创建但尚未执行（start() 尚未被调用）。

　　2. 可执行状态：线程可以执行，虽然不一定正在执行。CPU 时间随时可能被分配给该线程，从而使得它执行。

　　3. 死亡状态：正常情况下 run() 返回使得线程死亡。调用 stop()或 destroy() 亦有同样效果，但是不被推荐，前者会产生异常，后者是强制终止，不会释放锁。

　　4. 阻塞状态：线程不会被分配 CPU 时间，无法执行。

　　四：线程的优先级

??线程的优先级代表该线程的重要程度，当有多个线程同时处于可执行状态并等待获得 CPU 时间时，线程调度系统根据各个线程的优先级来决定给谁分配 CPU 时间，优先级高的线程有更大的机会获得 CPU 时间，优先级低的线程也不是没有机会，只是机会要小一些罢了。

??你可以调用 Thread 类的方法 getPriority() 和 setPriority()来存取线程的优先级，线程的优先级界于1(MIN_PRIORITY)和10(MAX_PRIORITY)之间，缺省是5(NORM_PRIORITY)。

　　五：线程的同步

??由于同一进程的多个线程共享同一片存储空间，在带来方便的同时，也带来了访问冲突这个严重的问题。Java语言提供了专门机制以解决这种冲突，有效避免了同一个数据对象被多个线程同时访问。

　　由于我们可以通过 private 关键字来保证数据对象只能被方法访问，所以我们只需针对方法提出一套机制，这套机制就是 synchronized 关键字，它包括两种用法：synchronized 方法和 synchronized 块。

　　1. synchronized 方法：通过在方法声明中加入 synchronized关键字来声明 synchronized 方法。如：

public synchronized void accessVal(int newVal);

　　synchronized 方法控制对类成员变量的访问：每个类实例对应一把锁，每个 synchronized 方法都必须获得调用该方法的类实例的锁方能执行，否则所属线程阻塞，方法一旦执行，就独占该锁，直到从该方法返回时才将锁释放，此后被阻塞的线程方能获得该锁，重新进入可执行状态。这种机制确保了同一时刻对于每一个类实例，其所有声明为 synchronized 的成员函数中至多只有一个处于可执行状态（因为至多只有一个能够获得该类实例对应的锁），从而有效避免了类成员变量的访问冲突（只要所有可能访问类成员变量的方法均被声明为 synchronized）。

　　在 Java 中，不光是类实例，每一个类也对应一把锁，这样我们也可将类的静态成员函数声明为 synchronized ，以控制其对类的静态成员变量的访问。

　　synchronized 方法的缺陷：若将一个大的方法声明为synchronized 将会大大影响效率，典型地，若将线程类的方法 run() 声明为 synchronized ，由于在线程的整个生命期内它一直在运行，因此将导致它对本类任何 synchronized 方法的调用都永远不会成功。当然我们可以通过将访问类成员变量的代码放到专门的方法中，将其声明为 synchronized ，并在主方法中调用来解决这一问题，但是 Java 为我们提供了更好的解决办法，那就是 synchronized 块。

　　2. synchronized 块：通过 synchronized关键字来声明synchronized 块。语法如下：

synchronized(syncObject) {
//允许访问控制的代码
}

??synchronized 块是这样一个代码块，其中的代码必须获得对象 syncObject （如前所述，可以是类实例或类）的锁方能执行，具体机制同前所述。由于可以针对任意代码块，且可任意指定上锁的对象，故灵活性较高。
六：线程的阻塞

??为了解决对共享存储区的访问冲突，Java 引入了同步机制，现在让我们来考察多个线程对共享资源的访问，显然同步机制已经不够了，因为在任意时刻所要求的资源不一定已经准备好了被访问，反过来，同一时刻准备好了的资源也可能不止一个。为了解决这种情况下的访问控制问题，Java 引入了对阻塞机制的支持。

??阻塞指的是暂停一个线程的执行以等待某个条件发生（如某资源就绪），学过操作系统的同学对它一定已经很熟悉了。Java 提供了大量方法来支持阻塞，下面让我们逐一分析。

　　1. sleep() 方法：sleep() 允许指定以毫秒为单位的一段时间作为参数，它使得线程在指定的时间内进入阻塞状态，不能得到CPU 时间，指定的时间一过，线程重新进入可执行状态。

　　典型地，sleep() 被用在等待某个资源就绪的情形：测试发现条件不满足后，让线程阻塞一段时间后重新测试，直到条件满足为止。

　　2. suspend() 和 resume() 方法：两个方法配套使用，suspend()使得线程进入阻塞状态，并且不会自动恢复，必须其对应的resume() 被调用，才能使得线程重新进入可执行状态。典型地，suspend() 和 resume() 被用在等待另一个线程产生的结果的情形：测试发现结果还没有产生后，让线程阻塞，另一个线程产生了结果后，调用 resume() 使其恢复。

　　3. yield() 方法：yield() 使得线程放弃当前分得的 CPU 时间，但是不使线程阻塞，即线程仍处于可执行状态，随时可能再次分得 CPU 时间。调用 yield() 的效果等价于调度程序认为该线程已执行了足够的时间从而转到另一个线程。

　　4. wait() 和 notify() 方法：两个方法配套使用，wait() 使得线程进入阻塞状态，它有两种形式，一种允许指定以毫秒为单位的一段时间作为参数，另一种没有参数，前者当对应的 notify() 被调用或者超出指定时间时线程重新进入可执行状态，后者则必须对应的 notify() 被调用。

??初看起来它们与 suspend() 和 resume() 方法对没有什么分别，但是事实上它们是截然不同的。区别的核心在于，前面叙述的所有方法，阻塞时都不会释放占用的锁（如果占用了的话），而这一对方法则相反。

　　上述的核心区别导致了一系列的细节上的区别。

??首先，前面叙述的所有方法都隶属于 Thread 类，但是这一对却直接隶属于 Object 类，也就是说，所有对象都拥有这一对方法。初看起来这十分不可思议，但是实际上却是很自然的，因为这一对方法阻塞时要释放占用的锁，而锁是任何对象都具有的，调用任意对象的 wait() 方法导致线程阻塞，并且该对象上的锁被释放。而调用任意对象的notify()方法则导致因调用该对象的 wait() 方法而阻塞的线程中随机选择的一个解除阻塞（但要等到获得锁后才真正可执行）。

??其次，前面叙述的所有方法都可在任何位置调用，但是这一对方法却必须在 synchronized 方法或块中调用，理由也很简单，只有在synchronized 方法或块中当前线程才占有锁，才有锁可以释放。同样的道理，调用这一对方法的对象上的锁必须为当前线程所拥有，这样才有锁可以释放。因此，这一对方法调用必须放置在这样的 synchronized 方法或块中，该方法或块的上锁对象就是调用这一对方法的对象。若不满足这一条件，则程序虽然仍能编译，但在运行时会出现IllegalMonitorStateException 异常。

??wait() 和 notify() 方法的上述特性决定了它们经常和synchronized 方法或块一起使用，将它们和操作系统的进程间通信机制作一个比较就会发现它们的相似性：synchronized方法或块提供了类似于操作系统原语的功能，它们的执行不会受到多线程机制的干扰，而这一对方法则相当于 block 和wakeup 原语（这一对方法均声明为 synchronized）。它们的结合使得我们可以实现操作系统上一系列精妙的进程间通信的算法（如信号量算法），并用于解决各种复杂的线程间通信问题。

　　关于 wait() 和 notify() 方法最后再说明两点：

??第一：调用 notify() 方法导致解除阻塞的线程是从因调用该对象的 wait() 方法而阻塞的线程中随机选取的，我们无法预料哪一个线程将会被选择，所以编程时要特别小心，避免因这种不确定性而产生问题。

??第二：除了 notify()，还有一个方法 notifyAll() 也可起到类似作用，唯一的区别在于，调用 notifyAll() 方法将把因调用该对象的 wait() 方法而阻塞的所有线程一次性全部解除阻塞。当然，只有获得锁的那一个线程才能进入可执行状态。

??谈到阻塞，就不能不谈一谈死锁，略一分析就能发现，suspend() 方法和不指定超时期限的 wait() 方法的调用都可能产生死锁。遗憾的是，Java 并不在语言级别上支持死锁的避免，我们在编程中必须小心地避免死锁。

??以上我们对 Java 中实现线程阻塞的各种方法作了一番分析，我们重点分析了 wait() 和 notify() 方法，因为它们的功能最强大，使用也最灵活，但是这也导致了它们的效率较低，较容易出错。实际使用中我们应该灵活使用各种方法，以便更好地达到我们的目的。

　　七：守护线程

??守护线程是一类特殊的线程，它和普通线程的区别在于它并不是应用程序的核心部分，当一个应用程序的所有非守护线程终止运行时，即使仍然有守护线程在运行，应用程序也将终止，反之，只要有一个非守护线程在运行，应用程序就不会终止。守护线程一般被用于在后台为其它线程提供服务。

　　可以通过调用方法 isDaemon() 来判断一个线程是否是守护线程，也可以调用方法 setDaemon() 来将一个线程设为守护线程。

　　八：线程组

??线程组是一个 Java 特有的概念，在 Java 中，线程组是类ThreadGroup 的对象，每个线程都隶属于唯一一个线程组，这个线程组在线程创建时指定并在线程的整个生命期内都不能更改。你可以通过调用包含 ThreadGroup 类型参数的 Thread 类构造函数来指定线程属的线程组，若没有指定，则线程缺省地隶属于名为 system 的系统线程组。

??在 Java 中，除了预建的系统线程组外，所有线程组都必须显式创建。在 Java 中，除系统线程组外的每个线程组又隶属于另一个线程组，你可以在创建线程组时指定其所隶属的线程组，若没有指定，则缺省地隶属于系统线程组。这样，所有线程组组成了一棵以系统线程组为根的树。

??Java 允许我们对一个线程组中的所有线程同时进行操作，比如我们可以通过调用线程组的相应方法来设置其中所有线程的优先级，也可以启动或阻塞其中的所有线程。

　　Java 的线程组机制的另一个重要作用是线程安全。线程组机制允许我们通过分组来区分有不同安全特性的线程，对不同组的线程进行不同的处理，还可以通过线程组的分层结构来支持不对等安全措施的采用。Java 的 ThreadGroup 类提供了大量的方法来方便我们对线程组树中的每一个线程组以及线程组中的每一个线程进行操作。

　　九：总结

??在本文中，我们讲述了 Java 多线程编程的方方面面，包括创建线程，以及对多个线程进行调度、管理。我们深刻认识到了多线程编程的复杂性，以及线程切换开销带来的多线程程序的低效性，这也促使我们认真地思考一个问题：我们是否需要多线程？何时需要多线程？

??多线程的核心在于多个代码块并发执行，本质特点在于各代码块之间的代码是乱序执行的。我们的程序是否需要多线程，就是要看这是否也是它的内在特点。

??假如我们的程序根本不要求多个代码块并发执行，那自然不需要使用多线程；假如我们的程序虽然要求多个代码块并发执行，但是却不要求乱序，则我们完全可以用一个循环来简单高效地实现，也不需要使用多线程；只有当它完全符合多线程的特点时，多线程机制对线程间通信和线程管理的强大支持才能有用武之地，这时使用多线程才是值得的。

转自：http://ssby.blogdriver.com/ssby/

飘雪 2007-10-26 16:10 发表评论

java常用学习（转载）

飘雪 — Fri, 26 Oct 2007 05:52:00 GMT

摘要: JDBC初级应用实例(三) 发表人:wzh2352802 | 发表时间: 2007年一月23日, 13:53 再谈JDBC连结为什么要反复谈JDBC连结,因为所以JDBC的性能,最主要的就是JDBC连结,而SQL语句的优化,和JAVA编程无关,你的一个查询语句的效率,是你对于SQL语法的使用技巧,这一方面你就可请教DBA,而不是来看我这种程序设计... 阅读全文

飘雪 2007-10-26 13:52 发表评论

java虚拟机（转载）

飘雪 — Thu, 25 Oct 2007 10:15:00 GMT

一、什么是Java虚拟机

     当你谈到Java虚拟机时，你可能是指：
     1、抽象的Java虚拟机规范
     2、一个具体的Java虚拟机实现
     3、一个运行的Java虚拟机实例

二、Java虚拟机的生命周期

     一个运行中的Java虚拟机有着一个清晰的任务：执行Java程序。程序开始执行时他才运行，程序结束时他就停止。你在同一台机器上运行三个程序，就会有三个运行中的Java虚拟机。
     Java虚拟机总是开始于一个main()方法，这个方法必须是公有、返回void、直接受一个字符串数组。在程序执行时，你必须给Java虚拟机指明这个包换main()方法的类名。
     Main()方法是程序的起点，他被执行的线程初始化为程序的初始线程。程序中其他的线程都由他来启动。Java中的线程分为两种：守护线程（daemon）和普通线程（non-daemon）。守护线程是Java虚拟机自己使用的线程，比如负责垃圾收集的线程就是一个守护线程。当然，你也可以把自己的程序设置为守护线程。包含Main()方法的初始线程不是守护线程。
     只要Java虚拟机中还有普通的线程在执行，Java虚拟机就不会停止。如果有足够的权限，你可以调用exit()方法终止程序。

三、Java虚拟机的体系结构

     在Java虚拟机的规范中定义了一系列的子系统、内存区域、数据类型和使用指南。这些组件构成了Java虚拟机的内部结构，他们不仅仅为Java虚拟机的实现提供了清晰的内部结构，更是严格规定了Java虚拟机实现的外部行为。
     每一个Java虚拟机都由一个类加载器子系统（class loader subsystem），负责加载程序中的类型（类和接口），并赋予唯一的名字。每一个Java虚拟机都有一个执行引擎（execution engine）负责执行被加载类中包含的指令。
     程序的执行需要一定的内存空间，如字节码、被加载类的其他额外信息、程序中的对象、方法的参数、返回值、本地变量、处理的中间变量等等。Java虚拟机将这些信息统统保存在数据区（data areas）中。虽然每个Java虚拟机的实现中都包含数据区，但是Java虚拟机规范对数据区的规定却非常的抽象。许多结构上的细节部分都留给了 Java虚拟机实现者自己发挥。不同Java虚拟机实现上的内存结构千差万别。一部分实现可能占用很多内存，而其他以下可能只占用很少的内存；一些实现可能会使用虚拟内存，而其他的则不使用。这种比较精炼的Java虚拟机内存规约，可以使得Java虚拟机可以在广泛的平台上被实现。
     数据区中的一部分是整个程序共有，其他部分被单独的线程控制。每一个Java虚拟机都包含方法区（method area）和堆（heap），他们都被整个程序共享。Java虚拟机加载并解析一个类以后，将从类文件中解析出来的信息保存与方法区中。程序执行时创建的对象都保存在堆中。
     当一个线程被创建时，会被分配只属于他自己的PC寄存器“pc register”（程序计数器）和Java堆栈（Java stack）。当线程不掉用本地方法时，PC寄存器中保存线程执行的下一条指令。Java堆栈保存了一个线程调用方法时的状态，包括本地变量、调用方法的参数、返回值、处理的中间变量。调用本地方法时的状态保存在本地方法堆栈中（native method stacks），可能再寄存器或者其他非平台独立的内存中。
     Java堆栈有堆栈块（stack frames (or frames)）组成。堆栈块包含Java方法调用的状态。当一个线程调用一个方法时，Java虚拟机会将一个新的块压到Java堆栈中，当这个方法运行结束时，Java虚拟机会将对应的块弹出并抛弃。
     Java虚拟机不使用寄存器保存计算的中间结果，而是用Java堆栈在存放中间结果。这是的Java虚拟机的指令更紧凑，也更容易在一个没有寄存器的设备上实现Java虚拟机。
     图中的Java堆栈中向下增长的，PC寄存器中线程三为灰色，是因为它正在执行本地方法，他的下一条执行指令不保存在PC寄存器中。

四、数据类型（Data Types）

     所有Java虚拟机中使用的数据都有确定的数据类型，数据类型和操作都在Java虚拟机规范中严格定义。Java中的数据类型分为原始数据类型（primitive types）和引用数据类型（reference type）。引用类型依赖于实际的对象，但不是对象本身。原始数据类型不依赖于任何东西，他们就是本身表示的数据。
所有Java程序语言中的原始数据类型，都是Java虚拟机的原始数据类型，除了布尔型（boolean）。当编译器将Java源代码编译为自己码时，使用整型（int）或者字节型（byte）去表示布尔型。在Java虚拟机中使用整数0表示布尔型的false，使用非零整数表示布尔型的true，布尔数组被表示为字节数组，虽然他们可能会以字节数组或者字节块（bit fields）保存在堆中。
     除了布尔型，其他Java语言中的原始类型都是Java虚拟机中的数据类型。在Java中数据类型被分为：整形的byte，short，int，long；char和浮点型的float，double。Java语言中的数据类型在任何主机上都有同样的范围。
     在Java虚拟机中还存在一个Java语言中不能使用的原始数据类型返回值类型（returnValue）。这种类型被用来实现Java程序中的“finally clauses”，具体的参见18章的“Finally Clauses”。
     引用类型可能被创建为：类类型（class type），接口类型（interface type），数组类型（array type）。他们都引用被动态创建的对象。当引用类型引用null时，说明没有引用任何对象。
     Java虚拟机规范只定义了每一种数据类型表示的范围，没有定义在存储时每种类型占用的空间。他们如何存储由Java虚拟机的实现者自己决定。关于浮点型更多信息参见14章“Floating Point Arithmetic”。

TypeRange
byte8-bit signed two's complement integer (-27 to 27 - 1, inclusive)
short16-bit signed two's complement integer (-215 to 215 - 1, inclusive)
int32-bit signed two's complement integer (-231 to 231 - 1, inclusive)
long64-bit signed two's complement integer (-263 to 263 - 1, inclusive)
char16-bit unsigned Unicode character (0 to 216 - 1, inclusive)
float32-bit IEEE 754 single-precision float
double64-bit IEEE 754 double-precision float
returnValueaddress of an opcode within the same method
referencereference to an object on the heap, or null

五、字节长度

Java虚拟机中最小的数据单元式字（word），其大小由Java虚拟机的实现者定义。但是一个字的大小必须足够容纳byte，short，int， char，float，returnValue，reference；两个字必须足够容纳long，double。所以虚拟机的实现者至少提供的字不能小于31bits的字，但是最好选择特定平台上最有效率的字长。
在运行时，Java程序不能决定所运行机器的字长。字长也不会影响程序的行为，他只是在Java虚拟机中的一种表现方式。

六、类加载器子系统

     Java虚拟机中的类加载器分为两种：原始类加载器（primordial class loader）和类加载器对象（class loader objects）。原始类加载器是Java虚拟机实现的一部分，类加载器对象是运行中的程序的一部分。不同类加载器加载的类被不同的命名空间所分割。
     类加载器调用了许多Java虚拟机中其他的部分和java.lang包中的很多类。比如，类加载对象就是java.lang.ClassLoader子类的实例，ClassLoader类中的方法可以访问虚拟机中的类加载机制；每一个被Java虚拟机加载的类都会被表示为一个 java.lang.Class类的实例。像其他对象一样，类加载器对象和Class对象都保存在堆中，被加载的信息被保存在方法区中。
     1、加载、连接、初始化（Loading, Linking and Initialization）
类加载子系统不仅仅负责定位并加载类文件，他按照以下严格的步骤作了很多其他的事情：（具体的信息参见第七章的“类的生命周期”）
          1）、加载：寻找并导入指定类型（类和接口）的二进制信息
          2）、连接：进行验证、准备和解析
               ①验证：确保导入类型的正确性
               ②准备：为类型分配内存并初始化为默认值
               ③解析：将字符引用解析为直接饮用
          3）、初始化：调用Java代码，初始化类变量为合适的值
     2、原始类加载器（The Primordial Class Loader）
     每个Java虚拟机都必须实现一个原始类加载器，他能够加载那些遵守类文件格式并且被信任的类。但是，Java虚拟机的规范并没有定义如何加载类，这由 Java虚拟机实现者自己决定。对于给定类型名的类型，原始莱加载器必须找到那个类型名加“.class”的文件并加载入虚拟机中。
     3、类加载器对象
     虽然类加载器对象是Java程序的一部分，但是ClassLoader类中的三个方法可以访问Java虚拟机中的类加载子系统。
          1）、protected final Class defineClass(…)：使用这个方法可以出入一个字节数组，定义一个新的类型。
          2）、protected Class findSystemClass(String name)：加载指定的类，如果已经加载，就直接返回。
          3）、protected final void resolveClass(Class c)：defineClass()方法只是加载一个类，这个方法负责后续的动态连接和初始化。
     具体的信息，参见第八章“连接模型”（ The Linking Model）。
     4、命名空间
     当多个类加载器加载了同一个类时，为了保证他们名字的唯一性，需要在类名前加上加载该类的类加载器的标识。具体的信息，参见第八章“连接模型”（ The Linking Model）。

七、方法区（The Method Area）

     在Java虚拟机中，被加载类型的信息都保存在方法区中。这写信息在内存中的组织形式由虚拟机的实现者定义，比如，虚拟机工作在一个“little- endian”的处理器上，他就可以将信息保存为“little-endian”格式的，虽然在Java类文件中他们是以“big-endian”格式保存的。设计者可以用最适合并地机器的表示格式来存储数据，以保证程序能够以最快的速度执行。但是，在一个只有很小内存的设备上，虚拟机的实现者就不会占用很大的内存。
     程序中的所有线程共享一个方法区，所以访问方法区信息的方法必须是线程安全的。如果你有两个线程都去加载一个叫Lava的类，那只能由一个线程被容许去加载这个类，另一个必须等待。
     在程序运行时，方法区的大小是可变的，程序在运行时可以扩展。有些Java虚拟机的实现也可以通过参数也订制方法区的初始大小，最小值和最大值。
     方法区也可以被垃圾收集。因为程序中的内由类加载器动态加载，所有类可能变成没有被引用（unreferenced）的状态。当类变成这种状态时，他就可能被垃圾收集掉。没有加载的类包括两种状态，一种是真正的没有加载，另一个种是“unreferenced”的状态。详细信息参见第七章的类的生命周期（The Lifetime of a Class）。
     1、类型信息（Type Information）
          每一个被加载的类型，在Java虚拟机中都会在方法区中保存如下信息：
          1）、类型的全名（The fully qualified name of the type）
          2）、类型的父类型的全名（除非没有父类型，或者弗雷形式java.lang.Object）（The fully qualified name of the typeís direct superclass）
          3）、给类型是一个类还是接口（class or an interface）（Whether or not the type is a class ）
          4）、类型的修饰符（public，private，protected，static，final，volatile，transient等）（The typeís modifiers）
          5）、所有父接口全名的列表（An ordered list of the fully qualified names of any direct superinterfaces）
          类型全名保存的数据结构由虚拟机实现者定义。除此之外，Java虚拟机还要为每个类型保存如下信息：
          1）、类型的常量池（The constant pool for the type）
          2）、类型字段的信息（Field information）
          3）、类型方法的信息（Method information）
          4）、所有的静态类变量（非常量）信息（All class (static) variables declared in the type, except constants）
          5）、一个指向类加载器的引用（A reference to class ClassLoader）
          6）、一个指向Class类的引用（A reference to class Class）

          1）、类型的常量池（The constant pool for the type）
          常量池中保存中所有类型是用的有序的常量集合，包含直接常量（literals）如字符串、整数、浮点数的常量，和对类型、字段、方法的符号引用。常量池中每一个保存的常量都有一个索引，就像数组中的字段一样。因为常量池中保存中所有类型使用到的类型、字段、方法的字符引用，所以它也是动态连接的主要对象。详细信息参见第六章“The Java Class File”。
          2）、类型字段的信息（Field information）
          字段名、字段类型、字段的修饰符（public，private，protected，static，final，volatile，transient等）、字段在类中定义的顺序。
          3）、类型方法的信息（Method information）
          方法名、方法的返回值类型（或者是void）、方法参数的个数、类型和他们的顺序、字段的修饰符（public，private，protected，static，final，volatile，transient等）、方法在类中定义的顺序
          如果不是抽象和本地本法还需要保存
          方法的字节码、方法的操作数堆栈的大小和本地变量区的大小（稍候有详细信息）、异常列表（详细信息参见第十七章“Exceptions”。）
          4）、类（静态）变量（Class Variables）
          类变量被所有类的实例共享，即使不通过类的实例也可以访问。这些变量绑定在类上（而不是类的实例上），所以他们是类的逻辑数据的一部分。在Java虚拟机使用这个类之前就需要为类变量（non-final）分配内存
          常量（final）的处理方式于这种类变量（non-final）不一样。每一个类型在用到一个常量的时候，都会复制一份到自己的常量池中。常量也像类变量一样保存在方法区中，只不过他保存在常量池中。（可能是，类变量被所有实例共享，而常量池是每个实例独有的）。Non-final类变量保存为定义他的类型数据（data for the type that declares them）的一部分，而final常量保存为使用他的类型数据（data for any type that uses them）的一部分。详情参见第六章“The Java Class FileThe Java Class File”
          5）、指向类加载器的引用（A reference to class ClassLoader）
          每一个被Java虚拟机加载的类型，虚拟机必须保存这个类型是否由原始类加载器或者类加载器加载。那些被类加载器加载的类型必须保存一个指向类加载器的引用。当类加载器动态连接时，会使用这条信息。当一个类引用另一个类时，虚拟机必须保存那个被引用的类型是被同一个类加载器加载的，这也是虚拟机维护不同命名空间的过程。详情参见第八章“The Linking Model”
          6）、指向Class类的引用（A reference to class Class）
          Java虚拟机为每一个加载的类型创建一个java.lang.Class类的实例。你也可以通过Class类的方法：
public static Class forName(String className)来查找或者加载一个类，并取得相应的Class类的实例。通过这个Class类的实例，我们可以访问Java虚拟机方法区中的信息。具体参照Class类的JavaDoc。
     2、方法列表（Method Tables）
     为了更有效的访问所有保存在方法区中的数据，这些数据的存储结构必须经过仔细的设计。所有方法区中，除了保存了上边的那些原始信息外，还有一个为了加快存取速度而设计的数据结构，比如方法列表。每一个被加载的非抽象类，Java虚拟机都会为他们产生一个方法列表，这个列表中保存了这个类可能调用的所有实例方法的引用，报错那些父类中调用的方法。详情参见第八章“The Linking Model”

八、堆
     当Java程序创建一个类的实例或者数组时，都在堆中为新的对象分配内存。虚拟机中只有一个堆，所有的线程都共享他。
     1、垃圾收集（Garbage Collection）
     垃圾收集是释放没有被引用的对象的主要方法。它也可能会为了减少堆的碎片，而移动对象。在Java虚拟机的规范中没有严格定义垃圾收集，只是定义一个Java虚拟机的实现必须通过某种方式管理自己的堆。详情参见第九章“Garbage Collection”。
     2、对象存储结构（Object Representation）
     Java虚拟机的规范中没有定义对象怎样在堆中存储。每一个对象主要存储的是他的类和父类中定义的对象变量。对于给定的对象的引用，虚拟机必须嫩耨很快的定位到这个对象的数据。另为，必须提供一种通过对象的引用方法对象数据的方法，比如方法区中的对象的引用，所以一个对象保存的数据中往往含有一个某种形式指向方法区的指针。
     一个可能的堆的设计是将堆分为两个部分：引用池和对象池。一个对象的引用就是指向引用池的本地指针。每一个引用池中的条目都包含两个部分：指向对象池中对象数据的指针和方法区中对象类数据的指针。这种设计能够方便Java虚拟机堆碎片的整理。当虚拟机在对象池中移动一个对象的时候，只需要修改对应引用池中的指针地址。但是每次访问对象的数据都需要处理两次指针。下图演示了这种堆的设计。在第九章的“垃圾收集”中的HeapOfFish Applet演示了这种设计。
     另一种堆的设计是：一个对象的引用就是一个指向一堆数据和指向相应对象的偏移指针。这种设计方便了对象的访问，可是对象的移动要变的异常复杂。下图演示了这种设计
     当程序试图将一个对象转换为另一种类型时，虚拟机需要判断这种转换是否是这个对象的类型，或者是他的父类型。当程序适用instanceof语句的时候也会做类似的事情。当程序调用一个对象的方法时，虚拟机需要进行动态绑定，他必须判断调用哪一个类型的方法。这也需要做上面的判断。
     无论虚拟机实现者使用哪一种设计，他都可能为每一个对象保存一个类似方法列表的信息。因为他可以提升对象方法调用的速度，对提升虚拟机的性能非常重要，但是虚拟机的规范中比没有要求必须实现类似的数据结构。下图描述了这种结构。图中显示了一个对象引用相关联的所有的数据结构，包括：
          1）、一个指向类型数据的指针
          2）、一个对象的方法列表。方法列表是一个指向所有可能被调用对象方法的指针数组。方法数据包括三个部分：操作码堆栈的大小和方法堆栈的本地变量区；方法的字节码；异常列表。
          每一个Java虚拟机中的对象必须关联一个用于同步多线程的lock(mutex)。同一时刻，只能有一个对象拥有这个对象的锁。当一个拥有这个这个对象的锁，他就可以多次申请这个锁，但是也必须释放相应次数的锁才能真正释放这个对象锁。很多对象在整个生命周期中都不会被锁，所以这个信息只有在需要时才需要添加。很多Java虚拟机的实现都没有在对象的数据中包含“锁定数据”，只是在需要时才生成相应的数据。除了实现对象的锁定，每一个对象还逻辑关联到一个“wait set”的实现。锁定帮组线程独立处理共享的数据，不需要妨碍其他的线程。“wait set”帮组线程协作完成同一个目标。“wait set”往往通过Object类的wait()和notify()方法来实现。
     垃圾收集也需要堆中的对象是否被关联的信息。Java虚拟机规范中指出垃圾收集一个运行一个对象的finalizer方法一次，但是容许 finalizer方法重新引用这个对象，当这个对象再次不被引用时，就不需要再次调用finalize方法。所以虚拟机也需要保存finalize方法是否运行过的信息。更多信息参见第九章的“垃圾收集”
     3、数组的保存（Array Representation）
在Java 中，数组是一种完全意义上的对象，他和对象一样保存在堆中、有一个指向Class类实例的引用。所有同一维度和类型的数组拥有同样的Class，数组的长度不做考虑。对应Class的名字表示为维度和类型。比如一个整型数据的Class为“[I”，字节型三维数组Class名为“[[[B”，两维对象数据 Class名为“[[Ljava.lang.Object”。
多维数组被表示为数组的数组，如下图：
     数组必须在堆中保存数组的长度，数组的数据和一些对象数组类型数据的引用。通过一个数组引用的，虚拟机应该能够取得一个数组的长度，通过索引能够访问特定的数据，能够调用Object定义的方法。Object是所有数据类的直接父类。更多信息参见第六章“类文件”。

九、PC寄存器（程序计数器）（The Program Counter）

每一个线程开始执行时都会被创建一个程序计数器。程序计数器只有一个字长（word），所以它能够保存一个本地指针和returnValue。当线程执行时，程序计数器中存放了正在执行指令的地址，这个地址可以使一个本地指针，也可以使一个从方法字节码开始的偏移指针。如果执行本地方法，程序计数器的值没有被定义。

十、Java堆栈（The Java Stack）

     当一个线程启动时，Java虚拟机会为他创建一个Java堆栈。Java堆栈用一些离散的frame类纪录线程的状态。Java虚拟机堆Java堆栈的操作只有两种：压入和弹出frames。
     线程中正在执行的方法被称为当前方法（current method），当前方法所对应的frame被称为当前帧（current frame）。定义当前方法的类被称为当前类（current class），当前类的常量池被称为当前常量池（current constant pool.）。当线程执行时，Java虚拟机会跟踪当前类和当前常量池。但线程操作保存在帧中的数据时，他只操作当前帧的数据。
     当线程调用一个方法时，虚拟机会生成一个新的帧，并压入线程的Java堆栈。这个新的帧变成当前帧。当方法执行时，他使用当前帧保存方法的参数、本地变量、中间结构和其他数据。方法有两种退出方式：正常退出和异常推出。无论方法以哪一种方式推出，Java虚拟机都会弹出并丢弃方法的帧，上一个方法的帧变为当前帧。
     所有保存在帧中的数据都只能被拥有它的线程访问，线程不能访问其他线程的堆栈中的数据。所以，访问方法的本地变量时，不需要考虑多线程同步。
     和方法区、堆一样，Java堆栈不需要连续的内存空间，它可以被保存在一个分散的内存空间或者堆上。堆栈具体的数据和长度都有Java虚拟机的实现者自己定义。一些实现可能提供了执行堆栈最大值和最小值的方法。

十一、堆栈帧（The Stack Frame）

     堆栈帧包含三部分：本地变量、操作数堆栈和帧数据。本地变量和操作数堆栈的大小都是一字（word）为单位的，他们在编译就已经确定。帧数据的大小取决于不同的实现。当程序调用一个方法时，虚拟机从类数据中取得本地变量和操作数堆栈的大小，创建一个合适大小和帧，然后压入Java堆栈中。
     1、本地变量（Local Variables）
     本地变量在Java堆栈帧中被组织为一个从0计数的数组，指令通过提供他们的索引从本地变量区中取得相应的值。Int,float,reference, returnValue占一个字，byte,short,char被转换成int然后存储，long和doubel占两个字。
     指令通过提供两个字索引中的前一个来取得long,doubel的值。比如一个long的值存储在索引3，4上，指令就可以通过3来取得这个long类型的值。
     本地变量区中包含了方法的参数和本地变量。编译器将方法的参数以他们申明的顺序放在数组的前面。但是编译器却可以将本地变量任意排列在本地变量数组中，甚至两个本地变量可以公用一个地址，比如，当两个本地变量在两个不交叠的区域内，就像循环变量i,j。
     虚拟机的实现者可以使用任何结构来描述本地变量区中的数据，虚拟机规范中没有定义如何存储long和doubel。
     2、操作数堆栈（Operand Stack）
     向本地变量一样，操作数堆栈也被组织为一个以字为单位的数组。但是不像本地变量那样通过索引访问，而是通过push和pop值来实现访问的。如果一个指令push一个值到堆栈中，那么下一个指令就可以pop并且使用这个值。
     操作数堆栈不像程序计数器那样不可以被指令直接访问，指令可以直接访问操作数堆栈。Java虚拟机是一个以堆栈为基础，而不是以寄存器为基础的，因为它的指令从堆栈中取得操作数，而不是同寄存器中。当然，指令也可以从其他地方去的操作数，比如指令后面的操作码，或者常量池。但是Java虚拟机指令主要是从操作数堆栈中取得他们需要的操作数。
     Java虚拟机将操作数堆栈视为工作区，很多指令通过先从操作数堆栈中pop值，在处理完以后再将结果push回操作数堆栈。一个add的指令执行过程如下图所示：先执行iload_0和iload_1两条指令将需要相加的两个数，从本地方法区中取出，并push到操作数堆栈中；然后执行iadd指令，现 pop出两个值，相加，并将结果pusp进操作数堆栈中；最后执行istore_2指令，pop出结果，赋值到本地方法区中。
     3、帧数据（Frame Data）
     处理本地变量和操作数堆栈以外，java堆栈帧还包括了为了支持常量池，方法返回值和异常分发需要的数据，他们被保存在帧数据中。
     当虚拟机遇到使用指向常量池引用的指令时，就会通过帧数据中指向常量区的指针来访问所需要的信息。前面提到过，常量区中的引用在最开始时都是符号引用。即使当虚拟机检查这些引用时，他们也是字符引用。所以虚拟机需要在这时转换这个引用。
     当一个方法正常返回时，虚拟机需要重建那个调用这个方法的方法的堆栈帧。如果执行完的方法有返回值，虚拟机就需要将这个值push进调用方法的哪个操作数堆栈中。
     帧数据中也包含虚拟机用来处理异常的异常表的引用。异常表定义了一个被catch语句保护的一段字节码。每一个异常表中的个体又包含了需要保护的字节玛的范围，和异常被捕捉到时需要执行的字节码的位置。当一个方法抛出一个异常时，Java虚拟机就是用异常表去判断如何处理这个异常。如果虚拟机找到了一个匹配的catch，他就会将控制权交给catch语句。如果没有找到匹配的catch，方法就会异常返回，然后再调用的方法中继续这个过程。
     除了以上的三个用途外，帧数据还可能包含一些依赖于实现的数据，比如调试的信息。

十二、本地方法堆栈

本地方法区依赖于虚拟机的不同实现。虚拟机的实现者可以自己决定使用哪一种机制去执行本地方法。
任何本地方法接口（Native Method Interface）都使用某种形式的本地方法堆栈。

十三、执行引擎

     一个java虚拟机实现的核心就是执行引擎。在Java虚拟机规范，执行引擎被描述为一系列的指令。对于每一个指令，规范都描述了他们应该做什么，但是没有说要如何去做。
     1、指令集
     在Java虚拟机中一个方法的字节码流就是一个指令的序列。每一个指令由一个字节的操作码（Opcode）和可能存在的操作数（Operands）。操作码指示去做什么，操作数提供一些执行这个操作码可能需要的额外的信息。一个抽象的执行引擎每次执行一个指令。这个过程发生在每一个执行的线程中。
有时，执行引擎可能会遇到一个需要调用本地方法的指令，在这种情况下，执行引擎会去试图调用本地方法，但本地方法返回时，执行引擎会继续执行字节码流中的下一个指令。本地方法也可以看成对Java虚拟机中的指令集的一种扩充。
     决定下一步执行那一条指令也是执行引擎工作的一部分。执行引擎有三种方法去取得下一条指令。多数指令会执行跟在他会面的指令；一些像goto， return的指令，会在他们执行的时候决定他们的下一条指令；当一个指令抛出异常时，执行引擎通过匹配catch语句来决定下一条应该执行的指令。
     平台独立性、网络移动性、安全性左右了Java虚拟机指令集的设计。平台独立性是指令集设计的主要影响因素之一。基于堆栈的结构使得Java虚拟机可以在更多的平台上实现。更小的操作码，紧凑的结构使得字节码可以更有效的利用网络带宽。一次性的字节码验证，使得字节码更安全，而不影响太多的性能。
     2、执行技术
     许多种执行技术可以用在Java虚拟机的实现中：解释执行，及时编译（just-in-time compiling），hot-spot compiling,native execution in silicon。
     3、线程
     Java虚拟机规范定义了一种为了在更多平台上实现的线程模型。Java线程模型的一个目标时可以利用本地线程。利用本地线程可以让Java程序中的线程能过在多处理器机器上真正的同时执行。
     Java线程模型的一个代价就是线程优先级，一个Java线程可以在1-10的优先级上运行。1最低，10最高。如果设计者使用了本地线程，他们可能将这 10个优先级映射到本地优先级上。Java虚拟机规范只定义了，高一点优先级的线程可以却一些cpu时间，低优先级的线程在所有高优先级线程都堵塞时，也可以获取一些cpu时间，但是这没有保证：低优先级的线程在高优先级线程没有堵塞时不可以获得一定的cpu时间。因此，如果需要在不同的线程间协作，你必须使用的“同步（synchronizatoin）”。
     同步意味着两个部分：对象锁（object locking）和线程等待、激活(thread wait and notify)。对象锁帮助线程可以不受其他线程的干扰。线程等待、激活可以让不同的线程进行协作。
     在Java虚拟机的规范中，Java线程被描述为变量、主内存、工作内存。每一个Java虚拟机的实例都有一个主内存，他包含了所有程序的变量：对象、数组合类变量。每一个线程都有自己的工作内存，他保存了哪些他可能用到的变量的拷贝。规则：
          1）、从主内存拷贝变量的值到工作内存中
          2）、将工作内存中的值写会主内存中
     如果一个变量没有被同步化，线程可能以任何顺序更新主内存中的变量。为了保证多线程程序的正确的执行，必须使用同步机制。

十四、本地方法接口（Native Method Interface）

Java虚拟机的实现并不是必须实现本地方法接口。一些实现可能根本不支持本地方法接口。Sun的本地方法接口是JNI(Java Native Interface)。

十五、现实中的机器（The Real Machine）

十六、数学方法：仿真(Eternal Math : A Simulation)
本文转自：http://www.blogjava.net/cheneyfree

飘雪 2007-10-25 18:15 发表评论

在 MyEclipse 5.1GA 上使用 XFire 编写 Web Service （转载）

飘雪 — Wed, 24 Oct 2007 07:11:00 GMT

在 MyEclipse 5.1GA 上使用 XFire 编写 Web Service

Posted on 2006-11-16 00:04 Stephen Wong 阅读(1320) 评论(0) 编辑收藏所属分类: WebService 、Java 、J2EE 、Java 开发环境

   来源：http://tech.it168.com/j/e/2006-10-28/200610281432707.shtml    （红色部分为实验批注）

附：MyEclipse 5.0 官方提供的图文教程：

http://www.myeclipseide.com/ContentExpress-display-ceid-81.html#webservices

   开发环境
    Sun Java 5+ Eclipse 3.2 +MyEclipse 5.0.0.

    概述

    本文介绍了使用MyEclipse Web Service来迅速开发和测试一个HelloWorld Web Service,其中包括:
    1. 介绍了MyEclipse Web Services的基本概念
    2. 创建一个MyEclipse Web Services工程
    3. 创建一个简单的HelloWorld Web Service
    4. 在Web容器中,如Tomcat 5中部署Web Service
    5. 使用Web Services Explorer来测试部署的Web Services

    XFire Java SOAP框架概述
    MyEclipse Web Services是建立在XFire Java SOAP框架和工具基础上的, XFire是一款开源的Java SOAP框架。它拥有一个轻量级的信息处理模块，通过STAX来与SOAP信息相结合。提供了一个工作在Web Services下的简单API，支持POJO和schema开发. XFire支持 Web Services standards,Spring 整合, 支持JBI , 支持 JAXB ,XMLBeans,Java 5 和JAX-WS.并支持HTTP, JMS, XMPP, In-memory传输协议.

    一. 创建Web Service工程

    在MyEclipse 5.0中引入了一个新的工程类型即Web Service工程,该工程扩展了MyEclipse Web Project来支持额外的Web Service配置,开发和部署.本部分将使用Web Services Project wizard来创建和配置一个新的Web Service Projects Web Service Wizard将完成下列的动作:
    创建MyEclipse J2EE Web Project
    在工程中的web.xml文件中配置XFire Servlet
    创建XFire services.xml配置文件
    在工程中的构建路径中添加MyEclipse-XFire类库
    添加一个指定的MyEclipse web project builder到.projects文件,以便部署services.xml文件到它合适的位置.如: /WEB-INF/classes/META-INF/xfire/

    运行Web Service Project Wizard
    该向导包括三个页面, Page-1搜集Web Project配置细节, Page-2搜集XFire配置细节, Page-3在新建的构建路径中配置XFire类库
    1. 执行Web Services Project Wizard.
       1). 选择File>New>Other
       2). 扩展MyEclipse种类按照J2EE工程的种类
       3). 选择Web Services Project然后点击Next,如图所示

Figure-1: New Project Wizard Launcher
2. 添加Project Name,点击Next

Figure-2: Page-2, Collecting web configuration details
3.在向导的Page-2中添加XFire servlet和service.xml文件的配置信息,按照默认的值即可.

Figure-3: XFire servlet and services.xml configuration
4.在向导的Page-3中选择类库添加到工程的构建路径中,其中XFire Core Library是需要的,如果要在工程中开发一个客户端应用, XFire HTTP Client Libraries也是需要的.

    Figure-4: Selecting XFire libraries to add to new web service project buildpath

    5选择Finish完成Web Service工程的创建过程
    Figure-5,显示了新创建的HelloWorld Web Service工程的组织结构,Web Service 工程和一个标准的MyEclipse Web工程很相似. XFire Web Service配置元素如图红色区域显示:

    Figure-5: Web services artifacts of a new web service project

    二. 创建Web Service-Code-first Strategy
    在这部分将用MyEclipse Web Service Wizard并通过使用Code-first Strategy来创建一个HelloWorldService示例.

    1. 执行MyEclipse Web Service Wizard,有两种方法来执行MyEclipse Web Service Wizard
    方法1.从MyEclipse perspective toolbar中来执行向导
    在打开的Web Service Wizard上的workbench上来选择新Web Service按钮
    方法2.从workbench menubar执行向导
    1. 从workbench menubar选择: File>New>Other>MyEclipse>Web Service

    Figure-6: Launching Web Service Wizard

    2. 在Page-1选择HelloWorld 工程并选择Create web service from Java bean
    3. 选择Next到Page-2

    Figure-7: Page-1 of new web service wizard

    4. 填写Web Service的名字HelloWorldService
    5. 选择Java Source folder或者选择New按钮来新建一个source folder
    6. 填写Java package或者通过选择Browse按钮来选择一个已经存在的package.也可以选择New按钮来新建一个Java package
    注意:对Service接口和Service执行的类的默认值是基于所填入Web Service名字来产生的.
    7. 选择Next来初始化Web Service的创建过程

Figure-8: Page-2 of new web service wizard.
该向导产生了IHelloWorldService Java接口和HelloWorldServiceImpl Java类.并且在services.xml配置文件中创建了一个实体(如图所示),注意到example(String message)方法在接口类中产生,当Web Service部署后作为一个测试操作.

Figure-9: Newly created HelloWorld interface and implementation class

Web Service 服务端服务接口代码：

package org.stephencat.ws;
//Generated by MyEclipse

public interface ISampleService {

    public String example(String message);

}

Web Service 服务端服务实现代码：

package org.stephencat.ws;
//Generated by MyEclipse

public class SampleServiceImpl implements ISampleService {

    public String example(String message) {
        return message + " This is Xfire !!";
    }

}

    三. 部署Web Service Project
    Web Service可以部署在任何MyEclipse支持的J2EE应用服务器上,该部分将演示如何在Tomcat 5 Web容器上部署HelloWorld工程.

    3.1部署HelloWorld Web Service Project

    Figure-10显示了如何部署HelloWorld应用.
    1. 从Server Manager中选择Deployer按钮(step-1)
    2. 在Server Deployments对话框中选择Add to create a new deployment (step-2)
    3. 在New Deployment对话框中选择HelloWorld工程并选择Exploded Archive选项
    4. 在New Deployment对话框选择Finish来将HelloWorld在Tomcat 5默认的位置中打包为WAR
    5. 选择OK完成部署

Figure-10: Three-step deployment process
新HelloWorld WAR部署将出现在Server Manager视图中Tomcat 5节点下.

    Figure-11: Servers Manager View depicting deployed HelloWorld web service project

    四. 启动Tomcat服务器（或 JBoss 服务器）

    五. 使用Web Service Explorer测试Web Service
    MyEclipse提供了一个Web Service Explorer来测试Web Service.
    1. 在MyEclipse perspective中选择toolbar button来执行Web Service Explorer

    Figure-15: Web Services Explorer launch button on workbench toolbar

    2. 选择WSDL模式(Figure-16)
    3. 在活动面板中键入HelloWorldService WSDL文档的URL

http://localhost:8080/wstest/services/SampleService?WSDL

Web Service Explorer将下载自动产生的WSDL文档,该WSDL文档由XFire framework,并产生一系列的操作能够调用service.
    4. 在活动面板中选择example操作并在in0域中键入HelloWorld
    5. 选择Go按钮来调用在HelloWorldService上的example操作,,结果出现在Status面板上

    Figure-16: Web Services Explorer testing HelloWorldService

    六. 创建Java Test客户端
    XFire提供了一个动态的代理框架,能够读取WSDL文档和创建潜在的消息服务使Java类来执行在Web Service的行为.该部分将为HelloWorld Web Service写一个Java Web Service客户端
    6.1增加XFire类库配置
    为了使example client能够在HelloWorld工程中运行,需要增加XFire HTTP Client类库到工程的构建路径中.
    1. 在Package Explore视图中右击HelloWorld工程选择Build Path>Add Library
    2. 选择MyEclipse Libraries
    3. 选择XFire HTTP Client Libraries

    Figure-17: Choosing the XFire HTTP Client Libraries
    4. 选择Finish
    6.2创建HelloWorldClient类
    执行Java类向导来创建HelloWorldClient类

Figure-18: HelloWorldClient defined in New Java Class Wizard.

Web Service 客户端代码如下:

package org.stephencat.ws;

import org.codehaus.xfire.*;
import org.codehaus.xfire.service.*;
import org.codehaus.xfire.service.binding.*;
import org.codehaus.xfire.client.*;

import java.net.*;

public class SampleClient {

    /**
     * @param args
     */
    public static void main(String[] args) {
        Service srvcModel = new
        ObjectServiceFactory().create(ISampleService.class);
        XFireProxyFactory factory =
           new XFireProxyFactory(XFireFactory.newInstance().getXFire());
        String url =
           "http://localhost:8080/wstest/services/SampleService";
        try {
            ISampleService srvc = (ISampleService)factory.create(srvcModel, url);
           String result = srvc.example("hello world");
           System.out.print(result);
        } catch (MalformedURLException e){
           e.printStackTrace();
        }

    }

}

该段代码定义了创建一个XFire web service proxy的过程,该代理支持POJO IHelloWorldService接口

右键点击Run As>Java Application或者Debug As>JavaApplication来运行或调试该程序

飘雪 2007-10-24 15:11 发表评论

Axis入门学习（转载）

飘雪 — Mon, 22 Oct 2007 03:24:00 GMT

RSS Feed for beginner

By subscribing to this Really Simple Syndication (RSS) feed, you can preview updates made to this space in any RSS reader or aggregator. RSS allows you to subscribe to feeds from several sources and automatically combines the information into one list. You can quickly browse the list without visiting each site to search for new information of interest to you.

Learn more about RSS

Subscribe to this feed in Live.com

Subscribe to this feed in an aggregator that supports one-click subscription

Using Apache-Axis to develop the WebService (Lesson 4)

This time, we will begin to write some cases for calling our service.

Service:

package server;

public class SayHello
{
      public String getName( String name )
      {
            return "hello " + name;
      }
}

Client:

public class SimpleSayHelloClient
{
        public static void main(String [] args) throws Exception {
              String endpoint = http://localhost:8080/learnws/services/SayHello;
              Service service = new Service();
              Call call    = (Call) service.createCall();
              call.setTargetEndpointAddress(new java.net.URL(endpoint));
              call.setOperationName("getName");
              String res = (String) call.invoke(new Object[]{"GuanYabei"});
              System.out.println(res);
         }

}

Ok, we have finished our code,now we will publish the service.First, we have to write a .bat file named deploy.bat include words following that :

set Axis_Lib=E:\workspace\learnws\context\WEB-INF\lib
set Java_Cmd=java -Djava.ext.dirs=%Axis_Lib%
set Axis_Servlet=http://localhost:8080/learnws/servlet/AxisServlet
%Java_Cmd% org.apache.axis.client.AdminClient -l%Axis_Servlet% deploy.wsdd

This .bat file exits under the src folder.

We can execute it and we will see a XML file called server-config.wsdd under the WEB-INF folder.

Well, now we can execute client code and we can see the words "hello GuanYabei".

We can generate cliend code by wsdl file as well. We can visite http://localhost:8080/learnws/services to download the SayHello.wsdl. And then we need a .bat file to generate clinet code by this SayHello.wsdl.

The bat context is following this:

set Axis_Lib=E:\workspace\learnws\context\WEB-INF\lib
set Java_Cmd=java -Djava.ext.dirs=%Axis_Lib%
set Output_Path=E:\workspace\learnws\src
set Package=server
%Java_Cmd% org.apache.axis.wsdl.WSDL2Java -o%Output_Path% -p%Package% SayHello.wsdl

the bat file called WSDL2Java.bat.

Executing WSDL2Java.bat, 4 files are generated. they are : SayHello_PortType.java , SayHelloService.java , SayHelloServiceLocator.java and SayHelloSoapBindingStub.java.

Now we can write client code like this:

package server;

import java.rmi.RemoteException;
import javax.xml.rpc.ServiceException;

public class SayHelloClient
{

      /**
        * @param args
        * @throws RemoteException
        */
         public static void main( String[] args )
         {
                SayHelloService service = new SayHelloServiceLocator();
                SayHello_PortType client = null;
                try
                {
                      client = service.getSayHello();
                }
                catch (ServiceException e)
                {
                       e.printStackTrace();
                }
                String retValue = null;
                try
                {
                       retValue = client.getName("clientname");
                }
                catch (RemoteException e)
                {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                }
                System.out.println(retValue);

}

If everything is successful , we will see the words "hello clientname";

Published Date: 四, 09 八月 2007 00:42:19 GMT
Read the full item

Using Apache-Axis to develop the WebService (Lesson 3)

Using WSDD to publish your service.

We have shown the how to install and config the Axis for developping the WebServie before this lesson. And We wriet a simple test to show how to call the services we published, but we often publish our services by a wsdd file in practice instead of the way that turn *.java to *.jws. This time, We'll close to the practice and show how to use WSDD file to publish our services!

Now, you can set up a new project for your webservice, my porject's name is learnws(for short learning WebService). its directory structure follow that :

learnws

|--context

|--WEB-INF

| |--lib (axis jars)

| |--classes (your webservice classes)

|--src (your webservice code)

OK,please config your tomcat for publishing this webapp,and then copy necessary jars to directory lib.

Please config your web.xml like this:

"-//Sun Microsystems, Inc.//DTD Web
Application 2.3//EN" "http://java.sun.com/dtd/web-app_2_3.dtd">

org.apache.axis.transport.http.AxisHTTPSessionListener

AxisServlet

org.apache.axis.transport.http.AxisServlet

AdminServlet

org.apache.axis.transport.http.AdminServlet

101

SOAPMonitorService

org.apache.axis.monitor.SOAPMonitorService

SOAPMonitorPort

5001

102

AxisServlet

/servlet/AxisServlet

AxisServlet

*.jws

AxisServlet

/services/*

SOAPMonitorService

/SOAPMonitor

wsdl

text/xml

xsd

text/xml

index.jsp

index.html

index.jws

Well, Now, we need a service, the code follow this:

package server;

public class SayHello
{
    public String getName( String name )
    {
         return "hello " + name;
    }
}

OK, we should write a deploy.wsdd file for grenterating file server-config.wsdd. Axis will publish our services by server-config.wsdd.

deploy.wsdd :

http://xml.apache.org/axis/wsdd/" xmlns:java="http://xml.apache.org/axis/wsdd/providers/java">

We can write a deploy.bat file to generate the server-config.wsdd:

OK, we can execute this bat file and then visite URL http://localhost:8080/learnws/servlet/AxisServlet. We can see the wsdl in web page if it is no exception!

If you can see the wsdl, you have finished the first step!

Published Date: 一, 06 八月 2007 05:39:16 GMT
Read the full item

How to use Hibernate3.2 Lesson 1

Hibernate is one of the most popular OR-MAPING tool. At present, its last version is hibernate3.2.4. It is even as titile said, we do not tell you what is hibernate,but I will tell you how to use hibernate! OK, let's begin!

First, you need to download the hibernate3.2.4.zip and hibernate-tool-3.2.0.zip from the website www.hibernate.org. And then you can unzip these zips.

Do you have the IDE-Eclipse? If you don't ,you need download it (We suggest you to download eclipse-3.2.2).

Copy all of the files that we unzip to hibernate-tool-3.2.0.zip to directory "configuration" and "features" under the eclipse home ? No, we needn't do it. We have another way!

We can make a dirctory "links" under the eclipse-home and make a file. The make file and its name is HibernateTools-3.2.0.beta9a.link.(attention: .link is necessary). The Context of the file is your hibernate-tool-3.2.0's path for example:path=D:\\extends_pugins\\HibernateTools-3.2.0.beta9a (my hibernate-tools folder is HibernateTools-3.2.0.beta9a).

Well, now, you can start up the Eclipse and you can see the 4 items from the New. Those are Hibernate XML Mapping file, Hibernate Configuration File, Hibernate Console Configuration and Hibernate Reverse Configuration.

Now, you should set up a project for hibernate in Eclipse. And then, load all of hibernate jars to your lib path. You can set up a DateBase for using hiberate to visite it.

OK, We have a rest, See you next lesson. bye!

Published Date: 二, 31 七月 2007 03:33:30 GMT
Read the full item

How can I do ?

Recently, I found my mood was not good. I didn't know when it was, I have even started to worried about my future!

What did I want? What did I need? Who can I be wanted? Maybe, I could tell your these answers many years ago, but now, I don't know really.

I have known that I must keep persistent efforts forever. I have known that I am never a lucky boy. Certainly, I have even known that I should believe in myself and my faith. But now, face to my current conditions, who can tell me how can I do?!

Now my job is very easy. It is too easy to set my heart at rest! But I don't need a rest, frankly speaking, I need more money, I need more money that was even my value and ability! I think I need a room which I can show myself!

Maybe I understand how can I do , maybe or not......

I pray... I pray that the God blesse me! I don't expect that I will turn to a lucky boy, I do only expect that my repayment will be even my payment!

All of words both are nonsense!

Published Date: 一, 30 七月 2007 15:01:56 GMT
Read the full item

Using Apache-Axis to develop the WebService (Lesson 2)

Last time We have showed how to install and config the axis1.4. Today we will continue the WebService trip!
As you know, this time, we will show how to develop a simple webservice application. We will use the case of HelloWorld.

1. coding a webservice application

   public class HelloWorld
   {
       public String getName( String name )
       {
           return "hello " + name;
       }
   }

We will copy the file HelloWorld.java to AXIS_HOME and turn HelloWorld.java to HelloWorld.wsdl. And then, we will restart the Tomcat before visiting URL http://localhost:8080/axis/HelloWorld.jws?wsdl.
You will see a page that display a XML context. The page context is WSDL,it told we what functions were offered by WebService.

ATTENTION :
Don't setup the java file in a package.

2. coding client and visit HelloWorld by DII.
   If we use DII to visit HelloWorld, we should find operation name and parameterOrder from the page.

   import javax.xml.namespace.QName;
   import org.apache.axis.client.Call;
   import org.apache.axis.client.Service;

   public class SayHelloClient
   {
      public static void main( String[] args )
      {
         String point = "http://localhost:8080/axis/HelloWorld.jws";
         Service service = new Service();
         try
         {
             Call call = null;
             call = (Call) service.createCall();
             call.setOperationName(new QName(
                                            point, "getName"));//提供方法名
             call.setTargetEndpointAddress(new java.net.URL(point));//提供接口地址
             String ret = (String) call.invoke(new Object[]
                                            { "GuanYabei" });//提供接口参数
             System.out.println("return value is " + ret);
          }
          catch (Exception e)
         {
             e.printStackTrace();
         }
      }
   }
   Now you can run this application via your IDE, you can see a word "return value is hello GuanYabei".

Published Date: 三, 25 七月 2007 02:13:09 GMT
Read the full item

Using Apache-Axis to develop the WebService (Lesson 1)

At present, there are two version axis(axis1.x and axis2) in Apache.
But we should understand the axis2 is not update version of axis1.x, so they are different each other.
I will introduce Axis1.4 to my viewers. ^_^

Installation And Configuration

1. download these from website
    axis-bin-1_4.zip http://www.apache.org/dist/ws/axis/1_4/axis-bin-1_4.zip
    axis-src-1_4.zip http://www.apache.org/dist/ws/axis/1_4/axis-src-1_4.zip
    javamail-1_4.zip http://java.sun.com/products/javamail/downloads/index.html
    xml-security-bin-1_3_0.zip http://xml.apache.org/security/dist/java-library/

2. unzip axis-bin-1_4.zip and copy webapps\axis to tomcat\webapps\

3. unzip axis-src-1_4.zip and copy lib\activation.jar to tomcat\common\lib\
unzip javamail-1_4.zip and copy mail.jar to tomcat\common\lib\

upzip xml-security-bin-1_3_0.zip and copy lib\xmlsec-1.3.0.jar to tomcat\common\lib
copy JDK_HOME\lib\tool.jar to tomcat\common\lib\

4. start up Tomcat and visit http://127.0.0.1:8080/axis
    you can see the Apache-AXIS page and click validation link.
    if you can see Axis Happiness Page without "Not Found words", you are successful.

5. config envionment variables

   TOMCAT_HOME=D:\Program Files\Apache Software Foundation\Tomcat 5.5
   AXIS_HOME=D:\Program Files\Apache Software Foundation\Tomcat 5.5\webapps\axis
   AXIS_LIB=%AXIS_HOME%\WEB-INF\lib
   AXISCLASSPATH=.;%AXIS_LIB%\axis.jar;%AXIS_LIB%\commons-discovery-0.2.jar;%AXIS_LIB%\commons-logging-1.0.4.jar;%AXIS_LIB%\jaxrpc.jar;%AXIS_LIB%\saaj.jar;%AXIS_LIB%\log4j-1.2.8.jar;%AXIS_LIB%axis-ant.jar;%TOMCAT_HOME%\common\lib\activation.jar

Published Date: 二, 24 七月 2007 06:24:35 GMT
Read the full item

My new glasses

Last Saturday, I bought a new glasses to instead of old one with me 5 years. The new glasses costed me 230 yuan, my friend, ZhuXixi, help me for choosing it. I like it very much.
The glasses' material is steel. In fact, I think titanium is better than steel, but all glasses style that was made in titanium did not apply me! So, at last, I bought the steel one. I think it looks good very well. its style suited my face. But my friend said I looks like PangLong(a singer and I don't like him),it spoils me -_-!
Now I hope I can bought the second glasses that was made in titanium.

Published Date: 二, 24 七月 2007 01:28:45 GMT
Read the full item

It doesn't matter. I will make persistent effort!

In the afternoon, I went to the TIBCAL Company and entered for an interview.To my surprise, the position was Technique Supported. Frankly speaking, I didn't even know what to do about that position. The interview was not all right. I had to talk about all words in English. But I knew that my English is very poor. At last, that man tested me had to talk with me in Chinese. I felt shame! Of course, if I only came up against this occasion, I thought I may not feel too bad. Today, July 12th 2007 year, I filed in my knowledge that I am proud of. I did not perfectly answer any question. In fact, some knowledge points were not held by myself too. I need learn more things about software technology and developing skill.

In spite of this, I was not discouraged. I knew this way is very long! I must make persistent effort!

Published Date: 四, 12 七月 2007 06:23:30 GMT
Read the full item

Enjoy my dreams

I has wanted to have a notebook-computer('NB' for short) myself since I was still a student at the college. But I did not have enough money to afford to pay it. Now, I earn money more and more, but I find that I can't still afford to pay it because of some reason. Then I changed my mind and I hoped that my firm can buy a NB to me. But it does not come true.

I dream of having a NB myself. Frankly speaking, I did not think it is only a dream for me in the past. Now I have still believed in that. So I need do my best to earn more money for my dream.

In fact,I think, I'm not really interested in having a NB. I am only interested in the thing that I do make great efforts for my dreams coming true.

Published Date: 六, 07 七月 2007 14:18:33 GMT
Read the full item

How can you understand ?

How can you understand that new sky usually is outside house.

How can you understand that lover may not apply to gathering.

How can you understand that losing love is not the incurable disease but only an ache.

How can you understand that she needn’t follow you forever , in spite of accompanying you in the past.

How can you understand that concern of friends is not all of sweet talk.

How can you understand that people who you don’t like to rap to concern you very much.

How can you understand that people who you depend on don’t love you sometimes.

How can you understand that you don’t catch up with her because she don’t want to be caught by you.

How can you understand that you don’t hold her by bearing and connivance.

How can you understand that being lonely doesn't belong to the love.

How can you understand that you should not be punished for her fault.

How can you understand that one person who love you indeed is waiting you at a distance.

The meaning of being lonely is that love is closing to you.

note:

incurable disease : 绝症

sweet talk : 甜言蜜语

rap to : 与….说话，搭理....

bearing and connivance : 忍受与纵容

indeed : 真正地

for you ,for me ,for everyone.
Published Date: 二, 03 七月 2007 13:43:57 GMT
Read the full item

The Most Valuable Program Language

What is the most valuable program language? you mast have your own answer. let me guess it.

mybe you can tell me that it is C++. well,if you can develop softwares or any applications by it, you will get a good salary! but how much ? I can tell you, 10000 yuan to 15000 yuan for common developers.

mybe you can tell me that it is Java or C#(C sharp). good, beyond all doubt,they are the most popular program language now. but C++'s value is lager than theirs.

in fact, I asked the same question to others. I do get the true answer is PPT (microsoft office power point). Why it is? We do not develop any softwares with it. Of course, you are right. but the thing that we are talking about is language's value and is not language's function. so if PPT compared with other program language from valuable aspect,it is the most valuable language.

the reason is very simple! other program language can give you a good salary for your job, but I think its value is too small! If you are good at writing PPT, you can obtain the big capital from investors. that's pretty penny!

do you understand now?

note:

pretty penny : a lot of money

Published Date: 五, 29 六月 2007 15:45:02 GMT
Read the full item

The Trip Of The Xingcheng-City

Last weekend I enjoyed an exciting trip with my friends. This is twice to visited Xingcheng. Last time we enjoyed the trip in last year of October. We arrived at the railway station of Calabash-island City by train in the early morning. Than We went to the Xingcheng City by car. The car covered distance in 30 minutes from Calabash-island to Xingcheng City.

We arrived at seashore first. I think I like the sea but I can’t swimming. We sat the sand beach and sang. The sky was very dark. I could not see any thing and only hear the sea.

if you ask me what is interesting for me, I can say “eating shrimps!”. We bought a lot of fresh shrimps from fisherfolks. The shrimp’s price is cheaper than Beijing’s. We ate many shrimp. It’s very delicious!

On Sunday We visited Xingcheng by car. We visited the ancestral wall and nearly every shops. My friend ZhuXixi bought a few of seashell. She like it very much. She had a great many of beautiful seashell. I think her room must be a seashell-museums.

At last We went home by train. We have a good time!

note:

Calabash-island 葫芦岛

shrimp 虾

Published Date: 四, 28 六月 2007 05:58:15 GMT
Read the full item

飘雪 2007-10-22 11:24 发表评论