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");   
    }
}

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