java中的同步锁包括对象锁和类锁。

对象锁：针对的是具体的对象实例；类锁：针对的是整个class类

现在先让我们看一些文绉绉的书本概念，暂时看不懂没关系，只要各位看官耐心看完这篇文章的，就都明白了

多线程之间的同步实际上是靠锁来实现的
在java的运行时环境中（即JVM虚拟机中），会被多线程共享的数据包括 堆中的实例变量和方法区中的类变量 （可以关注我的简书号，后续会有相关白话文章介绍JVM内存管理）
在JVM中，每个对象和类在逻辑上都与一个监视器相关联，这是JVM内部实现的，我们不需要关心。我们只需要记住以下两句话
1. 对于对象，监视器保护的是对象的实例变量（对象锁）
2. 对于类，监视器保护的是类的类变量（类锁）
这里多说一句，实际上类锁也是根据对象锁来实现的，具体不再展开介绍，以后会专门写文章介绍。

对于类锁，JVM在load class文件时，会创建一个与该class相关联的java.lang.Class类的实例，当锁住这个class类关联的java.lang.Class实例的时候，实际上就锁住了这个类的class类

对于每一个对象一个线程可以多次对同一个对象上锁，JVM维护一个加锁计数器，线程每获得一次该对象，计数器就加1，每释放一次，计数器就减 1，当计数器值为0时，锁就被完全释放了

我们无需去手动进行加锁释放锁，这些工作JVM都替我们完成了

看到这里，大家应该能明白，其实我们thread线程中每访问一个实例，内部其实都有加锁释放锁的动作。
大家或许有一个疑问，那我的变量或代码（即所谓的临界区）是怎么实现多线程安全访问呢？也就是说现在各个线程都拿到锁了，但是怎么去让这个锁生效呢？接下来就是我们的主角synchronized上场了

synchronized关键字

通过上述的分析，我们知道（线程）锁上锁的对象了，那么怎么上锁呢，实际就是通过这个synchronized关键字进行上锁。

synchronized 之所以可以实现同步，是因为java中的每一个对象都会作为锁，即java中的每一个对象JVM在内部都为其关联了一个监控器（即加了锁）

synchronized的作用域包括以下三个

普通同步方法，锁针对的是当前实例对象
静态同步方法，锁针对的是当前class对象
同步方法块，锁的是括号里面的对象（synchrozed（this））

如果小伙伴们还是觉得不太好理解，下面我们通过几个测试例子来看一下

package ke.com;

/**
 * Created by zl on 2019/4/30.
 */
public class ShareResource implements Runnable {

    static int i = 0;

    synchronized public void increase() {
        i = i+1;
    }

    @Override
    public void run() {
        for (int k=0; k<5000;k++) {
            increase();
        }

    }

    public static void main(String[] args) throws InterruptedException {
        ShareResource instance1 = new ShareResource();
        ShareResource instance2 = new ShareResource();

        Thread thread1 = new Thread(instance1);
        Thread thread2 = new Thread(instance2);

        thread1.start();
        thread2.start();
           // join的含义是等两个子线程都执行完毕后，主线程在执行打印代码
        thread1.join();
        thread2.join();
        System.out.println("i=" + i);
    }
 }

上面的代码执行结果是下图所示：

image.png

不是我们想象的10000。
这是因为我们的main方法中生成了两个ShareResource实例，即我们获取的是两把锁。所以我们应该用类锁，而不应该用对象锁（即我们所在了方法上），而对象锁是针对某一个具体实例的

我们把测试代码改成如下，对静态方法的synchronized就是对类的synchronized，这样我们获取琐时，获取的就是类锁

// 只需要把increate方法改成静态的
synchronized public static void increase() {
        i = i+1;
}

关于对象锁，这里多说一句，假如有synchronized method1 和synchronized method2 ，同步了多个方法，method1的锁不会造成 method2访问线程的阻塞，即两者的锁不会相互影响。
另外，同步也不会被继承

说完了普通方法同步和静态方法的同步，我们来看一下同步方法块

同步方法块

同步代码块又分为 synchronized（this）和synchronized（非this），下面我们通过具体代码来看一下两者的区别

package ke.com;

/**
 * Created by zl on 2019/4/30.
 */
public class SynchronizedThisTest {
    public static void main(String[] args) {
        Service service = new Service();
        ThreadA a = new ThreadA(service);
        a.start();

        ThreadB b = new ThreadB(service);
        b.start();

    }

}

class Service {
    public void serviceA() {
        synchronized (this) {
            System.out.println("业务A开始时间="+System.currentTimeMillis());
            // 让调用线程休眠2s让出cpu
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("业务A结束时间="+System.currentTimeMillis());
        }
    }

    public void serviceB() {
        synchronized (this) {
            System.out.println("业务B的开始时间="+System.currentTimeMillis());
            System.out.println("业务B的结束时间="+System.currentTimeMillis());
        }
    }
}

class ThreadA extends Thread {
    private Service service;
    ThreadA(Service s) {
        super();
        this.service = s;
    }

    @Override
    public void run() {
        super.run();
        // 调用业务A
        service.serviceA();
    }
}

class ThreadB extends Thread {
    private Service service;

    ThreadB(Service s) {
        this.service = s;
    }

    @Override
    public void run() {
        super.run();
        service.serviceB();
    }
}

上面代码的运行结果是

image.png

可见就算业务A的线程的时间很长，B线程也不会获取执行机会，说明synchronized（this）是锁的整个对象自身

下面我们换成synchronized（object）的形式看看
我们把Service类重写

class Service {
    public void serviceA() {
        Object o = new Object();
        synchronized (o) {
            System.out.println("业务A开始时间="+System.currentTimeMillis());
            // 让调用线程休眠2s让出cpu
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("业务A结束时间="+System.currentTimeMillis());
        }
    }

    public void serviceB() {
        Object o = new Object();
        synchronized (o) {
            System.out.println("业务B的开始时间="+System.currentTimeMillis());
            System.out.println("业务B的结束时间="+System.currentTimeMillis());
        }
    }
}

运行结果如下

image.png

所以在实际应用中一般不用synchronized(this) 而是用一个synchronized（object）产生两个锁，来提高执行效率

Object中的wait(),notify(),notifyAll()方法一般与synchronized同步锁绑定使用

让你不再害怕JAVA的锁（一）

让你不再害怕JAVA的锁（一）

synchronized关键字

同步方法块

推荐阅读更多精彩内容