Java多线程同步Synchronized

在Java应用中，使用多线程进行工作的需要是越来越多，使用多线程进行工作，大大的提高了系统的工作效率，然而因此而产生的问题也是层出不穷，而且因为多线程而产生的问题跟踪是一个难题。

同步的概念：
    同步分为 方法同步 和 同步块  两种方式。

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

 

同步所锁定的内容是什么？

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

 

 

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

 

1. Synchronized 加在方法上， （方法同步）

 

public  synchronized void function1(){ ……}

public  void function2(){

         synchronized （this）{……}

    ……}

这两种写法的效果是一样的，锁定的都是类实例对象。

如果有一个 类实例对象：   inst = new ClassSynInst（），

另外有两个线程： threada，threadb，都调用了inst 对象，那么，在同一时间，如果 threada调用了inst.function1()，则threadb在该时间内不能访问inst.function1() 和 inst.function2(); 因为threada把inst这个对象的锁使用了，所以无法分给其它线程使用

但是，如果threada调用 inst1.function1(), threadb调用 inst2.function1(), 则可以同时进行，因为它们调用的是不同的ClassSynInst类对象实例。

 

 

 

2. Synchronized 加在变量上， （同步块）

 Object a = new Object（）；

 Object b = new Object（）；

 

 

public  void function1(){

         synchronized （a）{……}

    ……}

public  void function2(){

         synchronized （b）{……}

    ……}

 

这种情况下，是实现代码块锁定，锁定的对象是 变量 a 或 b； （注意，a 、b 都是非static 的）

 

如果有一个 类实例对象：   inst = new ClassSynInst（），

另外有两个线程： threada，threadb，都调用了inst 对象，那么，在同一时间，如果 threada调用了inst.function1()，则threadb在该时间内可以访问inst.function2(); 但不能访问  inst.function1() 的同步块， 因为a被 threada锁定了。

 

3. Synchronized 锁定的是 类变量 ，即static 变量

 

class Test{ 
 static Object o= new Object(); 

public static synchronized void f1(){ ……} 

public static void f2(){ 
synchronized(Test.class){ ……} 
} 

public static void f3(){ 
try { 
synchronized (Class.forName("Test")) { ……} 
} 
catch (ClassNotFoundException ex) { 
} 
} 

public static void f4(){ 
synchronized(o){ ……} 
} 
} 

 

以上4个方法中实现的效果都是一样的，其锁定的对象都是类Test，而不是类实例对象 ，即在多线程中，其共享的资源是属于类的，而不是属于类对象的。

在这种情况下，如果threada 访问了这4个方法中的任何一个， 在同一时间内其它的线程都不能访问 这4个方法。

 

 

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

例：

class test {

    static String path = “ file path”；    

    public void  readConfiFile(){

          synchronized （path）{

              // 读取该path指定的文件。

         }

 

   }

 

     public void  writeConfiFile(){

        synchronized （path）{

              // 写信息到该path指定的文件。

         }

   }

 

}

 

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

 

 

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

 

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

---------------------------------------------------------------------------------------------------------------------------

线程同步时，调用一个 synchronized 的方法，所有的 synchronized 的方法都被锁定，其他的方法不受影响。

 

看一个例子：

 

package com.ldq;

 public class Test06 {

     private static Obj o1;

     /**
     * @param args
     */
     public static void main(String[] args) {
         // TODO Auto-generated method stub

         o1 = new Obj();

         new Thread() {
             public void run() {
                o1.method01();
            }
        }.start();

         new Thread() {
             public void run() {
                o1.method02();
            }
        }.start();

         new Thread() {
             public void run() {
                o1.method03();
            }
        }.start();

    }
}

 class Obj {

     synchronized void method01() {
         while (true) {
             System.out.println("method01");
             try {
                 Thread.sleep(5000);
             } catch (InterruptedException e) {
                 // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    }

     void method02() {
         while (true) {
             System.out.println("method02");
             try {
                 Thread.sleep(1000);
             } catch (InterruptedException e) {
                 // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    }

     synchronized void method03() {
         while (true) {
             System.out.println("method03");
             try {
                 Thread.sleep(1000);
             } catch (InterruptedException e) {
                 // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    }

}

package com.ldq;

public class Test06 {

	private static Obj o1;

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub

		o1 = new Obj();

		new Thread() {
			public void run() {
				o1.method01();
			}
		}.start();

		new Thread() {
			public void run() {
				o1.method02();
			}
		}.start();

		new Thread() {
			public void run() {
				o1.method03();
			}
		}.start();

	}
}

class Obj {

	synchronized void method01() {
		while (true) {
			System.out.println("method01");
			try {
				Thread.sleep(5000);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
	}

	void method02() {
		while (true) {
			System.out.println("method02");
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
	}

	synchronized void method03() {
		while (true) {
			System.out.println("method03");
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
	}

}

 

 

以上代码输出结果为：

method01
method02
method02
method02
method02
method02
method01
method02
method02
method02

 

      分析：首先生成一个对象 o1 ，它有 3 个方法，其中 method01 和 method03 有关键字 synchronized 修饰，说明这两个方法要做线程同步，而 method02 没有关键字 synchronized 修饰，说明不用做同步。可见，对象加锁操作是针对有 synchronized 关键字而言的。调用 synchronized 的方法，整个对象的所有 synchronized 的方法都被加锁，但是其他的方法不受影响。