关于native,transient,volatile三个关键字的使用

Question

学JAVA快一年,突然发现有3个关键字竟然从没接触过.
想了解下这3个关键字的用法和功能,最好有例子

Answer 1

1，native是方法修饰符。Native方法是由另外一种语言（如c/c++，FORTRAN，汇编）实现的本地方法。一般用于JNI中。public class testdll 
{ 
static 
{ 
System.loadLibrary("test"); 
}     public native static int get();     public native static void set(int i);     public static void main(String[] args) 
    { 
testdll test = new testdll(); 
test.set(10); 
System.out.println(test.get()); 
} 
} test.dll可以用VC写，例如，
-----testdll.h-----
/* DO NOT EDIT THIS FILE - it is machine generated */
#include <jni.h>
/* Header for class testdll */#ifndef _Included_testdll
#define _Included_testdll
#ifdef __cplusplus
extern "C" {
#endif
/*
 * Class:     testdll
 * Method:    get
 * Signature: ()I
 */
JNIEXPORT jint JNICALL Java_testdll_get
  (JNIEnv *, jclass);/*
 * Class:     testdll
 * Method:    set
 * Signature: (I)V
 */
JNIEXPORT void JNICALL Java_testdll_set
  (JNIEnv *, jclass, jint);#ifdef __cplusplus
}
#endif
#endif
-------testdll.c-----------
#include "testdll.h" int i = 0; JNIEXPORT jint JNICALL Java_testdll_get (JNIEnv *, jclass) 
{ 
return i; 
} JNIEXPORT void JNICALL Java_testdll_set (JNIEnv *, jclass, jint j) 
{ 
i = j; 
} 

Answer 2

2，transienttransient是一个变量修饰符,标记为transient的变量，在对一个对象进行序列化时，这些变量状态不会被序列化。例如，假设某个类的成员变量是transient，那么当通过ObjectOutputStream把这个类的某个实例保存到磁盘上时，实际上transient变量的值是不会保存的。当对象序列化的保存在存储器上时，不希望有些字段数据被保存，为了保证安全性，可以把这些字段声明为transient。要更明白，可以看一些序列化的内容。

Answer 3

3，volatile
原CSDN有一篇介绍过，现贴回来。volatile修饰变量。在每次被线程访问时，都强迫从共享内存中重读该成员变量的值。而且，当成员变量发生变化时，强迫线程将变化值回写到共享内存。这样在任何时刻，两个不同的线程总是看到某个成员变量的同一个值。 
看看Java Language Specification中的例子。 
条件：一个线程不停的调用方法one()，一个线程不停的调用方法two()。我测试过多次，这种情况好像一直没有出现。 代码
class Test {   
    static int i = 0, j = 0;   
    static void one() { i++; j++; }   
    static void two() {   
        System.out.println("i=" + i + " j=" + j);   
    }   
}   结果偶尔会出现j大于i的情况，因为方法没有同步，所以会出现i和j可能不是一次更新。一种防止这种情况发生的办法就是声明两个方法为synchronized 的。 代码
class Test {   
    static int i = 0, j = 0;   
    static synchronized void one() { i++; j++; }   
    static synchronized void two() {   
        System.out.println("i=" + i + " j=" + j);   
    }   
}   这样可以防止两个方法同时被执行，还可以保证j和i被同时更新，这样一来i和j的值一直是一样的。 
另外一种途径就是把i和j声明为volatile。 代码
class Test {   
    static volatile int i = 0, j = 0;   
    static void one() { i++; j++; }   
    static void two() {   
        System.out.println("i=" + i + " j=" + j);   
    }   
}  

Answer 4

来迟了。。那就说需要用的时候吧 
native
当你需要调用本地程序的时候transient
你的类实现了java.io.Serializable而你又不想保存某个字段的时候volatile
这个字段会被其他线程(直接或者间接)访问到，而你想保证每个线程都能得到最新的数据
（性能上肯定有损耗的，为了安全牺牲性能的事情多着去了）