「JAVA」synchronized锁住的是代码还是对象

并发场景下，如何实现线程同步？ 你可能会立马想到Sychronized，但至于具体怎么用，让你讲一讲，又会感觉模棱两可的意思--说的是我。。。所谓一知半解就是不解，所以还是得好好理解一下，synchronized到底怎么用？刚好拜读到一篇文章，作者讲解思路清晰，简单明了，小弟收益匪浅，这里根据文章内容，代码重新验证一下。
在Java中，synchronized关键字是用来控制线程同步的，就是在多线程的环境下，控制synchronized代码段不被多个线程同时执行。synchronized即可加在一段代码上，也可以加在方法上。铛铛铛，划重点，千万不要以为给方法或者代码段加上synchronized就万事大吉，看下面一段代码：

/**
 * Created by ing on 2019/7/10
 */
class Sync {
    public synchronized void test(int i){
        System.out.println("test"+i+"开始...");
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("test"+i+"开始...");
    }

}

class MyThread extends Thread{
    int i;
    public MyThread(int i){
        this.i = i;
    }
    public void run(){
        Sync sync = new Sync();
        sync.test(i);
    }
}
public class Main{
    public static void main(String[] args){
        for (int i = 0; i < 3; i++) {
            Thread thread = new MyThread(i);
            thread.start();
        }
    }
}

如上代码，可能你的原意是运行之后，test应该是顺序执行，也就是test1开始...test1结束...test2开始...
但运行结果却是

test0开始...
test1开始...
test2开始...
test1结束...
test0结束...
test2结束...

啪，有掌声~你发现，上面程序起了三个线程，虽然test()方法加了synchronized 但是还是同时执行了起来，这里synchronized没起作用。

这时候你又想起了synchronized(this) 既然方法上加不起作用，那这个就应该可以了吧，毕竟就这么两种方法，总不能都有掌声。。。于是你伴随着键盘美妙音符，很快写就

test0开始...
test1开始...
test2开始...
test0结束...
test2结束...
test1结束...

啪啪~掌声又响起，羞红了你的脸。。。还是没看到synchronized起作用，摊手礼，到底怎么回事呢。。划重点，面试会考

实际上， synchronized(this)以及非static 的synchronized方法（至于static synchronized方法后面会讲），只能防止多个线程同时执行同一个对象的同步代码段。注意是 同一个对象

回到本文题目：synchronized锁住的是代码还是对象？ 答案是synchronized锁住的是括号里的对象，而不是代码。对于非synchronized方法，锁的就是对象本身也就是this .

当synchronized锁住一个对象后，别的线程如果也想拿到这个对象的锁，就必须等待这个线程执行完成后释放锁，才能再次给对象加锁，这样才能达到线程同步的目的，即使两个不同的代码段，都要锁同一个对象，那么这两个代码段也不能在多线程环境下同时运行。

所以我们在用synchronized关键字的时候，能缩小代码段的范围就尽量缩小，能在代码段上加同步就不要在整个方法上加同步，这叫减小锁的粒度，使代码更大程度的并发。原因是基于以上的思想，锁的代码段时间太长了，别的线程是不是要等很久，等的花儿都谢了。

再看上面的代码，每个线程中都new了一个Sync类的对象，也就是产生了三个Sync对象，由于不是同一个对象，所以可以多线程同时运行synchronized方法或代码段。

知道了原因，那么你需要做的就是再次修改一下，让三个线程使用同一个Sync对象

package com.ing.learn;

/**
 * Created by ing on 2019/7/10
 */
class Sync3 {

    public  void test(int i){
        synchronized (this){
            System.out.println("test"+i+"开始...");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("test"+i+"结束...");
        }
    }

}

class MyThread3 extends Thread{
    private Sync3 mSync3;
    int i;
    public MyThread3(Sync3 mSync3,int i){
        this.mSync3=mSync3;
        this.i=i;
    }
    public void run(){
        mSync3.test(i);
    }
}
public class Main3{
    public static void main(String[] args){
        Sync3 sync3 = new Sync3();
        for (int i = 0; i < 3; i++) {
            Thread thread = new MyThread3(sync3,i);
            thread.start();
        }
    }
}

运行结果

test0开始...
test0结束...
test2开始...
test2结束...
test1开始...
test1结束...

give me five ! 终于起作用了。

那么如果真的想锁住这段代码，要怎么做？也就是还是最开始的那段代码，每个线程new 一个Sync对象，怎么才能让test方法不会被多个线程执行。

解决也很简单，只要锁住同一个对象不就行了，例如，synchronized后的括号中锁同一个固定对象，这样就行了。这样是没问题，但是，比较多的做法是让synchronized锁这个类对应的Class对象

package com.ing.learn;

/**
 * Created by ing on 2019/7/10
 */
class Sync4 {

    public  void test(int i){
        synchronized (Sync4.class){
            System.out.println("test"+i+"开始...");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("test"+i+"结束...");
        }
    }

}

class MyThread4 extends Thread{
    int i;
    public MyThread4(int i){
        this.i=i;
    }
    public void run(){
        Sync4 sync = new Sync4();
        sync.test(i);
    }
}
public class Main4{
    public static void main(String[] args){
        for (int i = 0; i < 3; i++) {
            Thread thread = new MyThread4(i);
            thread.start();
        }
    }
}

运行结果

test0开始...
test0结束...
test1开始...
test1结束...
test2开始...
test2结束...

上面代码用synchronized(Sync4.class)实现了全局锁的效果。

最后，解释下static synchronized方法的特殊性：

static 方法可以直接类名加方法名调用，方法中无法使用this,所以它锁的不是this,而是类的Class对象，所以static synchrionized方法相当于全局锁，相当于锁住了代码段。