java语言基础部分（1）——常用关键字

1、static
    在static方法的内部不能调用非静态方法，但这不是完全不可能，如果传递一个对象的引用到静态方法里，那么就可以通过这个对象的引用调用非静态方法。static可以修饰内部类，普通类是不允许声明为静态的；
    对于静态变量在内存中只有一个拷贝（节省内存），JVM只为静态分配一次内存，在加载类的过程中完成静态变量的内存分配；
    对于实例变量，每创建一个实例，就会为实例变量分配一次内存，实例变量可以在内存中有多个拷贝，互不影响（灵活）。
    static变量：类变量；成员变量：实例变量。
    static修饰的静态代码块是随着类的加载而运行的，所以要早于构造方法的运行。

    JVM中的堆、栈和方法区
    栈：
        1 基础数据类型 byte short int long float double char boolean
        2 方法的形式参数，方法调用完后从栈空间回收
        3 引用对象的地址，引用完后，栈空间地址立即被回收，堆空间等待GC
            a) 栈内的数据线程之间独立
            b) 具体细分为:
                b.1) 基本类型变量区
                b.2) 执行环境上下文
                b.3) 操作指令区

    堆
        1 this
        2 new出来的对象
        3 数组
        a) jvm只有一个堆区，并被所有线程共享。

    方法区域(又叫 静态区)
        1 字符串常量
        2 static
        3 所有的class
            a) 被所有线程共享, 其内存放程序中永远唯一的元素，eg: static class
2、final
    特别要注意的是final空白，
    即final修饰成员变量时，可以final String str;先不赋值，但是必须在构造方法中赋值，要不然还是会报错的；
    final修饰局部变量时，也可以定义final空白，因为你要使用之前肯定是要先赋值的，并且只能赋值一次。
    final类不能被继承，没有子类，final类中的方法默认是final的。
        在设计类的时候，如果这个类不需要有子类，类的实现细节不允许改变，并且确定这个类不会被扩展，那么就设计为final类。
    final方法不能被子类覆盖，但可以被继承。
        使用final方法的原因有二：
        第一、把方法锁定，防止任何继承类修改它的意义和实现。
        第二、高效。编译器在遇到调用final方法时候会转入内嵌机制，大大提高执行效率。
    final成员变量表示常量，只能被赋值一次，赋值后不再改变。
        final修饰的变量有三种：静态变量、实例变量和局部变量，分别表示三种类型的常量。
        final不能用于修饰构造方法。
    final参数
         当函数参数为final类型时，你可以读取使用该参数，但是无法改变该参数的值。
    static和final修饰过的实例常量，实例本身不能再改变了，但对于一些容器类型（比如，ArrayList、HashMap）的实例变量，不可以改变容器变量本身，但可以修改容器中存放的对象，这一点在编程中用到很多。
3、transient
    java有个特点就是序列化，简单地来说就是可以将这个类存储在物理空间（当然还是以文件的形式存在），那么当你从本地还原这个文件时，你可以将它转换为它本身。这可以极大地方便网络上的一些操作，但同时，因为涉及到安全问题，所以并不希望把类里面所有的东西都能存储（因为那样，别人可以通过序列化知道类里面的内容），那么我们就可以用上transient这个关键字，它的意思是临时的，即不会随类一起序列化到本地，所以当还原后，这个关键字定义的变量也就不再存在。

    通常,我们写的程序都要求特定信息能持久存在或保存到磁盘上,以供一个程序使用或用在同一个程序的另一次运行上.这种持久性可以通过几种方式来实现,包括写到数据库中或是利用JAVA为对象序列化提供的支持.不管我们选用什么方法,类实例的持久性都是通过保存类的域的状态来完成的,保存这些状态,以便以后可以对它们进行访问或使用它们来创建相同的实例.然而,有可能并不是所有的域都需要被保存起来.当一个实例被持久化时,其内部的一些域却不需要持久化,则可以用trainsient修饰符告诉编译器指定的域不需要被持久保存.
    序列化与反序列化：http://blog.csdn.net/wangloveall/article/details/7992448/
     1.Java序列化与反序列化

     Java序列化是指把Java对象转换为字节序列的过程；而Java反序列化是指把字节序列恢复为Java对象的过程。

     2.为什么需要序列化与反序列化

     我们知道，当两个进程进行远程通信时，可以相互发送各种类型的数据，包括文本、图片、音频、视频等， 而这些数据都会以二进制序列的形式在网络上传送。那么当两个Java进程进行通信时，能否实现进程间的对象传送呢？答案是可以的。如何做到呢？这就需要Java序列化与反序列化了。换句话说，一方面，发送方需要把这个Java对象转换为字节序列，然后在网络上传送；另一方面，接收方需要从字节序列中恢复出Java对象。

     当我们明晰了为什么需要Java序列化和反序列化后，我们很自然地会想Java序列化的好处。其好处一是实现了数据的持久化，通过序列化可以把数据永久地保存到硬盘上（通常存放在文件里），二是，利用序列化实现远程通信，即在网络上传送对象的字节序列。

    3.如何实现Java序列化与反序列化

    1）JDK类库中序列化API

     java.io.ObjectOutputStream：表示对象输出流

    它的writeObject(Object obj)方法可以对参数指定的obj对象进行序列化，把得到的字节序列写到一个目标输出流中。

    java.io.ObjectInputStream：表示对象输入流

    它的readObject()方法源输入流中读取字节序列，再把它们反序列化成为一个对象，并将其返回。

    2）实现序列化的要求

    只有实现了Serializable或Externalizable接口的类的对象才能被序列化，否则抛出异常。

    3）实现Java对象序列化与反序列化的方法

    假定一个Student类，它的对象需要序列化，可以有如下三种方法：

    方法一：若Student类仅仅实现了Serializable接口，则可以按照以下方式进行序列化和反序列化

    ObjectOutputStream采用默认的序列化方式，对Student对象的非transient的实例变量进行序列化。

    ObjcetInputStream采用默认的反序列化方式，对对Student对象的非transient的实例变量进行反序列化。

    方法二：若Student类仅仅实现了Serializable接口，并且还定义了readObject(ObjectInputStream in)和writeObject(ObjectOutputSteam out)，则采用以下方式进行序列化与反序列化。

    ObjectOutputStream调用Student对象的writeObject(ObjectOutputStream out)的方法进行序列化。

    ObjectInputStream会调用Student对象的readObject(ObjectInputStream in)的方法进行反序列化。

    方法三：若Student类实现了Externalnalizable接口，且Student类必须实现readExternal(ObjectInput in)和writeExternal(ObjectOutput out)方法，则按照以下方式进行序列化与反序列化。

    ObjectOutputStream调用Student对象的writeExternal(ObjectOutput out))的方法进行序列化。

    ObjectInputStream会调用Student对象的readExternal(ObjectInput in)的方法进行反序列化。

    4）JDK类库中序列化的步骤

    步骤一：创建一个对象输出流，它可以包装一个其它类型的目标输出流，如文件输出流：

    ObjectOutputStream out = new ObjectOutputStream(new fileOutputStream(“D:\\objectfile.obj”));

    步骤二：通过对象输出流的writeObject()方法写对象：

    out.writeObject(“Hello”);

    out.writeObject(new Date());

    5）JDK类库中反序列化的步骤

    步骤一：创建一个对象输入流，它可以包装一个其它类型输入流，如文件输入流：

    ObjectInputStream in = new ObjectInputStream(new fileInputStream(“D:\\objectfile.obj”));

    步骤二：通过对象输出流的readObject()方法读取对象：

    String obj1 = (String)in.readObject();

    Date obj2 = (Date)in.readObject();

    说明：为了正确读取数据，完成反序列化，必须保证向对象输出流写对象的顺序与从对象输入流中读对象的顺序一致。
4、volatile
    http://blog.csdn.net/vking_wang/article/details/9982709
    http://www.cnblogs.com/aigongsi/archive/2012/04/01/2429166.html
    在java线程并发处理中，有一个关键字volatile的使用目前存在很大的混淆，以为使用这个关键字，在进行多线程并发处理的时候就可以万事大吉。
    Java语言是支持多线程的，为了解决线程并发的问题，在语言内部引入了 同步块 和 volatile 关键字机制。

    synchronized
    同步块大家都比较熟悉，通过 synchronized 关键字来实现，所有加上synchronized 和 块语句，在多线程访问的时候，同一时刻只能有一个线程能够用
    synchronized 修饰的方法 或者 代码块。

    volatile
    用volatile修饰的变量，线程在每次使用变量的时候，都会读取变量修改后的最的值。volatile很容易被误用，用来进行原子性操作。
    在 java 垃圾回收整理一文中，描述了jvm运行时刻内存的分配。其中有一个内存区域是jvm虚拟机栈，每一个线程运行时都有一个线程栈，
    线程栈保存了线程运行时候变量值信息。当线程访问某一个对象时候值的时候，首先通过对象的引用找到对应在堆内存的变量的值，然后把堆内存
    变量的具体值load到线程本地内存中，建立一个变量副本，之后线程就不再和对象在堆内存变量值有任何关系，而是直接修改副本变量的值，在修改完之后的某一个时刻（线程退出之前），自动把线程变量副本的值回写到对象在堆中变量。这样在堆中的对象的值就产生变化了。
    如图1
    read and load 从主存复制变量到当前工作内存
    use and assign  执行代码，改变共享变量值
    store and write 用工作内存数据刷新主存相关内容

    其中use and assign 可以多次出现

    但是这一些操作并不是原子性，也就是 在read load之后，如果主内存count变量发生修改之后，线程工作内存中的值由于已经加载，不会产生对应的变化，所以计算出来的结果会和预期不一样

    对于volatile修饰的变量，jvm虚拟机只是保证从主内存加载到线程工作内存的值是最新的

    例如假如线程1，线程2 在进行read,load 操作中，发现主内存中count的值都是5，那么都会加载这个最新的值
    在线程1对count进行修改之后，会write到主内存中，主内存中的count变量就会变为6
    线程2由于已经进行read,load操作，在进行运算之后，也会更新主内存count的变量值为6
    导致两个线程及时用volatile关键字修改之后，还是会存在并发的情况。

5、    assert
    Java在执行的时候默认是不启动断言检查的（这个时候，所有的断言语句都将忽略！），如果要开启断言检查，则需要用开关-enableassertions或-ea来开启。
    1、assert <boolean表达式>
    如果<boolean表达式>为true，则程序继续执行。
    如果为false，则程序抛出AssertionError，并终止执行。
    
    2、assert <boolean表达式> : <错误信息表达式>
    如果<boolean表达式>为true，则程序继续执行。
    如果为false，则程序抛出java.lang.AssertionError，并输入<错误信息表达式>。
    assert关键字用法简单，但是使用assert往往会让你陷入越来越深的陷阱中。应避免使用。笔者经过研究，总结了以下原因：
 
    a、assert关键字需要在运行时候显式开启才能生效，否则你的断言就没有任何意义。而现在主流的Java IDE工具默认都没有开启-ea断言检查功能。这就意味着你如果使用IDE工具编码，调试运行时候会有一定的麻烦。并且，对于Java Web应用，程序代码都是部署在容器里面，你没法直接去控制程序的运行，如果一定要开启-ea的开关，则需要更改Web容器的运行配置参数。这对程序的移植和部署都带来很大的不便。
    
    b、用assert代替if是陷阱之二。assert的判断和if语句差不多，但两者的作用有着本质的区别：assert关键字本意上是为测试调试程序时使用的，但如果不小心用assert来控制了程序的业务流程，那在测试调试结束后去掉assert关键字就意味着修改了程序的正常的逻辑。
    
    c、assert断言失败将面临程序的退出。这在一个生产环境下的应用是绝不能容忍的。一般都是通过异常处理来解决程序中潜在的错误。但是使用断言就很危险，一旦失败系统就挂了。

    assert既然是为了调试测试程序用，不在正式生产环境下用，那应该考虑更好的测试JUint来代替其做用，JUint相对assert关键的所提供的功能是有过之而无不及。当然完全可以通过IDE debug来进行调试测试。在此看来，assert的前途一片昏暗。
 
    因此，应当避免在Java中使用assert关键字，除非哪一天Java默认支持开启-ea的开关，这时候可以考虑。对比一下，assert能给你带来多少好处，多少麻烦，这是我们选择是否使用的的原则。
6、 const和goto只是Java的保留字
7、 enum
    枚举类型是JDK5.0的新特征。Sun引进了一个全新的关键字enum来定义一个枚举类。下面就是一个典型枚举类型的定义：
    Java代码
    public enum Color{  
        RED,BLUE,BLACK,YELLOW,GREEN  
    }
    显然，enum很像特殊的class，实际上enum声明定义的类型就是一个类。而这些类都是类库中Enum类的子类(java.lang.Enum<E>)。它们继承了这个Enum中的许多有用的方法。下面我们就详细介绍enum定义的枚举类的特征及其用法。（后面均用Color举例）

    a、Color枚举类是特殊的class，其枚举值(RED,BLUE...)是Color的类对象(类实例)：
                          Color c=Color.RED;
        而且这些枚举值都是public static final的，也就是我们经常所定义的常量方式，因此枚举类中的枚举值最好全部大写。

    b、即然枚举类是class，当然在枚举类型中有构造器，方法和数据域。但是，枚举类的构造器有很大的不同：
          (1) 构造器只是在构造枚举值的时候被调用。

    Java代码
    enum Color{  
                    RED(255,0,0),BLUE(0,0,255),BLACK(0,0,0),YELLOW(255,255,0),GREEN(0,255,0);  
                    //构造枚举值，比如RED(255,0,0)  
                    private Color(int rv,int gv,int bv){  
                     this.redValue=rv;  
                     this.greenValue=gv;  
                     this.blueValue=bv;  
                    }  
    
                    public String toString(){  //自定义的public方法  
                    return super.toString()+"("+redValue+","+greenValue+","+blueValue+")";  
                    }  
         
                    private int redValue;  //自定义数据域，private为了封装。  
                    private int greenValue;  
                    private int blueValue;  
     }
      (2) 构造器只能私有private，绝对不允许有public构造器。这样可以保证外部代码无法新构造枚举类的实例。这也是完全符合情理的，因为我们知道枚举值是public static final的常量而已。 但枚举类的方法和数据域可以允许外部访问。

    Java代码
    public static void main(String args[])  
    {  
            // Color colors=new Color(100,200,300);  //wrong  
               Color color=Color.RED;  
               System.out.println(color);  // 调用了toString()方法  
    }
    c、所有枚举类都继承了Enum的方法，下面我们详细介绍这些方法。
       (1)  ordinal()方法: 返回枚举值在枚举类种的顺序。这个顺序根据枚举值声明的顺序而定。
                 Color.RED.ordinal();  //返回结果：0
                 Color.BLUE.ordinal();  //返回结果：1
       (2)  compareTo()方法: Enum实现了java.lang.Comparable接口，因此可以比较象与指定对象的顺序。Enum中的compareTo返回的是两个枚举值的顺序之差。当然，前提是两个枚举值必须属于同一个枚举类，否则会抛出ClassCastException()异常。(具体可见源代码)
                 Color.RED.compareTo(Color.BLUE);  //返回结果 -1
       (3)  values()方法： 静态方法，返回一个包含全部枚举值的数组。
                 Color[] colors=Color.values();
                 for(Color c:colors){
                        System.out.print(c+",");
                 }//返回结果：RED,BLUE,BLACK YELLOW,GREEN,
       (4)  toString()方法： 返回枚举常量的名称。
                 Color c=Color.RED;
                 System.out.println(c);//返回结果: RED
       (5)  valueOf()方法： 这个方法和toString方法是相对应的，返回带指定名称的指定枚举类型的枚举常量。
                 Color.valueOf("BLUE");   //返回结果: Color.BLUE
      

        (6)  equals()方法： 比较两个枚举类对象的引用。
        d、枚举类可以在switch语句中使用。

        Java代码

        Color color=Color.RED;   
        switch(color){   
                case RED: System.out.println("it's red");break;   
                case BLUE: System.out.println("it's blue");break;   
                case BLACK: System.out.println("it's blue");break;   
        }
8、 native
    单地讲，一个Native Method就是一个java调用非java代码的接口。一个Native Method是这样一个java的方法：该方法的实现由非java语言实现，比如C。这个特征并非java所特有，很多其它的编程语言都有这一机制，比如在C＋＋中，你可以用extern "C"告知C＋＋编译器去调用一个C的函数。
   "A native method is a Java method whose implementation is provided by non-java code."
   在定义一个native method时，并不提供实现体（有些像定义一个java interface），因为其实现体是由非java语言在外面实现的。，下面给了一个示例：   

    package java.lang;
    public class Object {
        ......
        public final native Class<?> getClass();
        public native int hashCode();
        protected native Object clone() throws CloneNotSupportedException;
        public final native void notify();
        public final native void notifyAll();
        public final native void wait(long timeout) throws InterruptedException;
        ......
    }

        标识符native可以与所有其它的java标识符连用，但是abstract除外。这是合理的，因为native暗示这些方法是有实现体的，只不过这些实现体是非java的，但是abstract却显然的指明这些方法无实现体。native与其它java标识符连用时，其意义同非Native Method并无差别。

    一个native method方法可以返回任何java类型，包括非基本类型，而且同样可以进行异常控制。这些方法的实现体可以自制一个异常并且将其抛出，这一点与java的方法非常相似。
    native method的存在并不会对其他类调用这些本地方法产生任何影响，实际上调用这些方法的其他类甚至不知道它所调用的是一个本地方法。JVM将控制调用本地方法的所有细节。

    如果一个含有本地方法的类被继承，子类会继承这个本地方法并且可以用java语言重写这个方法（这个似乎看起来有些奇怪），同样的如果一个本地方法被fianl标识，它被继承后不能被重写。
   本地方法非常有用，因为它有效地扩充了jvm.事实上，我们所写的java代码已经用到了本地方法，在sun的java的并发（多线程）的机制实现中，许多与操作系统的接触点都用到了本地方法，这使得java程序能够超越java运行时的界限。有了本地方法，java程序可以做任何应用层次的任务。


    二.为什么要使用Native Method
   java使用起来非常方便，然而有些层次的任务用java实现起来不容易，或者我们对程序的效率很在意时，问题就来了。
   与java环境外交互：
   有时java应用需要与java外面的环境交互。这是本地方法存在的主要原因，你可以想想java需要与一些底层系统如操作系统或某些硬件交换信息时的情况。本地方法正是这样一种交流机制：它为我们提供了一个非常简洁的接口，而且我们无需去了解java应用之外的繁琐的细节。
   与操作系统交互：
   JVM支持着java语言本身和运行时库，它是java程序赖以生存的平台，它由一个解释器（解释字节码）和一些连接到本地代码的库组成。然而不管怎样，它毕竟不是一个完整的系统，它经常依赖于一些底层（underneath在下面的）系统的支持。这些底层系统常常是强大的操作系统。通过使用本地方法，我们得以用java实现了jre的与底层系统的交互，甚至JVM的一些部分就是用C写的，还有，如果我们要使用一些java语言本身没有提供封装的操作系统的特性时，我们也需要使用本地方法。
    Sun's Java
    Sun的解释器是用C实现的，这使得它能像一些普通的C一样与外部交互。jre大部分是用java实现的，它也通过一些本地方法与外界交互。例如：类java.lang.Thread 的 setPriority()方法是用java实现的，但是它实现调用的是该类里的本地方法setPriority0()。这个本地方法是用C实现的，并被植入JVM内部，在Windows 95的平台上，这个本地方法最终将调用Win32 SetPriority() API。这是一个本地方法的具体实现由JVM直接提供，更多的情况是本地方法由外部的动态链接库（external dynamic link library）提供，然后被JVM调用。


    三.JVM怎样使Native Method跑起来：
    我们知道，当一个类第一次被使用到时，这个类的字节码会被加载到内存，并且只会回载一次。在这个被加载的字节码的入口维持着一个该类所有方法描述符的list，这些方法描述符包含这样一些信息：方法代码存于何处，它有哪些参数，方法的描述符（public之类）等等。
    如果一个方法描述符内有native，这个描述符块将有一个指向该方法的实现的指针。这些实现在一些DLL文件内，但是它们会被操作系统加载到java程序的地址空间。当一个带有本地方法的类被加载时，其相关的DLL并未被加载，因此指向方法实现的指针并不会被设置。当本地方法被调用之前，这些DLL才会被加载，这是通过调用java.system.loadLibrary()实现的。
 
   最后需要提示的是，使用本地方法是有开销的，它丧失了java的很多好处。如果别无选择，我们可以选择使用本地方法。

 

    可以将native方法比作Java程序同Ｃ程序的接口，其实现步骤：
    １、在Java中声明native()方法，然后编译；
    ２、用javah产生一个.h文件；
    ３、写一个.cpp文件实现native导出方法，其中需要包含第二步产生的.h文件（注意其中又包含了JDK带的jni.h文件）；
    ４、将第三步的.cpp文件编译成动态链接库文件；
    ５、在Java中用System.loadLibrary()方法加载第四步产生的动态链接库文件，这个native()方法就可以在Java中被访问了。

9、 strictfp, 即 strict float point (精确浮点)。
    　　strictfp 关键字可应用于类、接口或方法。使用 strictfp 关键字声明一个方法时，该方法中所有的float和double表达式都严格遵守FP-strict的限制,符合IEEE-754规范。当对一个类或接口使用 strictfp 关键字时，该类中的所有代码，包括嵌套类型中的初始设定值和代码，都将严格地进行计算。严格约束意味着所有表达式的结果都必须是 IEEE 754 算法对操作数预期的结果，以单精度和双精度格式表示。
    　　如果你想让你的浮点运算更加精确，而且不会因为不同的硬件平台所执行的结果不一致的话，可以用关键字strictfp.
    示例 1
    　　下面的示例演示了一个使用 strictfp 修饰符声明的类。
    Java代码
    package com.magical;  
    
    // Example of precision control with strictfp  
    public strictfp class MyClass {  
        public static void main(String[] args)  
        {  
            float aFloat = 0.6710339f;  
            double aDouble = 0.04150553411984792d;  
            double sum = aFloat + aDouble;  
            float quotient = (float)(aFloat / aDouble);  
            System.out.println("float: " + aFloat);  
            System.out.println("double: " + aDouble);  
            System.out.println("sum: " + sum);  
            System.out.println("quotient: " + quotient);  
        }  
    }
    运行结果：
    float: 0.6710339
    double: 0.04150553411984792
    sum: 0.7125394529774224

    quotient: 16.167336

10、synchronized
    
    代表这个方法加锁,相当于不管哪一个线程A每次运行到这个方法时,都要检查有没有其它正在用这个方法的线程B（或者C D等）,有的话要等正在使用这个方法的线程B（或者C D）运行完这个方法后再运行此线程A,没有的话,直接运行 它包括两种用法：synchronized 方法和 synchronized 块。
a. synchronized 方法：

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

　　public synchronized void accessVal(int newVal);

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

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

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

 
b. synchronized 块：

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

　　synchronized(syncObject) {

　　//允许访问控制的代码

　　}

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

 

 
 
对synchronized(this)的一些理解

　　一、当两个并发线程访问同一个对象object中的这个synchronized(this)同步代码块时，一个时间内只能有一个线程得到执行。另一个线程必须等待当前线程执行完这个代码块以后才能执行该代码块。

　　二、当一个线程访问object的一个synchronized(this)同步代码块时，其他线程对object中所有其它synchronized(this)同步代码块的访问将被阻塞。

　　三、然而，当一个线程访问object的一个synchronized(this)同步代码块时，另一个线程仍然可以访问该object中的除synchronized(this)同步代码块以外的部分。

　　四、第三个例子同样适用其它同步代码块。也就是说，当一个线程访问object的一个synchronized(this)同步代码块时，它就获得了这个object的对象锁。结果，其它线程对该object对象所有同步代码部分的访问都被暂时阻塞。

　　五、以上规则对其它对象锁同样适用

 

 

synchronized的一个简单例子

public class TextThread
{

/**
* @param args
*/
public static void main(String[] args)
{
// TODO 自动生成方法存根
        TxtThread tt = new TxtThread();
        new Thread(tt).start();
        new Thread(tt).start();
        new Thread(tt).start();
        new Thread(tt).start();
}
}

class TxtThread implements Runnable
{
int num = 100;
String str = new String();
public void run()
{
while (true)
{
   synchronized(str)
   {
   if (num>0)
   {
    try
    {
     Thread.sleep(10);
    }
    catch(Exception e)
    {
     e.getMessage();
    }
    System.out.println(Thread.currentThread().getName()+ "this is "+ num--);
   }
   }
}
}
}

上面的例子中为了制造一个时间差,也就是出错的机会,使用了Thread.sleep(10)

Java对多线程的支持与同步机制深受大家的喜爱，似乎看起来使用了synchronized关键字就可以轻松地解决多线程共享数据同步问题。到底如何？――还得对synchronized关键字的作用进行深入了解才可定论。

总的说来，synchronized关键字可以作为函数的修饰符，也可作为函数内的语句，也就是平时说的同步方法和同步语句块。如果再细的分类，synchronized可作用于instance变量、object reference（对象引用）、static函数和class literals(类名称字面常量)身上。

在进一步阐述之前，我们需要明确几点：

A．无论synchronized关键字加在方法上还是对象上，它取得的锁都是对象，而不是把一段代码或函数当作锁――而且同步方法很可能还会被其他线程的对象访问。

B．每个对象只有一个锁（lock）与之相关联。

C．实现同步是要很大的系统开销作为代价的，甚至可能造成死锁，所以尽量避免无谓的同步控制。

接着来讨论synchronized用到不同地方对代码产生的影响：

 

假设P1、P2是同一个类的不同对象，这个类中定义了以下几种情况的同步块或同步方法，P1、P2就都可以调用它们。

 

1． 把synchronized当作函数修饰符时，示例代码如下：

Public synchronized void methodAAA()

{

//….

}

这也就是同步方法，那这时synchronized锁定的是哪个对象呢？它锁定的是调用这个同步方法对象。也就是说，当一个对象P1在不同的线程中执行这个同步方法时，它们之间会形成互斥，达到同步的效果。但是这个对象所属的Class所产生的另一对象P2却可以任意调用这个被加了synchronized关键字的方法。

上边的示例代码等同于如下代码：

public void methodAAA()

{

synchronized (this)      // (1)

{

       //…..

}

}

(1)处的this指的是什么呢？它指的就是调用这个方法的对象，如P1。可见同步方法实质是将synchronized作用于object reference。――那个拿到了P1对象锁的线程，才可以调用P1的同步方法，而对P2而言，P1这个锁与它毫不相干，程序也可能在这种情形下摆脱同步机制的控制，造成数据混乱：（

2．同步块，示例代码如下：

public void method3(SomeObject so)

{

    synchronized(so)

    {
       //…..
    }

}

这时，锁就是so这个对象，谁拿到这个锁谁就可以运行它所控制的那段代码。当有一个明确的对象作为锁时，就可以这样写程序，但当没有明确的对象作为锁，只是想让一段代码同步时，可以创建一个特殊的instance变量（它得是一个对象）来充当锁：

class Foo implements Runnable

{

        private byte[] lock = new byte[0]; // 特殊的instance变量

        Public void methodA()
        {

           synchronized(lock) { //… }

        }

        //…..

}

注：零长度的byte数组对象创建起来将比任何对象都经济――查看编译后的字节码：生成零长度的byte[]对象只需3条操作码，而Object lock = new Object()则需要7行操作码。

c．将synchronized作用于static 函数，示例代码如下：

Class Foo
{

    public synchronized static void methodAAA()   // 同步的static 函数
    {
        //….
    }

    public void methodBBB()
    {

       synchronized(Foo.class)   // class literal(类名称字面常量)

    }
}

   代码中的methodBBB()方法是把class literal作为锁的情况，它和同步的static函数产生的效果是一样的，取得的锁很特别，是当前调用这个方法的对象所属的类（Class，而不再是由这个Class产生的某个具体对象了）。

记得在《Effective Java》一书中看到过将 Foo.class和 P1.getClass()用于作同步锁还不一样，不能用P1.getClass()来达到锁这个Class的目的。P1指的是由Foo类产生的对象。

可以推断：如果一个类中定义了一个synchronized的static函数A，也定义了一个synchronized 的instance函数B，那么这个类的同一对象Obj在多线程中分别访问A和B两个方法时，不会构成同步，因为它们的锁都不一样。A方法的锁是Obj这个对象，而B的锁是Obj所属的那个Class。

 

小结如下：

搞清楚synchronized锁定的是哪个对象，就能帮助我们设计更安全的多线程程序。

 

还有一些技巧可以让我们对共享资源的同步访问更加安全：

1． 定义private 的instance变量+它的 get方法，而不要定义public/protected的instance变量。如果将变量定义为public，对象在外界可以绕过同步方法的控制而直接取得它，并改动它。这也是JavaBean的标准实现方式之一。

2． 如果instance变量是一个对象，如数组或ArrayList什么的，那上述方法仍然不安全，因为当外界对象通过get方法拿到这个instance对象的引用后，又将其指向另一个对象，那么这个private变量也就变了，岂不是很危险。 这个时候就需要将get方法也加上synchronized同步，并且，只返回这个private对象的clone()――这样，调用端得到的就是对象副本的引用了

 

 

还有，比较常用的就有：Collections.synchronizedMap(new HashMap())，当然这个MAP就是生命在类中的全局变量，就是一个 线程安全的HashMap，web的application是全web容器公用的，所以要使用线程安全来保证数据的正确。