synchronized锁解析

简介

线程的合理使用可以怎加cpu的利用率，达到增大系统吞吐量的效果。但是使用多线程的过程中会引发线程安全的问题。这篇文章我会尽量简介的阐述synchronized的使用及原理。

线程不安全示例

package synchronized02;

/**
 * 线程不安全示例
 */
public class UnSecurityDemo {
    public static int count;

    public static void incr(){
        count++;
    }

    public static void main(String[] args) throws InterruptedException {
        // 启动1000个线程执行++操作,查看结果是否符合1000预期
        for (int i = 0; i < 1000; i++) {
            Thread thread = new Thread(()->incr());
            thread.start();
            // 阻塞main线程
            thread.join();
        }
        System.out.println(count);
    }

}

返回结果：815

如果是线程安全的情况那么1000次自增的结果肯定是1000，那么究竟是为什么导致结果不为1000呢，接下来我们继续解析:

我们假设有两个线程thread1，thread2来执行i++操作了。如果thread2拿到的i不是thread1加加之后的i，那么此处的结果肯定不是我么预期中的2。
当然这边也涉及到了cpu相关的知识。有兴趣的小伙伴可以了解下cpu相关的知识，理解会更加深刻。
那么我们怎么去解决线程安全的问题呢？按照小伙伴们已有的知识，我们可以想到锁吧，那么 接下来我们就介绍下java提供的synchronized关键字。

synchronized使用

由上面的例子我们可以发现问题的关键在于共享变量的并发修改是有问题的。那么我们只需要保证这个共享变量的修改过程是互斥的就可以了，就是当有一个线程在操作这个变量的时候，其他线程是不可以操作这个共享变量的。我们接下来介绍下synchronized的用法。
synchronized的基本语法:

1.修饰方法
   a. 修饰实例方法,对当前对象加锁。未获得对象所得线程阻塞
   b. 修饰静态方法，对class类对象加锁。
2.修饰代码块
不同的修饰类型代表不同的锁控制粒度。

接下来我们改造下上面的例子

package synchronized02;

/**
 * 线程不安全示例
 */
public class SecurityDemo {
    public static int count;

	// 修饰方法
    public synchronized static void incr(){
        count++;
    }
	
	// 修饰代码块
	public static void incrBlock(){
		//====
		// doOther()
		//====
		synchronized(SecurityDemo.class){
			// 保护存在安全问题的非原子操作
			count++;
		}
		//====
		// doOther()
		//====
	}

    public static void main(String[] args) throws InterruptedException {
        // 启动1000个线程执行++操作,查看结果是否符合1000预期
        for (int i = 0; i < 1000; i++) {
            Thread thread = new Thread(()->incr());
            thread.start();
            // 阻塞main线程
            thread.join();
        }
        System.out.println(count);
    }
}

运行后发现，结果为1000.

synchronized锁升级

任何锁都具备数据的存储和互斥的特性，synchronized锁的状态在内存中是存储在对象的。

锁存储示意图

锁升级过程

在1.6之前synchronized的实现都是基于重量级锁来实现的，之后提供了锁升级的方式，引入了偏向锁和轻量级锁的概念，根据竞争的激烈性调整锁的级别，减少获得锁和释放锁带来的开销，提升程序的性能。

偏向锁

当前有两个线程线程1和线程2，线程1首先访问代码块。使用自旋设置锁标记成功，将偏向锁的锁标记指向自己，对象偏向锁标记置为1。如果后面线程2也访问同步块，假如此时线程1同步块执行完毕后解锁了，线程2也可以获取偏量锁继续执行。如果线程1还没有解锁，会暂停线程1&&2，切换轻量锁机制来运行。
由此可见偏向锁适用的场景: 大多数情况只有一个线程的情况, 不存在竞争。

轻量级锁

自旋会占用cpu资源，所以在指定的自旋次数之后，如果还没有获得轻量级锁，锁会膨胀成重量级锁。
自旋次数设置：
1.设置自旋次数 preBlockSpin
2.自适应自旋：如果一个线程进场自旋成功，那么虚拟机会适当的吧等待时间延长
当绝大多数线程在获得锁之后，很短时间内会释放锁的场景是轻量锁的使用场景。

重量级锁

升级到重量级所之后，没有获得锁的线程会被阻塞。