您的位置:首页 > 编程语言 > Java开发

Java多线程同步Synchronized使用分析

2012-12-18 13:51 323 查看
 

同步的概念:

同步分为 同步方法 和 同步块 两种方式。

锁定的内容分为 锁定类的某个特定实例 和 锁定类对象(类的所有实例)

变量分为 实例变量(不带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 加在变量上, (同步块,锁定类实例)

Java代码

 

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 变量(可能是属性,可能是方法)(锁定类对象)

Java代码

 

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. 类的方法中访问了多线程共同的资源, 且该资源是可变的,这种情况下也是需要进行同步的

Java代码

 

public class Demo4 {     
    static String path = "file path";     
    
    public void readConfiFile() {     
        synchronized (path) {     
           // 读取该path指定的文件。     
        }     
    
    }     
    
    public void writeConfiFile() {     
        synchronized (path) {     
            //写信息到该path指定的文件。     
        }     
    }     
}    

 

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

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

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

对线程run的控制:

[java]
view plaincopyprint?

public class ClientOutputThread extends Thread {  
      
    public void setMsg() {  
          
        synchronized (this) {  
            System.out.println("去唤醒线程...");  
            notify();  
        }  
    }  
  
    @Override  
    public void run() {  
        try {  
            while (true) {  
                    System.out.println("run()执行中...");  
                    synchronized (this) {  
                        System.out.println("等候状态..");  
                        wait();// 鍙戦?瀹屾秷鎭悗锛岀嚎绋嬭繘鍏ョ瓑寰呯姸鎬?
  
                          
                    }  
                }  
            }  
              
        catch (Exception e) {  
            e.printStackTrace();  
        }  
    }  
  
}  

public class ClientOutputThread extends Thread {

public void setMsg() {

synchronized (this) {
System.out.println("去唤醒线程...");
notify();
}
}

@Override
public void run() {
try {
while (true) {
System.out.println("run()执行中...");
synchronized (this) {
System.out.println("等候状态..");
wait();// 鍙戦?瀹屾秷鎭悗锛岀嚎绋嬭繘鍏ョ瓑寰呯姸鎬?

}
}
}

catch (Exception e) {
e.printStackTrace();
}
}

}


[java]
view plaincopyprint?

ClientOutputThread cot = new ClientOutputThread();  
        cot.start();  
          
        try {  
            Thread.sleep(5000);  
        } catch (InterruptedException e) {  
            // TODO Auto-generated catch block
  
            e.printStackTrace();  
        }  
        cot.setMsg();  

ClientOutputThread cot = new ClientOutputThread();
cot.start();

try {
Thread.sleep(5000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
cot.setMsg();


运行结果:

run()执行中...

等候状态..

去唤醒线程...

run()执行中...

等候状态..
内容来自用户分享和网络整理,不保证内容的准确性,如有侵权内容,可联系管理员处理 点击这里给我发消息
标签: