Java多线程同步Synchronized使用分析

由于servlet 是多线程单例的。
struts1 的前端控制器是单例的，线程不安全的；每次请求都会用同一actionServlet；
struts2 的action不是单例的，线程安全的；每次请求都会新new一个action来接收；

因此如果使用 servlet 或者strtus1 线程安全问题，不能不考虑，下面内容。

同步的概念：
    同步分为 同步方法 和 同步块  两种方式。
    锁定的内容分为 锁定类定实例 和 锁定类对象  两种方式。
    变量分为 实例变量(不带static的变量) 和 类变量(带static的变量）
    变量分为 属性 和 方法

使用同步的原因
   1. 在系统中对访类要使用多线程进行访问；
   2. 在该类中有 类变量， 或者是 在类的方法中有访问 公共资源（如一个外部文件的读写）。

同步锁锁定的内容是什么？
   无论你将Synchronized加在方法前还是加在一个变量前，其锁定的都是一个 类对象。 每一个对象都只有一个锁与之相关联。


下例中分情况的列举各种情况下的同步效果

1. Synchronized 加在方法上， （同步方法，锁定类实例）

public class Demo1 {

    public synchronized void m1(){
        //...............
    }

    public void m2(){
        //............

        synchronized(this){
            //.........
        }

        //........
    }
}

这两种写法的效果是一样的，锁定的都是类实例对象。如果有一个 类实例对象：   demo = new Demo1（），另外有两个线程： thread1，thread2，都调用了demo 对象，那么，在同一时间，如果 thread1调用了demo.m1()，则thread2在该时间内不能访问demo.m1() 和 demo.m2(); 因为thread1把demo这个对象的锁使用了，所以无法分给其它线程使用，但是，如果thread1调用 demo1.m1(), thread2调用 demo2.m1(), 则可以同时进行，因为它们调用的是不同的Demo1类对象实例。


2. Synchronized 加在变量上， （同步块，锁定类实例）

public class Demo2 {
    Object a = new Object();
    Object b = new Object();

    public void m1(){
        //............

        synchronized(a){
            //.........
        }

        //........
    }

    public void m2(){
        //............

        synchronized(b){
            //.........
        }

        //........
    }
}

这种情况下，是实现代码块锁定，锁定的对象是 变量 a 或 b； （注意，a 、b 都是非static 的）如果有一个 类实例对象：   demo = new Demo2（），另外有两个线程： thread1，thread2，都调用了demo 对象，那么，在同一时间，如果 thread1调用了demo.m1()，则thread2在该时间内可以访问demo.m2();但不能访问  demo.m1() 的同步块， 因为a被 thread1锁定了。

3. Synchronized 锁定的是 类变量 ，即static 变量(可能是属性，可能是方法)(锁定类对象)

public class Demo3 {
    static Object o = new Object();

    public static synchronized void m1() {
        //....
    }

    public static void m2() {
        //...
        synchronized (Demo3.class) {
            //.....
        }
        //.....
    }

    public static void m3() {
        //..........
        try {
            synchronized (Class.forName("Demo3")) {
              //............
            }
        } catch (ClassNotFoundException ex) {
        }
        //.............
    }

    public static void m4() {
        //............
       synchronized(o){
         //........
       }
        //..........
    }
}

以上4个方法中实现的效果都是一样的，其锁定的对象都是类Demo3，而不是类实例对象 ，即在多线程中，其共享的资源是属于类的，而不是属于类对象的。在这种情况下，如果thread1 访问了这4个方法中的任何一个， 在同一时间内其它的线程都不能访问 这4个方法。

4. 类的方法中访问了多线程共同的资源, 且该资源是可变的，这种情况下也是需要进行同步的

public class Demo4 {
    static String path = "file path";

    public void readConfiFile() {
        synchronized (path) {
           // 读取该path指定的文件。
        }

    }

    public void writeConfiFile() {
        synchronized (path) {
            //写信息到该path指定的文件。
        }
    }
}

这种情况下，必须锁定为 类变量，而不能进行锁定类实例对象，因为这是变象的一种类资源共享，而不是类实例对象资源共享。

线程，成也其，败也其，用好了可以提升性能，用不好则会使系统后患无穷。

PS： 进行线程同步需要很大的系统开销， 所以，在使用时，如果不是必须的，则尽量不使用同步功能。