synchronized关键字的对象锁和类锁使用

synchronized关键字的对象锁和类锁使用

对象锁

首先看两段能直观描述对象锁的代码

public class MyRunnable implements Runnable{
    @Override
    public void run() {
        try {
            printSome();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public synchronized void printSome() throws InterruptedException {
            System.out.println(Thread.currentThread().getName() + "exec 1");
            Thread.sleep(500);
            System.out.println(Thread.currentThread().getName() + "exec 2");
            Thread.sleep(500);
            System.out.println(Thread.currentThread().getName() + "exec 3");
            Thread.sleep(500);
    }
    public static void main(String[] args) {
        MyRunnable myRunnable = new MyRunnable();
        Thread t1 = new Thread(myRunnable,"thread1");
        Thread t2 = new Thread(myRunnable,"thread2");
        t1.start();
        t2.start();
    }
}

运行结果

这段代码中，在方法上使用synchronized关键字，也就是使用this作为锁对象。两个线程t1和t2使用一个runnable的示例，在调用同步方法时，使用的是同一把锁，也就是myRunnable这个实例，因此能成功达到同步的效果。

public class MyRunnable implements Runnable{
    @Override
    public void run() {
        try {
            printSome();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public synchronized void printSome() throws InterruptedException {
            System.out.println(Thread.currentThread().getName() + "exec 1");
            Thread.sleep(500);
            System.out.println(Thread.currentThread().getName() + "exec 2");
            Thread.sleep(500);
            System.out.println(Thread.currentThread().getName() + "exec 3");
            Thread.sleep(500);
    }
    public static void main(String[] args) {
        MyRunnable myRunnable1 = new MyRunnable();
        MyRunnable myRunnable2 = new MyRunnable();
        Thread t1 = new Thread(myRunnable1,"thread1");
        Thread t2 = new Thread(myRunnable2,"thread2");
        t1.start();
        t2.start();
    }
}

运行结果

可以看到，这段代码中两个线程并没有同步运行。两个线程t1，t2使用了不同的runnable对象，所以在执行到同步方法时，t1线程使用的this锁是myRunnable1 这个实例，t2线程使用的this锁是myRunnable2 这个实例。既然锁都不一样，那想同步就是痴心妄想了。

当使用同一个类的不同对象操作同步方法或同步块时(以this作为锁对象)，因为此时是对象锁的级别，而且是不同的对象实例，所以无法达到同步的效果。

类锁

类锁有两种使用方式，一种是在方法上同时用synchronized和static关键字修饰，另一种是在synchronized代码块中用xxx.class作为锁对象。因为是用的类来作为锁，所以不管这个类创建多少个对象，都是同属于一个类，所以是用的也是一把锁，继续通过两段代码直观体验下

public class MyRunnable implements Runnable {
    @Override
    public void run() {
        try {
            printSome();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    
    //通过static关键字达到类锁级别
    public static synchronized void printSome() throws InterruptedException {
            System.out.println(Thread.currentThread().getName() + "exec 1");
            Thread.sleep(500);
            System.out.println(Thread.currentThread().getName() + "exec 2");
            Thread.sleep(500);
            System.out.println(Thread.currentThread().getName() + "exec 3");
            Thread.sleep(500);
    }

    public static void main(String[] args) {
        MyRunnable myRunnable = new MyRunnable();
        Thread t1 = new Thread(myRunnable, "thread1");
        Thread t2 = new Thread(myRunnable, "thread2");
        t1.start();
        t2.start();
    }
}

结果如下

这段代码中，线程t1和t2使用的一个runnable对象，自然使用的也是同一个类锁,能够按顺序执行同步方法。

public class MyRunnable implements Runnable {
    @Override
    public void run() {
        try {
            printSome();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    //通过static关键字达到类锁级别
    public static synchronized void printSome() throws InterruptedException {
            System.out.println(Thread.currentThread().getName() + "exec 1");
            Thread.sleep(500);
            System.out.println(Thread.currentThread().getName() + "exec 2");
            Thread.sleep(500);
            System.out.println(Thread.currentThread().getName() + "exec 3");
            Thread.sleep(500);
    }

    public static void main(String[] args) {
        MyRunnable myRunnable1 = new MyRunnable();
        MyRunnable myRunnable2 = new MyRunnable();
        Thread t1 = new Thread(myRunnable1, "thread1");
        Thread t2 = new Thread(myRunnable2, "thread2");
        t1.start();
        t2.start();
    }
}

结果如下

这段代码中，虽然t1和t2使用了不同的runnable对象，但两个对象都属于一个类，所以在类锁的级别下，自然使用的也是同一把锁，能达到同步执行的效果。

总结

在针对各种各样synchronized 的用法时，首先先看是类锁级别还是对象锁级别，如果是对象锁级别，再看这个对象是一个全局的还是局部new出来的，或者是不同对象的this引用。总之就是判断多个线程进入同步区域时，是否使用的是同一把锁对象。