Java关键字之native，strictfp，transient，volatile

Java关键字（keywords） 

• abstract    default    if            private      this 
  boolean     do         implements    protected    throw 
  break       double     import        public       throws 
  byte        else       instanceof    return       transient 
  case        extends    int           short        try 
  catch       final      interface     static       void 
  char        finally    long          strictfp     volatile 
  class       float      native        super        while 
  const       for        new           switch 
  continue    goto       package       synchronized

以上是java specifications中定义的keywords，一共48个，其中常见的三个看似是关键字的true, false, null,都不是关键字，而是作为一个单独标识类型。 
其中，不常用到的关键字有：const，goto，native，strictfp，transient，volatile。 
const和goto为java中的保留字。 
1. native 
native是方法修饰符。Native方法是由另外一种语言（如c/c++，FORTRAN，汇编）实现的本地方法。因为在外部实现了方法，所以在java代码中，就不需要声明了，有点类似于借口方法。Native可以和其他一些修饰符连用，但是abstract方法和Interface方法不能用native来修饰。 
Example：

Java代码 

1. public interface TestInterface {  
2.      void doMethod();  
3. }  
4. public class Test implements TestInterface {  
5.     public native void doMethod();  
6.     private native int doMethodB();  
7. 　　public native synchronized String doMethodC();  
8. 　　static native void doMethodD();  
9. }  

为什么需要使用native method？请参考： 
http://www.iteye.com/topic/72543  java Native Method初涉 
2. strictfp 
修饰类和方法，意思是FP-strict，精确浮点，符合IEEE-754规范的。当一个class或interface用strictfp声明，内部所有的float和double表达式都会成为strictfp的。Interface method不能被声明为strictfp的，class的可以。 
Example：

Java代码 

1. strictfp interface FPTest {  
2.      void methodA();  
3. }  
4. class FPClass implements FPTest {  
5.     public void methodA() {  
6.     }  
7.     public void methodB() {  
8. 　　}  
9. 　　public strictfp void methodC() {  
10. 　　}  
11. }  
12. class FPClassB {  
13.     strictfp void methodA() {  
14.     }  
15. }  

3.transient 
变量修饰符。标记为transient的变量，在对象存储时，这些变量状态不会被持久化。当对象序列化的保存在存储器上时，不希望有些字段数据被保存，为了保证安全性，可以把这些字段声明为transient。 
4. volatile 

        在当前的Java内存模型下，线程可以把变量保存在本地内存（比如机器的寄存器）中，而不是直接在主存中进行读写。这就可能造成一个线程在主存中修改了一个变量的值，而另外一个线程还继续使用它在寄存器中的变量值的拷贝，造成数据的不一致。 
        要解决这个问题，只需要像在本程序中的这样，把该变量声明为volatile（不稳定的）即可，这就指示JVM，这个变量是不稳定的，每次使用它都到主存中进行读取。一般说来，多任务环境下各任务间共享的标志都应该加volatile修饰。 

      volatile修饰变量。在每次被线程访问时，都强迫从共享内存中重读该成员变量的值。而且，当成员变量发生变化时，强迫线程将变化值回写到共享内存。这样在任何时刻，两个不同的线程总是看到某个成员变量的同一个值。 
看看Java Language Specification中的例子。 

 

使用建议：在两个或者更多的线程访问的成员变量上使用volatile。当要访问的变量已在synchronized代码块中，或者为常量时，不必使用。 

由于使用volatile屏蔽掉了VM中必要的代码优化，所以在效率上比较低，因此一定在必要时才使用此关键字。 

条件：一个线程不停的调用方法one()，一个线程不停的调用方法two()。我测试过多次，这种情况好像一直没有出现。

Java代码 

1. class Test {  
2.     static int i = 0, j = 0;  
3.     static void one() { i++; j++; }  
4.     static void two() {  
5.         System.out.println("i=" + i + " j=" + j);  
6.     }  
7. }  

结果偶尔会出现j大于i的情况，因为方法没有同步，所以会出现i和j可能不是一次更新。一种防止这种情况发生的办法就是声明两个方法为synchronized 的。

Java代码 

1. class Test {  
2.     static int i = 0, j = 0;  
3.     static synchronized void one() { i++; j++; }  
4.     static synchronized void two() {  
5.         System.out.println("i=" + i + " j=" + j);  
6.     }  
7. }  

这样可以防止两个方法同时被执行，还可以保证j和i被同时更新，这样一来i和j的值一直是一样的。 
另外一种途径就是把i和j声明为volatile。

Java代码 

1. class Test {  
2.     static volatile int i = 0, j = 0;  
3.     static void one() { i++; j++; }  
4.     static void two() {  
5.         System.out.println("i=" + i + " j=" + j);  
6.     }  
7. }