Synchronized详解

1.作用

能够保证在同一时刻最多只有一个线程执行该段代码，以达到保证并发安全的效果。

2.地位

（1）synchronized是java关键字，被java原生语言支持；

（2）最基本的互斥同步手段

（3）高并发中元老级角色

3.对象锁和类锁

对象锁：包括方法锁（默认锁对象为this当前实例对象）和同步代码块锁（自己指定锁对象）

方法锁示例1：

/**
 * 对象锁示例——方法修饰符形式
 *
 * @date 2019/7/24
 * @since 1.0.0
 */
public class SyncObjectMethod3 implements Runnable {
    static SyncObjectMethod3 instance = new SyncObjectMethod3();

    @Override
    public void run() {
        method();
    }

    public static void main(String args[]) {
        Thread t1 = new Thread(instance);
        Thread t2 = new Thread(instance);
        t1.start();
        t2.start();
        while (t1.isAlive() | t2.isAlive()) {

        }
        System.out.println("all finished!");
    }

    public synchronized void method()  {
        System.out.println("我的对象锁方法修饰符形式，我叫" + Thread.currentThread().getName());
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName()+"运行结束");
    }
}

运行结果：

指定对象锁示例2：

/**
 * 对象锁示例——指定锁对象
 *
 * @date 2019/7/24
 * @since 1.0.0
 */
public class SyncObjectCodeBlock2 implements Runnable {
    static SyncObjectCodeBlock2 instance = new SyncObjectCodeBlock2();
    Object lock1 = new Object();
    Object lock2 = new Object();

    public static void main(String args[]) {
        Thread t1 = new Thread(instance);
        Thread t2 = new Thread(instance);
        t1.start();
        t2.start();
        while (t1.isAlive() || t2.isAlive()) {
        }
        System.out.println("all finish!");
    }

    @Override
    public void run() {
        synchronized (lock1) {
            System.out.println("我是对象锁代码块形式lock1。我叫" + Thread.currentThread().getName());
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "lock1运行结束");
        }

        synchronized (lock2) {
            System.out.println("我是对象锁代码块形式lock2。我叫" + Thread.currentThread().getName());
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "lock2运行结束");
        }
    }

}

运行结果：

如果将第二个同步方法的lock2对象换成lock1，大家可以才推测下会有什么结果。当前结果是并行，lock1,lock2两个对象之间的锁相互不干扰。

类锁：指synchronized修饰静态方法或指定锁为Class对象

（1）只有一个class对象：Java类可能有多个对象，但是只有1个Class对象

（2）本质：所谓的类锁，不过是Class对象的锁而已

（3）用法和效果：类锁只能在同一时刻被同一个对象拥有。

类锁——同步静态方法锁示例3

/**同时访问静态和非静态同步方法

 * @date 2019/7/24
 * @since 1.0.0
 */
public class SyncStaticAndNormal8 implements Runnable {
    static SyncStaticAndNormal8 instance = new SyncStaticAndNormal8();
    public static void main(String args[]) {
        Thread t1 = new Thread(instance);
        Thread t2 = new Thread(instance);
        t1.start();
        t2.start();
        while (t1.isAlive() || t2.isAlive()) {
        }
        System.out.println("all finish!");
    }

    @Override
    public void run() {
        if("Thread-0".equals(Thread.currentThread().getName())){
            method1();
        }else{
            method2();
        }
    }

    public static synchronized  void method1(){
        System.out.println("我是静态加锁的方法1，我叫" + Thread.currentThread().getName());
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName()+"运行结束");
    }

    public synchronized  void method2(){
        System.out.println("我是普通加锁的方法2，我叫" + Thread.currentThread().getName());
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName()+"运行结束");
    }
}

运行结果：

 

Class对象锁示例4：

/**

 * @date 2019/7/24
 * @since 1.0.0
 */
public class SyncClass5 implements Runnable {
    static SyncClass5 instance1 = new SyncClass5();
    static SyncClass5 instance2 = new SyncClass5();

    @Override
    public void run() {
        method();
    }

    public static void main(String args[]) {
        Thread t1 = new Thread(instance1);
        Thread t2 = new Thread(instance2);
        t1.start();
        t2.start();
        while (t1.isAlive() | t2.isAlive()) {

        }
        System.out.println("all finished!");
    }

    public void method() {
        synchronized (SyncClass5.class) {
            System.out.println("我的类锁方法第2种形式，我叫" + Thread.currentThread().getName());
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "运行结束");
        }
    }
}

运行结果：

锁生效，串行执行。

4.多线程访问同步方法的7种情况（面试常考）

（1）两个线程同时访问一个对象的同步方法？

锁生效，线程会逐个执行，依次结束（串行），因为是同一把锁

（2）两个线程访问2个对象的同步方法？

2线程同时开始，同时结束（并行），因为锁的是不同的实例

（3）2个线程访问的是sychroonized的静态方法

锁生效，线程会逐个执行，依次结束

（4）同时访问同步方法和非同步方法

非同步方法不受影响

（5）访问同一个对象的不同普通同步方法

串行，默认指定this

（6）同时访问静态synchronizede和非静态synchronized方法

并行，静态同步方法本质是锁类Class，非静态锁this即当前对象实例，是不同的锁

（7）方法抛出异常后，会释放锁吗

会释放，Lock不会。

 

7问题总结：

（1）一把锁只会同时被一个线程获取，没有拿到锁的线程必须等待（对应1,5）

（2）每个实例都对应有自己的一把锁，不同实例之间互不影响；例外：锁对象是*.class以及sync修饰的static方法的时候,所有对象共用一把类锁（对应2,3,4,6情况）

（3）无论方法正常执行与否或者抛出异常，都会释放锁（对应7）