一、乐观锁和悲观锁
乐观锁:在加锁之前,预估锁冲突的概率比较小,因此加锁的时候就不会为此做太多的准备,加锁做的事情比较少,因此加锁的速度也就可能更快。
悲观锁:在加锁之前,预估锁冲突的概率比较大,因此加锁的时候就会做大量的准备,加锁做的事情比较多,因此加锁的速度也就可能更慢。
二、轻量级锁和重量级锁
轻量级锁:运行代码之后,锁冲突的概率比较小,因此加锁的开销比较小,速度也比较快。
重量级锁:运行代码之后,锁冲突的概率比较大,因此加锁的开销比较大,速度也比较慢。
注意:这里和乐观、悲观锁不同的是,乐观、悲观锁是加锁之前进行的预估,而这里指的是加锁之后对结果的评价。
三、自旋锁和挂起等待锁
自旋锁:是轻量级锁的一种典型实现,加锁的时候,如果加锁失败,不会就此退出锁竞争,而是会循环不停的进行锁竞争,这次锁竞争失败了就再次进入循环竞争锁,直到加锁成功,才退出循环。
这种反复快速的执行,就称为 “自旋”,同时,自旋锁也是乐观锁,只要其他线程释放了锁,它就能第一时间加锁成功,这样它的加锁速度也很快,但如果有很多线程要加锁,也没必要使用自旋锁了,会白白浪费cpu资源。
等待挂起锁:是重量级锁的一种典型体现,也是悲观锁,加锁的时候,如果加锁失败,就会等待一段时间,这段时间它不会去进行加锁,和别的线程锁竞争,这时候就能把一些cpu资源让出来了,用这些cpu资源可以干一些其他事情,等一段时间过后,会再次尝试加锁,如果失败还是重复以上工作,成功就拿到锁了,没啥好说的。
当等待挂起的时候,会有内核调度器介入,这一块要完成的操作就多了,从而要获取锁的时间花费也更多一些。
四、普通互斥锁和读写锁
普通互斥锁:类似synchronized这种,操作涉及到加锁、解锁
读写锁:这里加锁的情况分为两种:加读锁,加写锁
读锁和读锁之间,不会涉及到锁冲突(不会阻塞)
写锁和写锁之间,会涉及到锁冲突(会阻塞)
读锁和写锁之间,会涉及到锁冲突(会阻塞)
当一个线程加读锁时,另一个线程只能读,不能写
当一个线程加写锁时,另一个线程不能写,也不能读
为啥要引入读写锁?
如果两个线程只读,这个操作本身就是安全的,不需要进行加锁。但是如果使用synchronized来加锁,读和读之间会涉及到锁竞争(阻塞),但我们也不能完全不给读操作加锁,就怕一个线程读,一个线程写,这时候肯定就有线程安全问题。
读写锁,就能很好的解决上述问题。
如果只有读的操作,读操作中不会有修改操作,这时候每个线程读的数据都是同一个不变的数据,如果加锁了,就会耗费一些没必要消耗的资源空间,不如加个读锁,读的时候不会锁竞争,写的时候才会,这样就能省去很多不必要的资源开销了(锁冲突的开销)
五、公平锁和非公平锁
公平锁:如果线程和线程之间,锁竞争的时间大小不一样,按照锁竞争时间久的线程先拿到锁,有先后顺序(先来后到的意思)
非公平锁:线程和线程之间没有拿锁顺序,随机调度,各凭各的本事拿锁。
这里使用公平锁,就能很好的解决线程饿死的这一问题。而要想实现公平锁,就需要引入额外的数据结构(引入队列,记录每个线程的先后顺序),才能实现公平锁。
六、可重入锁和不可重入锁
可重入锁:如synchronized,加锁一段代码,锁里面可以再进行一次加锁,锁里面可以嵌套多个锁,里面是用计数器这种方式对加锁技术,并判断是否解锁,是可重入锁。
不可重入锁:系统自带的锁,不能连续加锁两次。
七、synchronized和Linux的mutex锁的简单比较
synchronized:乐观锁 / 悲观锁自适应
轻量级锁 / 重量级锁自适应
自旋锁 / 挂起等待所自适应
不是读写锁
非公平锁
可重入锁
mutex: 悲观锁
重量级锁
挂起等待所
不是读写锁
非公平锁
不可重入锁
八、synchronized的自适应
synchronized内部优化的很好,有自适应性,通常都可以无脑用,而且效率也不会低。
1、锁升级
(1)偏向锁阶段
核心思想:“懒汉模式”,就是能不加锁,就不加锁,能晚加锁就晚加锁;所谓的偏向锁,并不是真的加锁了,只是做了个非常轻量的标记。
一旦有线程来竞争这个锁,持有偏向锁的线程能第一时间拿到这个锁,如果没有其他线程竞争锁,下次还是拿到锁的线程大概率还是持有偏向锁的线程。总的来说,当有锁竞争的情况下,偏向锁没有提高效率,在没有锁竞争的情况下,偏向锁就能大幅度的提高效率了。
这个标记是锁里面的一个属性,每个锁都有自己的标记,当锁对象首次加锁是,没有涉及到锁竞争,这个阶段就是偏向锁阶段,一旦涉及到锁竞争,就会升级成轻量级锁阶段。
(2)轻量级锁阶段
此处的轻量级锁就是通过自旋的方式实现的,假设有锁竞争,但不多,就会处于轻量级锁阶段,它的优势:当其他线程释放锁了,处于轻量级锁阶段的线程能第一时间拿到锁;劣势:比较消耗cpu资源,因为是自旋的方式实现的,会有个循环一直尝试拿锁。
当线程多了,轻量级锁就不合适了,每个线程都循环尝试拿锁,但如果已经有线程拿到锁了,其他线程要阻塞等待,但等待的这过程是会有循环不断的尝试拿锁,这里消耗的cpu资源就很多了。这时,就会从轻量级锁阶段升级成重量级锁阶段。
(3)重量级锁阶段
此处的轻量级锁是用挂起等待的方式实现的,当有很多线程同时去竞争这个锁时,有个线程拿到锁了,其他线程没拿到,就不会再不断的重复尝试去拿锁,而是阻塞等待,等待一段时间再去尝试拿锁,不成功再阻塞等待一段时间,循环以上步骤,这题就会让出cpu的资源,可以利用这些cpu资源干一些其他的事。
注意:此处只能升级,不能降级,但是只是当前版本是这样的,以后的版本也说不好会添加降级的功能。
2、锁消除
也是synchronized的内部优化;有时候,有些代码可以一眼看上去就不用加锁,但是代码加锁了,这时候,编译器就会把这个锁给干掉,毕竟加锁操作也是要消耗一些硬件资源的。
注意:锁消除和偏向锁的区别
锁消除:针对能够一眼就看出不涉及到线程安全问题的代码,编译器能够把锁给消除掉。
偏向锁:是已经运行代码了,才知道没有锁竞争。
3、锁粗化
通常情况下,我们更偏好于让锁更细一些,这样更有利于并发编程的时候解决线程安全问题,但有时候,让锁更粗写能提高效率,会希望锁粗点。
锁粗化:把多个细粒度的锁合并成一个粗粒度的锁。
如图:
一段代码中,频繁的加锁解锁,肯定会消耗更多的硬件资源,但是如果能把一段代码这些加锁解锁操作,优化成只有一次加锁、解锁,这样也能提高效率。而锁粗化目的也是提高效率。