理解synchronized的原理

synchronized的应用方式

synchronized关键字最主要有以下3种应用方式：

• 修饰代码块，指定加锁对象，给指定对象加锁，进入同步代码块前要获得给定对象的锁；
• 修饰实例方法（非static修饰的方法），作用于当前实例，进入同步代码块前要获得给定对象的锁；
• 修饰静态方法，作用于当前类对象加锁，进入同步代码块前要获得给定对象的锁；

synchronized作用于代码块
在一些情况下，我们编写的方法体可能比较大，同时存在一些比较耗时的操作，而需要同步的代码又只有一小部分，此时我们可以使用同步代码块的方式对需要同步的代码进行包裹。

public class test1 implements Runnable{
    static AccountingSync test1=new AccountingSync();
    static int i=0;
    @Override
    public void run() {
        //省略其他耗时操作....
        //使用同步代码块对变量i进行同步操作,锁对象为instance
        synchronized(test1){
            for(int j=0;j<50000;j++){
                    i++;
              }
        }
    }
    public static void main(String[] args) throws InterruptedException {
        Thread t1=new Thread(instance);
        Thread t2=new Thread(instance);
        t1.start();
        t2.start();
        //这里的Thread类中的join()方法是为了等待线程t1、t2结束,再完成主线程。
        //如果不加t1.join()和t2.join()输出的i的值为0；
        t1.join();
        t2.join();
        System.out.println(i);
    }
}

从代码看出，将synchronized作用于一个给定的实例对象instance，即当前实例对象就是锁对象，每次当线程进入synchronized包裹的代码块时就会要求当前线程持有instance实例对象锁，如果当前有其他线程正持有该对象锁，那么新到的线程就必须等待，这样也就保证了每次只有一个线程执行i++;操作。当然除了instance作为对象外，我们还可以使用this对象(代表当前实例)或者当前类的class对象（类名称.class）作为锁。

synchronized作用于实例方法
实例对象锁就是用synchronized修饰实例对象中的实例方法.

public class Test2 implements Runnable{
    //共享资源(临界资源)
    static int i=0;

    //synchronized修饰实例方法
    public synchronized void increase(){
        i++;
    }
    @Override
    public void run() {
        for(int j=0;j<50000;j++){
            increase();
        }
    }
    public static void main(String[] args) throws InterruptedException {
    	//线程1和线程2对同一个对象的临界资源进行操作
    	//注意：线程t1和t2，这里的对象锁是同一个
    	Test2 test2 = new Test2();
        //线程1
        Thread t1=new Thread(test2);
        //线程2
        Thread t2=new Thread(test2);
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        System.out.println(i);
    }
    /**
     * t1线程和t2线程同时对临界资源i进行操作。
     * 预计结果为：
     * 100000
     */
}

结果为100000。
上述代码中我们开启两个线程对同一个临界资源 i 进行操作。由于i++操作并不是原子性的，可能该操作在字节码角度是分两步进行的；先读取值，然后返回计算后的新值。这样的话，如果第二个线程在第一个线程读取旧值和写回新值期间读取i的域值，那么第二个线程就会与第一个线程一起看到同一个值，并执行相同值的加1操作，这也就造成了线程安全失败，因此对于increase方法必须使用synchronized修饰，以便保证线程安全。倘若我们没有使用synchronized关键字，其最终输出结果就绝大可能小于100000，这便是synchronized关键字的作用。

下面来看这样一种情况：

public class Test2 implements Runnable{
    static int i=0;
    public synchronized void increase(){
        i++;
    }
    @Override
    public void run() {
        for(int j=0;j<50000;j++){
            increase();
        }
    }
    public static void main(String[] args) throws InterruptedException {
    	//注意：下面的线程t1和t2，所持有的对象锁是不同对象的；但这两个线程操作的是临界资源，这就会出现问题。
        //实例1
        Thread t1=new Thread(new Test2());
        //实例2
        Thread t2=new Thread(new Test2());
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        System.out.println(i);
    }
}

结果为：一个小于100000的数字（两个线程每次的执行状态可能是不一样的）。
与前面不同的是我们同时创建了两个新实例Test2，然后启动两个不同的线程对共享变量i进行操作。所以最后 i 的结果不是100000；因为上述代码犯了严重的错误，虽然我们使用synchronized修饰了increase方法，但却new了两个不同的实例对象，这也就意味着存在着两个不同的实例对象锁，因此t1和t2都会进入各自的对象锁，也就是说t1和t2线程使用的是不同的锁，因此线程安全是无法保证的。
如果想让上面代码编译后输出的结果为100000，有两种方案：
1.按前面的这种写法，对同一对象：

Test2 test = new Test2();
Thread t1=new Thread(test);
Thread t2=new Thread(test);

2.将synchronized作用于静态的increase方法。（这样的话，对象锁就当前类对象，由于无论创建多少个实例对象，但对于的类对象拥有只有一个，所有在这样的情况下对象锁就是唯一的。）

synchronized作用于静态方法
当synchronized作用于静态方法时，其锁就是当前类的class对象锁。由于静态成员不专属于任何一个实例对象，是类成员，因此通过class对象锁可以控制静态成员的并发操作。

public class Test3 implements Runnable{
    static int i = 0;
    int int n = 99999;
    //这里对synchronized修饰的静态方法；
    public static synchronized void increase(){
        i++;
    }
    
    public synchronized void subtract(){
        n--;
    }

	public static synchronized void add(){
        i++;
    }
    
    @Override
    public void run() {
        for(int j=0;j<50000;j++){
            increase();
        }
    }
    public static void main(String[] args) throws InterruptedException {
    	//注意：下面的线程t1和t2，所持有的对象锁是不同对象的；但这两个线程操作的是临界资源。（这里不出现问题，是因为synchronized修饰的是静态方法，类对象只有一个）；
        //实例1
        Thread t1=new Thread(new Test3());
        //实例2
        Thread t2=new Thread(new Test3());
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        System.out.println(i);
    }
}

输出结果是：100000。
注意：由于synchronized关键字修饰的是静态increase方法，与修饰实例方法不同的是，其锁对象是当前类的class对象。代码中的add()方法和subtract()方法是实例方法，其对象锁是当前实例对象，如果别的线程调用subtract()方法，将不会产生互斥现象，毕竟锁对象不同。但我们应该意识到这种情况下如果调用add()方法可能会发现线程安全问题(操作了共享静态变量i)。

推荐看下这篇大神的博文《深入理解Java并发之synchronized实现原理》。