关于synchronized的三道面试题

1.为什么要使用synchronized

在并发编程中存在线程安全问题，主要原因有：1.存在共享数据 2.多线程共同操作共享数据。关键字synchronized可以保证在同一时刻，只有一个线程可以执行某个方法或某个代码块，同时synchronized可以保证一个线程的变化可见（可见性），即可以代替volatile。

2.实现原理

synchronized可以保证方法或者代码块在运行时，同一时刻只有一个方法可以进入到临界区，同时它还可以保证共享变量的内存可见性

3.synchronized的三种应用方式

Java中每一个对象都可以作为锁，这是synchronized实现同步的基础：

普通同步方法（实例方法），锁是当前实例对象 ，进入同步代码前要获得当前实例的锁
静态同步方法，锁是当前类的class对象 ，进入同步代码前要获得当前类对象的锁
同步方法块，锁是括号里面的对象，对给定对象加锁，进入同步代码库前要获得给定对象的锁。

4.synchronized的作用

Synchronized是Java中解决并发问题的一种最常用最简单的方法 ，他可以确保线程互斥的访问同步代码

5.synchronized锁工作原理

/**
 * 归根结底它上锁的资源只有两类：一个是对象，一个是类。
 */
public class SynchronizedTest {

    public static int i=0;

    SynchronizedTest test = new SynchronizedTest();
    /**
     * 对成员函数加锁，必须获得该类的实例对象的锁才能进入同步块
     */
    public synchronized void test1() {
        i++;
    }

    /**
     * 对静态方法加锁，必须获得该类的锁才能进入同步块，本文暂不关注该方法
     */
    public static synchronized void test2() {
        System.out.println("Hello static test2");
    }

    public void test3() {
        /**
         * 必须获得类锁
         */
        synchronized(SynchronizedTest.class) {
            System.out.println("Hello test3");
        }

        /**
         * 必须获得对象锁, 本文暂不关注该代码块
         */
        synchronized(test) {
            System.out.println("Hello test3-2");
        }
    }
}

反编译查看字节码：

// 编译生成字节码文件
javac SynchronizedTest.java 
// 反编译查看字节码文件
javap -verbose SynchronizedTest.class

同步块字节码：

// 编译生成字节码文件
javac SynchronizedTest.java 
// 反编译查看字节码文件
javap -verbose SynchronizedTest.class

同步块的字节码：

由monitorenter指令进入，然后monitorexit释放锁，在执行monitorenter之前需要尝试获取锁，如果这个对象没有被锁定，或者当前线程已经拥有了这个对象的锁，那么就把锁的计数器加1。当执行monitorexit指令时，锁的计数器也会减1。

6.关于synchronized的三道面试题

public class SynchronizedTest01 {

    public synchronized void one(){
        System.out.println("1111");
    }

    public synchronized void two(){
        System.out.println("2222");
    }

    public static void main(String[] args) {
        final SynchronizedTest01 test = new SynchronizedTest01();

        //非静态方法去竞争同一个对象(SynchronizedTest01 test)头部的锁，因此存在锁的竞争

        new Thread(new Runnable() {
            @Override
            public void run() {
                test.one();
            }
        }).start();

        new Thread(new Runnable() {
            @Override
            public void run() {
                test.two();
            }
        }).start();
    }
}

public class SynchronizedTest02 {

    public static synchronized void one(){
        System.out.println("1111");
    }

    public static synchronized void two(){
        System.out.println("2222");
    }

    public static void main(String[] args) {
        final SynchronizedTest02 testOne = new SynchronizedTest02();
        final SynchronizedTest02 testTwo = new SynchronizedTest02();

        //静态方法是对类加锁,testOne和testTwo是同一个类的两个实例化对象，因此存在锁的竞争

        new Thread(new Runnable() {
            @Override
            public void run() {
                testOne.one();
            }
        }).start();

        new Thread(new Runnable() {
            @Override
            public void run() {
                testTwo.two();
            }
        }).start();
    }
}

public class SynchronizedTest03 {
    public void one(){
        synchronized (this){
            System.out.println("1111");
        }
    }

    public void two(){
        synchronized (this){
            System.out.println("2222");
        }
    }

    public static void main(String[] args) {
        final SynchronizedTest03 test = new SynchronizedTest03();

        //同步代码块的锁对象是this(即当前对象test),因此存在锁的竞争。

        new Thread(new Runnable() {
            @Override
            public void run() {
                test.one();
            }
        }).start();

        new Thread(new Runnable() {
            @Override
            public void run() {
                test.two();
            }
        }).start();
    }

}

以上三个代码段均会出现synchronized锁的竞争。