深入理解synchronized

一、类锁和对象锁

synchronized一般就是用在同步方法和同步代码块里面，synchronized是基于对象实现的，就是指锁对象是哪个：

同步方法：

/**
     * 同步方法
     * 方法没有static修饰，不是静态方法，
     * 此时synchronized的锁对象，是当前类的实例，也就是new出来的那个对象
     *
     * @return
     */
    public synchronized String testSync1() {
        ticket -= ticket;
        return "";
    }


    /**
     * 同样是同步方法
     * 方法有static修饰，是静态方法
     * 此时synchronized的锁对象，是当前类对象，即SpringAIApplication.class
     *
     * @return
     */
    public static synchronized String testSync2() {
        ticket -= ticket;
        return "";
    }

同步代码块（以（）括号里指定的那个对象为锁对象）：

 //此时锁对象是SpringAIApplication.class，
        // 也可以指定一个对象
        //也可以是this，当前对象
        synchronized (lock) {
            while (true) {
                ticket--;
                if (ticket < 0) {
                    System.exit(0);
                }
            }
        }

二、synchronized的优化：

在JDK1.5前推出ReentrantLock，lock的性能远高于synchronized，所以在JDK1.6后，对synchronized进行了大量优化，主要优化包含以下三个方面：

1、锁消除：是指在加锁的代码块或方法中，并没有操作临界资源，锁消除机制不会执行加锁操作，因为加不加锁，意义都不大，没影响，因此不需要加锁；比如：

//临界资源一般是指会产生线程安全的变量
public void test1() {
        synchronized (this) {
            System.out.println("===没有操作临界资源===");
        }
    }

2、锁膨胀（或者叫锁扩张）：当在for循环中使用synchronized进行加锁和释放锁的操作，会进行多次的加锁和释放锁，与在for循环外加锁相比，可以减少锁资源增加和释放的次数，从而提升性能：

//会执行多次加锁和释放锁资源
for (int i = 0; i < 1000; i++) {
            System.out.println("==开始加锁==" + i);
            synchronized (lock) {
                ticket--;
                System.out.println("=====执行业务代码====");
            }
            System.out.println("==释放锁资源==" + i);
        }

//只会执行一次加锁和释放锁资源
        synchronized (lock) {
            for (int i = 0; i < 1000; i++) {
                ticket--;
                System.out.println("=====执行业务代码====");
            }
        }

3、锁升级：

无锁：当加锁的代码逻辑并没有去操作临界资源时，会触发锁消除

偏向锁：当每次都是同一个对象来获取锁时，没有发生锁资源竞争，当再次获取锁资源时，如果发生锁竞争，会优先偏向之前每次都获取的那个对象；

轻量级锁：当发生锁竞争时，不挂起线程，而是采用自旋的模式进行锁资源竞争，自旋就是尝试重新获取；

重量级锁：当自旋还是获取不到锁资源，则采用传统的synchronized模式，即挂起线程等待