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);
}
}
上面的代码执行结果是下图所示：
不是我们想象的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();
}
}
可见就算业务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());
}
}
}
所以在实际应用中一般不用synchronized(this) 而是用一个synchronized（object）产生两个锁，来提高执行效率
Object中的wait(),notify(),notifyAll()方法一般与synchronized同步锁绑定使用
