Java关键字：synchronized

synchronized是Java中的关键字，是一种同步锁。它修饰的对象有以下几种：

修饰一个方法

被修饰的方法称为同步方法，其作用的范围是整个方法，作用的对象是调用这个方法的对象；

修饰一个静态的方法

其作用的范围是整个静态方法，作用的对象是这个类的所有对象；

修饰一个代码块

被修饰的代码块称为同步语句块，其作用的范围是大括号{}括起来的代码，作用的对象是调用这个代码块的对象；

修饰一个类

其作用的范围是synchronized后面括号括起来的部分，作用主的对象是这个类的所有对象。

修饰一个方法
被修饰的方法称为同步方法，其作用的范围是整个方法，作用的对象是调用这个方法的对象；

如果多个线程访问同一个对象的实例变量，可能出现非线程安全问题。

例子：a线程set后sleep2000ms，看b线程是否可以趁机set，造成非线程安全

HasSelfPrivateNum.java:

package service;
 
public class HasSelfPrivateNum {
 
    private int num = 0;
 
    public void addI(String username) {
        try {
            if (username.equals("a")) {
                num = 100;
                System.out.println("a set over!");
                Thread.sleep(2000);
            } else {
                num = 200;
                System.out.println("b set over!");
            }
            System.out.println(username + " num=" + num);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
 
}

package extthread;
 
import service.HasSelfPrivateNum;
 
public class ThreadA extends Thread {
 
    private HasSelfPrivateNum numRef;
 
    public ThreadA(HasSelfPrivateNum numRef) {
        super();
        this.numRef = numRef;
    }
 
    @Override
    public void run() {
        super.run();
        numRef.addI("a");
    }
 
}

package extthread;
 
import service.HasSelfPrivateNum;
 
public class ThreadB extends Thread {
 
    private HasSelfPrivateNum numRef;
 
    public ThreadB(HasSelfPrivateNum numRef) {
        super();
        this.numRef = numRef;
    }
 
    @Override
    public void run() {
        super.run();
        numRef.addI("b");
    }
 
}

run：

package test;
 
import service.HasSelfPrivateNum;
import extthread.ThreadA;
import extthread.ThreadB;
 
public class Run {
    public static void main(String[] args) {
 
        HasSelfPrivateNum numRef = new HasSelfPrivateNum();
 
        ThreadA athread = new ThreadA(numRef);
        athread.start();
 
        ThreadB bthread = new ThreadB(numRef);
        bthread.start();
 
    }
}

结果：a线程set后sleep2000ms，b线程可以趁机set，造成非线程安全

这时我们使用synchronized修饰addI方法：

package service;
 
public class HasSelfPrivateNum {
 
    private int num = 0;
 
    synchronized public void addI(String username) {
        try {
            if (username.equals("a")) {
                num = 100;
                System.out.println("a set over!");
                Thread.sleep(2000);
            } else {
                num = 200;
                System.out.println("b set over!");
            }
            System.out.println(username + " num=" + num);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
 
}

结果：B不能set了，说明线程安全。

注意：我们取得的是对象锁，也就是说，一个对象一个锁，而不是锁住整个类或者代码或者方法。

例子：两个对象两个锁

打印名字后sleep，最后打印end

package extobject;
 
public class MyObject {
 
    synchronized public void methodA() {
        try {
            System.out.println("begin methodA threadName="
                    + Thread.currentThread().getName());
            Thread.sleep(5000);
            System.out.println("end");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
 
}

package extthread;
 
import extobject.MyObject;
 
public class ThreadA extends Thread {
 
    private MyObject object;
 
    public ThreadA(MyObject object) {
        super();
        this.object = object;
    }
 
    @Override
    public void run() {
        super.run();
        object.methodA();
    }
 
}

package extthread;
 
import extobject.MyObject;
 
public class ThreadB extends Thread {
 
    private MyObject object;
 
    public ThreadB(MyObject object) {
        super();
        this.object = object;
    }
 
    @Override
    public void run() {
        super.run();
        object.methodA();
    }
}

RUN:

package test.run;
 
import extobject.MyObject;
import extthread.ThreadA;
import extthread.ThreadB;
 
public class Run {
 
    public static void main(String[] args) {
        MyObject object = new MyObject();
        ThreadA a = new ThreadA(object);
        a.setName("A");
        ThreadB b = new ThreadB(object);
        b.setName("B");
 
        a.start();
        b.start();
    }
 
}

结果：两个对象互不影响，各自运行各自上锁

其它方法被调用是什么效果呢？

之前做实验是因为怕大家不理解知识，现在大家已经有了一定的基础，这个结论不再做实验。

结论：

如果A线程持有x对象的锁，B线程不可调用synchronized修饰的方法，但是可以异步调用没有被synchronized修饰的方法

synchronized具有锁重入功能，也就是说一个线程获得锁，再次请求是可以再次得到对象的锁的

下面做实验验证这个结论：

package myservice;
 
public class Service {
 
    synchronized public void service1() {
        System.out.println("service1");
        service2();
    }
 
    synchronized public void service2() {
        System.out.println("service2");
        service3();
    }
 
    synchronized public void service3() {
        System.out.println("service3");
    }
 
}

thread:

package extthread;
 
import myservice.Service;
 
public class MyThread extends Thread {
    @Override
    public void run() {
        Service service = new Service();
        service.service1();
    }
 
}

run:

package test;
 
import extthread.MyThread;
 
public class Run {
    public static void main(String[] args) {
        MyThread t = new MyThread();
        t.start();
    }
}

结果验证了上面的结论：

注：在父子类之间同样适用，不再做实验

但是如果一个线程出现了异常，难道就永远锁住了资源吗？其实不是的，出现异常自动释放锁。

实验：让a锁住对象后出现异常，看b是否可以拿到锁，代码不再展示。

结果：b可以正常执行。

修饰一个静态的方法

其作用的范围是整个静态方法，作用的对象是这个类的所有对象；

也就是说整个类就一个锁，这也和静态的概念相符（静态方法和属性是属于类的而不是具体一个对象的）

让我们来验证这个结论：

service：

package service;
 
public class Service {
 
    synchronized public static void printA() {
        try {
            System.out.println("线程名称为：" + Thread.currentThread().getName()
                    + "在" + System.currentTimeMillis() + "进入printA");
            Thread.sleep(3000);
            System.out.println("线程名称为：" + Thread.currentThread().getName()
                    + "在" + System.currentTimeMillis() + "离开printA");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
 
    synchronized public static void printB() {
        System.out.println("线程名称为：" + Thread.currentThread().getName() + "在"
                + System.currentTimeMillis() + "进入printB");
        System.out.println("线程名称为：" + Thread.currentThread().getName() + "在"
                + System.currentTimeMillis() + "离开printB");
    }
 
}

a：

package extthread;
 
import service.Service;
 
public class ThreadA extends Thread {
    private Service service;
 
    public ThreadA(Service service) {
        super();
        this.service = service;
    }
 
    @Override
    public void run() {
        service.printA();
    }
}

b：

package extthread;
 
import service.Service;
 
public class ThreadB extends Thread {
    private Service service;
 
    public ThreadB(Service service) {
        super();
        this.service = service;
    }
 
    @Override
    public void run() {
        service.printB();
    }
}

run：

package test;
 
import service.Service;
import extthread.ThreadA;
import extthread.ThreadB;
 
public class Run {
 
    public static void main(String[] args) {
 
        Service service1 = new Service();
        Service service2 = new Service();
 
        ThreadA a = new ThreadA(service1);
        a.setName("A");
        a.start();
 
        ThreadB b = new ThreadB(service2);
        b.setName("B");
        b.start();
 
    }
 
}

结果：

但是，请注意一个显而易见的结论：a线程访问synchronized修饰的静态方法时，b线程可以访问synchronized修饰的非静态方法，原因也很容易想到：静态方法是属于类的，普通方法是属于对象本身的，所以一个是对象锁，一个是class锁，不会影响。

为了验证这个结论，我们做实验看看结果。

service：

AB为静态的，C普通的。

package service;
 
public class Service {
 
    synchronized public static void printA() {
        try {
            System.out.println("线程名称为：" + Thread.currentThread().getName()
                    + "在" + System.currentTimeMillis() + "进入printA");
            Thread.sleep(3000);
            System.out.println("线程名称为：" + Thread.currentThread().getName()
                    + "在" + System.currentTimeMillis() + "离开printA");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
 
    synchronized public static void printB() {
        System.out.println("线程名称为：" + Thread.currentThread().getName() + "在"
                + System.currentTimeMillis() + "进入printB");
        System.out.println("线程名称为：" + Thread.currentThread().getName() + "在"
                + System.currentTimeMillis() + "离开printB");
    }
 
    synchronized public void printC() {
        System.out.println("线程名称为：" + Thread.currentThread().getName() + "在"
                + System.currentTimeMillis() + "进入printC");
        System.out.println("线程名称为：" + Thread.currentThread().getName() + "在"
                + System.currentTimeMillis() + "离开printC");
    }
 
}

a：

package extthread;
 
import service.Service;
 
public class ThreadA extends Thread {
    private Service service;
 
    public ThreadA(Service service) {
        super();
        this.service = service;
    }
 
    @Override
    public void run() {
        service.printA();
    }
 
}

b：

package extthread;
 
import service.Service;
 
public class ThreadB extends Thread {
    private Service service;
 
    public ThreadB(Service service) {
        super();
        this.service = service;
    }
 
    @Override
    public void run() {
        service.printB();
    }
}

c：

package extthread;
 
import service.Service;
 
public class ThreadC extends Thread {
 
    private Service service;
 
    public ThreadC(Service service) {
        super();
        this.service = service;
    }
 
    @Override
    public void run() {
        service.printC();
    }
}

run：

package test;
 
import service.Service;
import extthread.ThreadA;
import extthread.ThreadB;
import extthread.ThreadC;
 
public class Run {
 
    public static void main(String[] args) {
 
        Service service = new Service();
 
        ThreadA a = new ThreadA(service);
        a.setName("A");
        a.start();
 
        ThreadB b = new ThreadB(service);
        b.setName("B");
        b.start();
 
        ThreadC c = new ThreadC(service);
        c.setName("C");
        c.start();
 
    }
 
}

结果：

说明：验证了结论，因为AB同步执行，C异步执行。

修饰一个代码块
被修饰的代码块称为同步语句块，其作用的范围是大括号{}括起来的代码，作用的对象是调用这个代码块的对象；（而不一定是本对象了）

（synchronized方法是对当前对象加锁，synchronized代码块是对某个对象加锁）

用synchronized声明方法是有弊端的，比如A调用同步方法执行一个很长时间的任务，这时B就必须等待，有时候这种长时间等待是低效率且没有必要的，这时我们就要认识一下synchronized同步代码块了。

格式是这样的：synchronized(类名){......}

我们先来认识第一种用法来体会修饰代码块的好处：

synchronized(this)同步代码块：a调用相关代码后，b对其它synchronized方法和synchronized(this)同步代码块调用会阻塞。但是没有被synchronized修饰的代码就得以执行，不像之前修饰方法那么死板了。

我们来看一个例子：

第一个循环异步，第二个循环同步：

package mytask;
 
public class Task {
 
    public void doLongTimeTask() {
        for (int i = 0; i < 100; i++) {
            System.out.println("nosynchronized threadName="
                    + Thread.currentThread().getName() + " i=" + (i + 1));
        }
        System.out.println("");
        synchronized (this) {
            for (int i = 0; i < 100; i++) {
                System.out.println("synchronized threadName="
                        + Thread.currentThread().getName() + " i=" + (i + 1));
            }
        }
 
    }
}

thread1：

package mythread;
 
import mytask.Task;
 
public class MyThread1 extends Thread {
 
    private Task task;
 
    public MyThread1(Task task) {
        super();
        this.task = task;
    }
 
    @Override
    public void run() {
        super.run();
        task.doLongTimeTask();
    }
 
}

thread2：

package mythread;
 
import mytask.Task;
 
public class MyThread2 extends Thread {
 
    private Task task;
 
    public MyThread2(Task task) {
        super();
        this.task = task;
    }
 
    @Override
    public void run() {
        super.run();
        task.doLongTimeTask();
    }
 
}

run：

package test;
 
import mytask.Task;
import mythread.MyThread1;
import mythread.MyThread2;
 
public class Run {
 
    public static void main(String[] args) {
        Task task = new Task();
 
        MyThread1 thread1 = new MyThread1(task);
        thread1.start();
 
        MyThread2 thread2 = new MyThread2(task);
        thread2.start();
    }
}

结果：

在非同步代码块时，是交叉打印的

同步代码块时排队执行：

另一个用法：

synchronized(非this)同步代码块（也就是说将任意对象作为对象监视器）：

格式：synchronized(非this对象x){......}

1、当多个线程持有的对象监听器为同一个对象时，依旧是同步的，同一时间只有一个可以访问，

2、但是对象不同，执行就是异步的。

这样有什么好处呢？

（因为如果一个类有很多synchronized方法或synchronized（this）代码块，还是会影响效率，这时用synchronized(非this)同步代码块就不会和其它锁this同步方法争抢this锁）

实验

第一点我们就不验证了，因为体现不出它的好处，我们验证第二点：

service：

一个同步非this代码块，一个同步方法：

package service;
 
public class Service {
 
    private String anyString = new String();
 
    public void a() {
        try {
            synchronized (anyString) {
                System.out.println("a begin");
                Thread.sleep(3000);
                System.out.println("a   end");
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
 
    synchronized public void b() {
        System.out.println("b begin");
        System.out.println("b   end");
    }
 
}

a：

package extthread;
 
import service.Service;
 
public class ThreadA extends Thread {
    private Service service;
 
    public ThreadA(Service service) {
        super();
        this.service = service;
    }
 
    @Override
    public void run() {
        service.a();
 
    }
 
}

b：

package extthread;
 
import service.Service;
 
public class ThreadB extends Thread {
 
    private Service service;
 
    public ThreadB(Service service) {
        super();
        this.service = service;
    }
 
    @Override
    public void run() {
        service.b();
 
    }
 
}

run：

package test;
 
import service.Service;
import extthread.ThreadA;
import extthread.ThreadB;
 
public class Run {
 
    public static void main(String[] args) {
        Service service = new Service();
 
        ThreadA a = new ThreadA(service);
        a.setName("A");
        a.start();
 
        ThreadB b = new ThreadB(service);
        b.setName("B");
        b.start();
 
    }
 
}

结果：

确实是异步的。

最后一个要注意的点：我们知道synchronized(非this对象x){......}是将对象x监视，这也就意味着当线程a调用这段代码时，线程b调用类x中的同步方法和代码块也会是同步的效果（阻塞）。

为了让大家更明白，做最后一个例子：

首先创建一个有静态方法的类：

package test2.extobject;
 
public class MyObject {
    synchronized public void speedPrintString() {
        System.out.println("speedPrintString ____getLock time="
                + System.currentTimeMillis() + " run ThreadName="
                + Thread.currentThread().getName());
        System.out.println("-----------------");
        System.out.println("speedPrintString releaseLock time="
                + System.currentTimeMillis() + " run ThreadName="
                + Thread.currentThread().getName());
    }
}

然后用 synchronized(非this对象x){......}的形式引用它，并进入这个代码块，然后看看这时这个静态方法是否可以被调用。

service：作用是synchronized(object)

package test2.service;
 
import test2.extobject.MyObject;
 
public class Service {
 
    public void testMethod1(MyObject object) {
        synchronized (object) {
            try {
                System.out.println("testMethod1 ____getLock time="
                        + System.currentTimeMillis() + " run ThreadName="
                        + Thread.currentThread().getName());
                Thread.sleep(5000);
                System.out.println("testMethod1 releaseLock time="
                        + System.currentTimeMillis() + " run ThreadName="
                        + Thread.currentThread().getName());
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
 
}

threadA：

package test2.extthread;
 
import test2.extobject.MyObject;
import test2.service.Service;
 
public class ThreadA extends Thread {
 
    private Service service;
    private MyObject object;
 
    public ThreadA(Service service, MyObject object) {
        super();
        this.service = service;
        this.object = object;
    }
 
    @Override
    public void run() {
        super.run();
        service.testMethod1(object);
    }
 
}

threadB：

package test2.extthread;
 
import test2.extobject.MyObject;
 
public class ThreadB extends Thread {
    private MyObject object;
 
    public ThreadB(MyObject object) {
        super();
        this.object = object;
    }
 
    @Override
    public void run() {
        super.run();
        object.speedPrintString();
    }
}

run：

package test2.run;
 
import test2.extobject.MyObject;
import test2.extthread.ThreadA;
import test2.extthread.ThreadB;
import test2.service.Service;
 
public class Run {
 
    public static void main(String[] args) throws InterruptedException {
        Service service = new Service();
        MyObject object = new MyObject();
 
        ThreadA a = new ThreadA(service, object);
        a.setName("a");
        a.start();
 
        Thread.sleep(100);
 
        ThreadB b = new ThreadB(object);
        b.setName("b");
        b.start();
    }
 
}

结果：

是同步的。

当然，把修饰方法改为修饰代码块也是一样不能被执行的。

Synchronized的作用主要有三个：（1）确保线程互斥的访问同步代码（2）保证共享变量的修改能够及时可见（3）有效解决重排序问题。

synchronized底层原理
在 Java 早期版本中，synchronized属于重量级锁，效率低下，因为监视器锁（monitor）是依赖于底层的操作系统来实现，Java 的线程是映射到操作系统的原生线程之上的。如果要挂起或者唤醒一个线程，都需要操作系统帮忙完成，而操作系统实现线程之间的切换时需要从用户态转换到内核态，这个状态之间的转换需要相对比较长的时间，时间成本相对较高。

在 Java 6 之后从 JVM 层面对synchronized 较大优化，锁的实现引入了如自旋锁、适应性自旋锁、锁消除、锁粗化、偏向锁、轻量级锁等技术来减少锁操作的开销。

synchronized 同步语句块的实现使用的是 monitorenter 和 monitorexit 指令。

其中 monitorenter 指令指向同步代码块的开始位置，monitorexit 指令则指明同步代码块的结束位置。

当执行 monitorenter 指令时，线程试图获取锁也就是获取 monitor(monitor对象存在于每个Java对象的对象头中，synchronized 锁便是通过这种方式获取锁的，也是为什么Java中任意对象可以作为锁的原因) 的持有权.当计数器为0则可以成功获取，获取后将锁计数器设为1也就是加1。相应的在执行 monitorexit 指令后，将锁计数器设为0，表明锁被释放。如果获取对象锁失败，那当前线程就要阻塞等待，直到锁被另外一个线程释放为止。

synchronized 修饰的方法并没有 monitorenter 指令和 monitorexit 指令，取得代之的是ACC_SYNCHRONIZED标识，该标识指明了该方法是一个同步方法，JVM 通过该 ACC_SYNCHRONIZED 访问标志来辨别一个方法是否声明为同步方法，从而执行相应的同步调用。但是原理其实都是类似的。具体的实现是操作系统的知识可以去翻我操作系统的文章。

锁详解
锁主要存在四种状态，依次是：无锁状态、偏向锁状态、轻量级锁状态、重量级锁状态，他们会随着竞争的激烈而逐渐升级。注意锁可以升级不可降级，这种策略是为了提高获得锁和释放锁的效率。

自旋：当有个线程A去请求某个锁的时候，这个锁正在被其它线程占用，但是线程A并不会马上进入阻塞状态，而是循环请求锁(自旋)。这样做的目的是因为很多时候持有锁的线程会很快释放锁的，线程A可以尝试一直请求锁，没必要被挂起放弃CPU时间片，因为线程被挂起然后到唤醒这个过程开销很大,当然如果线程A自旋指定的时间还没有获得锁，仍然会被挂起。

自适应性自旋：自适应性自旋是自旋的升级、优化，自旋的时间不再固定，而是由前一次在同一个锁上的自旋时间及锁的拥有者的状态决定。例如线程如果自旋成功了，那么下次自旋的次数会增多，因为JVM认为既然上次成功了，那么这次自旋也很有可能成功，那么它会允许自旋的次数更多。

锁消除是指虚拟机即时编译器在运行时，对一些代码上要求同步，但是被检测到不可能存在共享数据竞争的锁进行消除。

偏向锁的目的是消除数据在无竞争情况下的同步原语，进一步提高程序的运行性能。如果说轻量级锁是在无竞争的情况下使用CAS操作去消除同步使用的互斥量，那么偏向锁就是在无竞争的情况下把整个同步都消除掉，连CAS操作都不用做了。偏向锁默认是开启的，也可以关闭。

Java关键字：synchronized

farAway

引用和评论

特征抽取并转换成Spark或Flink执行计划的思路

在Java程序中监听mysql的binlog

Jerry和您聊聊Chrome开发者工具

Bitmap 和布隆过滤器傻傻分不清？你这不应该啊

Just for fun——迅速写完快速排序

Spring 实现 3 种异步流式接口，干掉接口超时烦恼

💢线上高延迟请求排查

Java关键字：synchronized

farAway

引用和评论

特征抽取并转换成Spark或Flink执行计划的思路

在Java程序中监听mysql的binlog

Jerry和您聊聊Chrome开发者工具

Bitmap 和 布隆过滤器傻傻分不清？你这不应该啊

Just for fun——迅速写完快速排序

Spring 实现 3 种异步流式接口，干掉接口超时烦恼

💢线上高延迟请求排查

Bitmap 和布隆过滤器傻傻分不清？你这不应该啊