synchronized 使用详解+案例

synchronized 锁的类型

synchronized的锁类型，我觉得主要分为两种，一种是类锁，一种是实例对象锁。

类锁

类锁，顾名思义，就是在这个类上面加锁，也就是说，对于所有加了类锁的方法的时候，一次只有一个线程能够调用一个增加类锁的方法。

加类锁的方式

1、在静态方法上面使用 synchronized 进行修饰
2、加类锁的方式是在代码段中增加 synchronized 片段，如，上述增加类锁的方式就是在某一代码段中增加。 synchronized(Data.class) {}
案例如下：

public class Data {
	public static void main(String[] args) {
        new Thread(() -> {
            Data.method1();
        }, "A").start();
        new Thread(() -> {
            Data.method1();
        }, "B").start();
    }
    public synchronized static void method1() {
        for (int i=0; i<3; i++) {
            System.out.println("method01,  Thread name: " + Thread.currentThread().getName());
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public synchronized static void method2() {
        for (int i=0; i<3; i++) {
            System.out.println("method2， Thread name: " + Thread.currentThread().getName());
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

输入如下：
method01, Thread name: A
method01, Thread name: A
method01, Thread name: A
method02， Thread name: B
method02， Thread name: B
method02， Thread name: B

从上述输出可以看出两个线程访问两个加了类锁的两个方法，一次只能有一个加了类锁的方法被访问。

对象锁

对象是是针对于对象的实例，对于同一个对象的多个实例而言，增加了对象锁的两个方法，同一个实例对象一次只能调用一个增加对象锁的方法。

加对象锁的方式

1、就是在一个普通的方法上面增加 synchronized 关键字。
2、在方法的代码块中使用 synchronized 关键字。格式如：synchronized(this)

public class Data {
    public static void main(String[] args) {
        Data data = new Data();
        new Thread(() -> {
            data.method1();
        }, "A").start();
        new Thread(() -> {
            data.method2();
        }, "B").start();
    }
    public synchronized void method1() {
        for (int i=0; i<3; i++) {
            System.out.println("method01,  Thread name: " + Thread.currentThread().getName());
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public synchronized void method2() {
        for (int i=0; i<3; i++) {
            System.out.println("method02， Thread name: " + Thread.currentThread().getName());
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

输出如下：
method01, Thread name: A
method01, Thread name: A
method01, Thread name: A
method02， Thread name: B
method02， Thread name: B
method02， Thread name: B

证实了上述的结论。

对于类锁和对象锁的调用呢？

如果两个线程一个调用了类锁一个调用了对象锁呢，顺序是怎么样的？
案例：

public class Data {
    public static void main(String[] args) {
        Data data = new Data();
        new Thread(() -> {
            Data.method1();
        }, "A").start();
        new Thread(() -> {
            data.method2();
        }, "B").start();
    }
    public synchronized static void method1() {
        for (int i=0; i<3; i++) {
            System.out.println("method01,  Thread name: " + Thread.currentThread().getName());
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public synchronized  void method2() {
        for (int i=0; i<3; i++) {
            System.out.println("method02， Thread name: " + Thread.currentThread().getName());
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

输出：
method01, Thread name: A
method02， Thread name: B
method01, Thread name: A
method02， Thread name: B
method01, Thread name: A
method02， Thread name: B
从输出可以看出，类锁和对象锁之间是互不干扰的，没什么影响。

如有问题，忘大家指正。