对象锁和类锁

先来看一段小代码

public class MutiThread {
    private int num = 0;

    public synchronized void printNum(String tag){
        try {
            if(tag.equals("a")){
               num = 100;
               System.out.println("tag a, set num over!");
                Thread.sleep(1000);
            } else {
               num = 200;
               System.out.println("tag b, set num over!");
            }

            System.out.println("tag " + tag + ", num = " + num);

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

    //注意观察run方法输出顺序
    public static void main(String[] args) {

        //两个不同的对象
        final MutiThread m1 = new MutiThread();
        final MutiThread m2 = new MutiThread();

        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                m1.printNum("a");
            }
        });

        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                m2.printNum("b");
            }
        });

        t1.start();
        t2.start();
    }
}

输出结果

tag a, set num over!
tag b, set num over!
tag b, num = 200
tag a, num = 100

可以看得出来，synchronized锁住的只是对象，而m1,m2并不是同一个对象，所以这个锁没有“锁住”。

这就是对象锁

如果在方法上加上static关键字，输出结果正常

tag a, set num over!
tag a, num = 100
tag b, set num over!
tag b, num = 200

说明在静态方法上加synchronized关键字，表示锁定.class类，类一级别的锁（独占.class类）。