Java synchronized实现和原理介绍

synchronized是同步的意思，在java多线程中，我们一般会考虑共享数据的处理，共享数据的处理包含两块，第一是共享数据，第二是在多线程访问共享数据的时候，如果处理共享数据，保证数据的有效正确性。

我们要保证线程A访问共享数据，对数据进行处理的时候，其他线程能够等待线程A访问完毕后，和线程A看到相同的数据，再进行自己的业务处理，这也就是互斥锁。

java中，synchronized可以保证同一时刻，只有一个线程对某个方法某个代码块访问的时候。synchronized还有一个作用，保证一个线程的变化(主要是共享数据的变化)，能够被其他线程看到。

synchronized的三种应用方式：

1、修饰实例方法，作用于实例方法，给实例加锁

2、修饰静态方法，给当前类加锁，要访问代码前，要获得类对象的锁

3、修饰代码块，指定加锁对象，对给定对象加锁，进入同步代码库前要获得给定对象的锁

修饰实例方法

同步锁是给对象的，下面代码中，一个对象只有一把同步锁，两个线程获取同一把锁，所以thread2只能等到thread完成业务逻辑，释放同步锁，thread2才能获得锁，进行操作。运行结束后i的值为2000000。

package sychronized;

public class SychronizedTest implements Runnable {
    
    static int i = 0;
    
    public static void main(String[] args) throws InterruptedException {

        SychronizedTest test = new SychronizedTest();
        
        Thread thread = new Thread(test);
        Thread thread2 = new Thread(test);
        
        thread.start();
        thread2.start();
        
        thread.join();
        thread2.join();
        
        System.out.print(i);
    }

    @Override
    public void run() {
        for(int j=0;j<1000000;j++){
            increase();
        }
    }
    
    //对方法加了互斥锁
    public synchronized void increase(){
        i++;
    }
}
 

如果此时thread和thread2获得的锁是不一样的对象，那么这两个线程是互补干扰的，不用相互等待对方获得互斥锁，各自可以获得对象锁，进行操作。这种情况下i的值就会被这两个线程同时操作，那么运行的结果就肯定是小于2000000。因为两个线程同时操作，异步进行。

类似这样

修饰静态方法

当synchronized作用于静态方法，那么锁就是当前class对象锁。由于静态成员不属于任何一个实例对象，而是属于类成员，因此通过class对象锁来控制静态成功的并发控制。如果一个线程调用一个实例对象的非static synchronized方法，并不会影响另外的线程调用该实例对象的synchronized方法，不会出现互斥现象。访问静态同步方法占用的锁是当前类的class对象，而访问非静态同步方法占用的锁是实例对象锁。

package sychronized;

public class SychronizedTest implements Runnable {
    
    static int i = 0;
    
    public static void main(String[] args) throws InterruptedException {

        SychronizedTest test = new SychronizedTest();
        SychronizedTest test1 = new SychronizedTest();
        
        Thread thread = new Thread(test);
        Thread thread2 = new Thread(test1);
        
        thread.start();
        thread2.start();
        
        thread.join();
        thread2.join();
        
        System.out.print(i);
    }

    @Override
    public void run() {
        for(int j=0;j<1000000;j++){
            //如果run是调用increase方法，此方法是静态方法，锁是当前的类对象锁，不属于任何一个实例化对象，结果是2000000
            increase();
            //如果run是调用increase1方法，那这个方法是实例化对象锁，多线程占用同一个对象锁，需要等待，多线程
            //占用不一样的锁，是互斥锁，不需要等待其他线程释放，就可以占用锁，结果小于2000000
            increase1();
        }
    }
    
    //对方法加了互斥锁
    public static synchronized void increase(){
        i++;
    }
    
    public synchronized void increase1(){
        i++;
    }
}
 

修饰代码块

synchronized也可以对某个代码块进行修饰，而不用对整个方法就是控制。synchronized作用于实例对象this，即当前实例对象就是锁对象，当有其他对象持有该锁时，其他线程要拥有此锁需要等待当前线程结束释放才可以。或者当前的类的class对象作为锁，如下代码

实例对象作为锁对象

类的class作为锁