Java多线程中的锁

Java多线程的锁主要有4种情况,

1. 静态方法中的锁,此时,虚拟机使用的锁为该方法所在类的Class,即用来创建所有该类实例的那个模版,是全局唯一的,无论何种情况下调用该方法,均是线程安全的:

public class Test {  
    public static void main(String[] args) {  
        for(int i = 0;i<5;i++){  
            new R().start();  
        }  
    }  
}  
  
class R extends Thread{  
    static int i=0;  
    static Set set = new HashSet();  
  
    public void run(){  
        while(i<1000000)  
            multiThread();  
    }  
  
    public static synchronized void multiThread(){  
        if(!set.add(i++))  
            System.out.println(i+" is already exists");  
    }  
}

2. 非静态方法中的锁,此时虚拟机使用这个类的实例来作为锁,如果创建了多个实例,各个实例再同时调用该方法,那么这个方法便不安全了:

public class Test {  
    public static void main(String[] args) {  
  
        for(int i = 0;i<5;i++){  
            new R().start();  
        }  
    }  
}  
  
class R extends Thread{  
    static int i=0;  
    static Set set = new HashSet();  
  
    public void run(){  
        while(i<1000000)  
            multiThread();  
    }  
  
    public synchronized void multiThread(){  
        if(!set.add(i++))  
            System.out.println(i+" is already exists");  
    }  
}

这时候会打印一大堆信息出来,如果这个类只创建了一个实例,别的类来调用这个实例的synchronized方法,便是线程安全的:

public class Test {  
    public static void main(String[] args) {  
        for(int i = 0;i<5;i++){  
            new T().start();  
        }  
    }  
}  
  
class R{  
    static Set set = new HashSet();  
    static Integer i=0;  
  
    public synchronized void multiThread(){  
        if(!set.add(i++))  
            System.out.println(i+" is already exists");  
    }  
}  
  
class T extends Thread{  
    static R r = new R();  
  
    public void run(){  
        int i = 0;  
        while(i++<100000)  
            r.multiThread();  
    }  
}

3.  代码片段中加上synchronized,使用本实例做锁:

public class Test {  
    public static void main(String[] args) {  
        for(int i = 0;i<5;i++){  
            new R().start();  
        }  
    }  
}  
  
class R extends Thread{  
    static int i=0;  
    static Set set = new HashSet();  
    public void run(){  
        while(i<1000000)  
            multiThread();  
    }  
  
    public void multiThread(){  
        synchronized(this){  
            if(!set.add(i++))  
            System.out.println(i+" is already exists");  
        }          
    }  
}

这种情况和2一样,只有在这个实例仅存在一个的时候,代码段才是线程安全的,上面的代码中创建了5个R的实例,所以看起来线程安全的代码并不安全,此时,应该加上一个static的对象来作为线程锁,即:

4. 代码片段中加上synchronized,创建一个static的对象做锁:

public class Test {  
    public static void main(String[] args) {  
        for(int i = 0;i<5;i++){  
            new R().start();  
        }  
    }  
}  
  
class R extends Thread{  
    static int i=0;  
    static Set set = new HashSet();  
    static Object lock = new Object();  
    public void run(){  
        while(i<1000000)  
            multiThread();  
    }  
  
    public void multiThread(){  
        synchronized(lock){  
            if(!set.add(i++))  
            System.out.println(i+" is already exists");  
        }          
    }  
}

此时,该方法是绝对线程安全的。

一般来说,采用方法的synchronized比采用代码块的synchronized执行效率要高,从他们生成的虚拟机执行码可以分析出来(没证实过,有兴趣的可以用javap去反编译一下class文件比较一下)

JDK1.5以后,java.util.concurrent这个包里面有大量的多线程环境下可以使用的类,有能够用上的就最好用这个包里面的类,不要再自己去写同步代码了,例如典型的售票程序,可以使用AtomicInteger类来处理:

public class Test {  
    public static void main(String[] args) {  
        for(int i = 0;i<5;i++){  
            new R().start();  
        }  
    }  
}  
  
class R extends Thread{  
    static AtomicInteger ticket = new AtomicInteger();  
    static Set set = new HashSet();      
    public void run(){  
        while(ticket.get() <1000000 )  
            multiThread();  
    }  
  
    public void multiThread(){  
        if(!set.add(ticket.addAndGet(1)))  
            System.out.println(ticket.get()+" is already exists");     
    }  
}

这样子看起来是不是感觉要清爽一点了?

发表评论

电子邮件地址不会被公开。 必填项已用*标注