Synchronized使用方法

Synchronized是我们常用来维持线程安全时使用的一个关键字，内部通过monitor(监视器锁，由C++实现)来实现。而monitor本质又是依赖底层操作系统的mutex lock来实现。而操作系统实现线程之间的切换，需要从用户态切换到核心态，这个的成本非常高，状态之间的转换需要相对较长的时间，这也就是为什么synchronized效率低的原因。这种依赖mutex lock所实现的锁统称为“重量级锁”。jdk对Synchronized的优化，核心都是减少这种重量级锁的使用。

monitor：由C++实现，可以与对象一起创建和销毁，或者在线程尝试获取对象锁时创建。

一个线程尝试获取对象锁，会先令_owner指向该线程，同时_count自增1，这时候有其他线程尝试获取锁时，会先存入_EntryList集合，并进入阻塞。当前线程执行完成后，令_count自减1，_owner=null，同时将其放到_WaitSet中去。

如果线程被调用了wait()等方式，释放锁时，也会令_owner=null，_count减1，同时将该线程放入_WaitSet集合，等待唤醒。

Synchronized可以使用在三个地方：

1. 非静态方法
2. 静态方法
3. 代码块

首先我们先看一个普通的多线程方法

public class Main6  {

    public void method1() {
        System.out.println("method1 start");
        try {
            System.out.println("method1 exec");
            Thread.sleep();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("method1 completion");
    }

    public void method2() {
        System.out.println("method2 start");
        try {
            System.out.println("method2 exec");
            Thread.sleep();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("method2 completion");
    }

    public static void main(String[] args) {
        Main6 m1 = new Main6();
        Main6 m2 = new Main6();

        new Thread(new Runnable() {
            @Override
            public void run() {
                m1.method1();
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                m1.method2();
            }
        }).start();
    }
}

在这个方法执行的时候，method1()和method2()并行运行，但由于method2()的运行时间短，因此总是会先运行结束。

1.非静态方法

public class Main6  {

    public synchronized void method1() {
        System.out.println("method1 start");
        try {
            System.out.println("method1 exec");
            Thread.sleep();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("method1 completion");
    }

    public synchronized void method2() {
        System.out.println("method2 start");
        try {
            System.out.println("method2 exec");
            Thread.sleep();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("method2 completion");
    }

    public static void main(String[] args) {
        Main6 m1 = new Main6();
        Main6 m2 = new Main6();

        new Thread(new Runnable() {
            @Override
            public void run() {
                m1.method1();
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                m1.method2();
            }
        }).start();
    }
}

在非静态方法上添加synchronized关键字，当我们使用同一个对象分别在不同线程中调用该方法时候，会出现如下顺序的结果：

method1 start
method1 exec
method1 completion
method2 start
method2 exec
method2 completion

这是由于synchronized会获取当前调用对象的锁，当线程1在执行m1.method1();时候获取到了m1对象的锁，线程2企图执行m1.method2()方法时发现m1的锁已经被其他线程获取，因此会进入阻塞状态，直到线程1对method1()方法执行完。

注意，由于调用线程1的start()方法并不是一定会立即开始执行线程1，它先会与main线程争夺cpu等资源，因此有可能method2先执行，method1进入阻塞，直到method2执行完成后才会开始执行。

同时由于synchronized使用在非静态方法上获取的是当前对象的锁，因此假如线程1和2分别使用的是两个不同对象的mthod1方法和method2方法，则不会发生阻塞。

2.静态方法

public class Main6  {

    public static synchronized void method1() {
        System.out.println("method1 start");
        try {
            System.out.println("method1 exec");
            Thread.sleep();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("method1 completion");
    }

    public static synchronized void method2() {
        System.out.println("method2 start");
        try {
            System.out.println("method2 exec");
            Thread.sleep();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("method2 completion");
    }

    public static void main(String[] args) {
        Main6 m1 = new Main6();
        Main6 m2 = new Main6();

        new Thread(new Runnable() {
            @Override
            public void run() {
                m1.method1();
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                m2.method2();
            }
        }).start();
    }
}

静态方法与非静态方法的不同处在于方法是属于类，而不是属于当前对象。

这样即使我们调用的是不同对象的method1方法和method2方法，但是它们获取的锁是类对象的锁(Class对象的锁)，因此，不论使用的是哪个对象的method1和method2，均会发生线程阻塞的情况。只有当一个线程中的静态synchronized执行完成后才会执行另一个线程中的静态synchronized方法。

3.代码块

public class Main6  {

    public void method1() {
        System.out.println("method1 start");
        synchronized(this) {
            try {
                System.out.println("method1 exec");
                Thread.sleep();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("method1 completion");
    }

    public void method2() {
        System.out.println("method2 start");
        synchronized (this) {
            try {
                System.out.println("method2 exec");
                Thread.sleep();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("method2 completion");
    }

    public static void main(String[] args) {
        Main6 m1 = new Main6();new Thread(new Runnable() {
            @Override
            public void run() {
                m1.method1();
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                m1.method2();
            }
        }).start();
    }
}

输出的结果可能如下：

method1 start
method1 exec
method2 start
method1 completion
method2 exec
method2 completion

当synchronized被使用在代码块上时，它所获取的锁是括号中接收的对象的锁(如样例代码中的this指代的是当前调用它的对象)，这样，假设method1方法正在执行，并且进入代码块休眠3秒，这时method2获取cpu，开始执行第一行代码打印"method2 start"，然后遇见代码块，尝试获取this对象的锁，却发现已经被method1获取(sleet不释放锁)，因此method2进入阻塞状态，直到method1执行完毕后释放锁，method2获取锁开始执行代码块。

在代码块中调用Synchronized(下图)，侧重点在于第3步monitorenter，获取monitor，并对当前_count加一。里面内容执行完成后，在第15步monitorexit，令_count减一，同时释放monitor。

而当Synchronized被使用在方法上时，添加的是一个ACC_SYNCHRONIZED标志位，如果有该标志位，则判定当前方法使用了Synchronized