Java并发(2)一些基本问题

置顶 away_lit

于 2018-03-26 00:54:21 发布

阅读量493

点赞数

分类专栏： Java

本文链接：https://blog.csdn.net/away_lit/article/details/79692738

版权

Java 专栏收录该内容

4 篇文章 0 订阅

订阅专栏

一些问题：synchronized原理，特点、volatile的作用、如何提升索性能、各种锁的适用场景、CAS描述 ,ABA问题的产生及解决方案、银行家算法的过程、缺点。

1.Java的线程安全

当对个线程访问同一个对象时，不管运行时环境采用何种方式调度或者这些线程如何交替执行，也不需要进行额外的同步或协同，这个类都能表现出正确的行为，那么就称这个类是线程安全的。

2线程安全三要素：

原子性：互斥访问。典型非原子性操作：i++，64位非volatile变量的读/写操作。

可见性：一个线程对内存的修改可以及时被其它线程看到。共享变量在线程间不可见的原因：(1)线程交叉执行；(2)线程交叉执行+指令重排序；(3)共享变量更新后没有来得及在工作内存与主内存之间更新。

有序性: 如果在本线程内观察，所有的操作都是有序(ordering)的；如果在一个线程中观察另一个线程，所有的操作都是无序(out of order)的。前半句指“线程内表现为串行的语义”，后半句指“指令重排序或者工作内存与共内存同步延迟现象”。有序性指在什么情况下一个处理器上运行的一个线程所执行的内存访问操作在另外一个处理器上运行的其他线程看来是乱序的(out of order),所谓乱序，是指内存访问操作的顺序看起来像是发生了变化。

3.synchronized关键字，隐式锁。

(a)使用：

1.修饰普通方法，锁的是当前对象this。synchronized并不属于方法定义的一部分，不能被继承。子类重写该方法时，如果在重写时不明确写上synchronized，那这个方法就不是synchronized。换句话说，虽然继承了，但是没把synchronized继承下来，也就意味着“synchronized不能被继承”。

2.修饰静态方法，锁的是代表该类的Class类型对象，这个Class对象是该类的所有实例共享的。

3.修饰代码块，锁的是括号里指定的对象。

(b)特点:

1.既可以保证原子性，又可以保证可见性。基于锁的获取与释放保证原子性。JVM对synchronized的两条规定可以一定程度实现可见性：(1)线程加锁时，将清空工作内存中共享变量的值，从而使用共享变量时需要从主内存中重新读取更新的值；(2).线程解锁时，必须把共享变量最新的值刷新到主内存。流程：先清空工作内存→在主内存中拷贝最新变量的副本到工作内存→执行完代码→将更改后的共享变量的值刷新到主内存中→释放互斥锁。

2.不响应中断。见ReenterLock。

3.未优化的synchronized是典型的重量级锁，当无法获取同步对象的锁时该线程直接被阻塞。

(c)synchronized实现原理：

1.对synchronized的优化的原因:

矛盾1. 重量级锁中的阻塞(挂起线程/恢复线程)需要转入内核态中完成，有很大的性能影响。但锁大多数情况都是在很短的时间执行完成并释放。方案：引用轻量级锁(通过自旋来完成锁竞争)。

矛盾2. 轻量级锁中的自旋耗费CPU资源，如果竞争激烈，大量的自旋将浪费太多CPU时间片。方案：JDK5中引入自旋次数限制(默认为10，可以通过设置-XX:PreBlockSpin进行修改)；JDK6中引入了自适应自旋（简单来说如果自旋成功概率高，就会允许等待更长的时间（如100次自旋），如果失败率很高，那很有可能就不做自旋，直接升级为重量级锁。

矛盾3. 无论是轻量级锁还是重量级锁，都需要通过CAS来设置对象头的Mark Word来表示加锁和释放锁。但大多数情况下，锁不仅很少存在多个线程竞争，而且大多数情况下总是由同一线程多次获得，这样有太多不需要的CAS操作。方案：引入偏向锁，首次需要通过CAS修改对象头中的Mark Word，之后该线程再进入只需要比较对象头中的Mark Word的Thread ID是否与当前的一致，如果一致说明已经取得锁，就不用再CAS了。

矛盾4. 项目中代码块中可能绝大情况下都是多线程访问。每次都是先偏向锁然后过渡到轻量锁，而偏向锁能用到的又很少。方案：可以使用-XX:-UseBiasedLocking=false禁用偏向锁。

2.synchronized实现原理:

当一个线程试图访问同步代码块时，它首先必须得到锁；退出同步代码块时或抛出异常时必须释放锁。JVM基于进入和退出Monitor(监视器)对象来实现方法同步和代码块同步，任何对象都有一个monitor与之关联，当且一个monitor被持有后，该对象将处于锁定状态。代码块同步使用monitoenter指令monitorexit指令实现，在同步代码块前插入monitoenter指令，在在同步代码块后插入monitorexit指令；线程执行到monitorenter指令时，将会尝试获取对象所对应的monitor的所有权，即尝试获得对象的锁，线程执行monitorexit指令时，会释放对象的锁。锁是对象头的一部分数据。Monitor(监视器)是一种同步机制。

锁的关系及升级情况：锁升级是单向的: 无锁 -> 偏向锁 -> 轻量级锁 -> 重量级锁

4.volatile的作用：

(1)保证可见性

volatile通过加入内存屏障和禁止指令重排序来实现可见性：

1.对volatile变量进行写操作时，会在写操作后加入一条store屏障指令，将工作内存中共享变量的值刷新到主内存；

2.对volatile变量进行读操作时，会在读操作前加入一条load屏障指令，从主内存中读取共享变量最新值到工作内存。

(2)volatile可以保证对long/double读写操作的原子性。

(3)禁止创建对象时的指令重排序。创建一个对象分为3步：1.为该对象分配内存空间，2.用构造函数初始化该对象，3.返回该对象的引用。若(2,3)发生指令重排序，那么可能得到一个没有初始化完全的对象。

5J.U.C

(a)Atomic包

通过CAS实现原子性。乐观锁实现。将内存值与预期值进行比较；若相等，则认为在本线程执行期间该值没有被其它线程修改过，进行更新操作；否则继续尝试。若竞争不激烈，则修改成功的概率很高；若竞争很激烈，则修改失败的概率很高。当修改失败时，会进行大量的循环尝试，性能受到影响。

原子更新基本类型：AtomicBoolean 、AtomicInteger 、AtomicLong。lazySet()方法可见减少不必要的内存屏障，提高效率。

ABA问题：在进行CAS操作时，其它线程将数据对象的值A改为B，然后又改回A，让本线程误以为值没有被修改过，于是进行交换操作，但该值实际上已经被其它线程修改过，与CAS设计思想不符。可以通过加版本号进行解决，每次变量值更新的时候，把变量的版本号加1，只要变量被修改过，变量的版本号就会发生递增变化。

解决方案:AtomicStampedReference，AtomicMarkableReference类。

(b)ReenterLock与synchronized的比较。

(1)ReenterLock可以更细粒度的保证原子性，synchronized除了保证原子性外还可以保证可见性。

(2)ReenterLock可以尝试获取锁立即返回或在指定时间内返回，未优化的synchronized默认直接阻塞线程。

(3)ReenterLock可以响应中断(lockInterruptibly)，可以在中断处理中释放已经占有的锁以避免死锁；synchronized不响应中断，要么获得锁运行，要么一直等待锁。

(4)ReenterLock可以选择公平/非公平的实现；synchronized是默认非公平的实现。

(5)ReenterLock与synchronized都是可重入锁。Java的锁都是可重入的。

6.提高锁性能的技巧:

(1). 减小锁持有时间。1.将不需要同步的语句移出同步代码块外；2.早用完早释放锁。

(2). 减小锁粒度(共享数据的保护范围)。典型如CurrentHashMap(分段加锁，提高并发度)，LongAdder(分单元格CAS,减小冲突域)，数据库表级锁与行级锁。

(3). 读写锁分离代替独占锁。通过读操作共享，写操作互斥，在读多写少的场合，使用读写锁可以有效提高系统并发能力。

(4). 锁分离。典型如LinkedBolckedQueue的写锁依据功能作用特点的再次分离。

(5). 锁粗化。为了减小锁持有时间而反复的请求锁是一种得不偿失的操作，因此虚拟机在遇到连续对同一个锁请求和释放的操作时，会把所有锁操作整合为一次请求。

public void demoMethod(){
   for(int i=0;i<10;i++){
      synchronized{
         //do sth
      }
   }
}
锁粗化：
public void demoMethod(){
   synchronized{
       for(int i=0;i<10;i++){
         //do sth
       }
    }
 }

(6)无锁。copyOnWrite机制、MVCC。

7.悲观锁与乐观锁，自旋锁与互斥锁，可重入锁与不可重入锁，公平与非公平锁。

(a)悲观与乐观是两种设计思想。

(b)悲观锁假定一定会发生冲突，因此对临界区进行显示同步操作，典型实现手段：隐式锁synchronized，显示锁ReenterLock；乐观锁假定不会发生冲突，只在更新时检测，典型实现手段：CAS。因此悲观的实现一般适用于竞争激烈的场景，乐观的实现一般适用于竞争不太激烈的场景。

(c)自旋锁与互斥锁都是要保证资源的互斥访问。对于自旋锁，资源被其它线程占有而无法获得时，会进行自旋(while循环)来尝试获取资源，竞争不太激烈时，自旋浪费的CPU小于阻塞+唤醒一个线程的开销。对于互斥锁，资源被占用时直接进入阻塞队列，当资源可用时才被唤醒。因此自旋锁一般适用于竞争激烈的场景，互斥锁一般适用于竞争不太激烈的场景。

(d)可重入锁允许一个线程同时获取某个锁多次，如果同一个线程多次获取锁，那么也必须释放相同的次数；Java的锁都是可重入锁。可重入意味着获取锁操作的粒度是“线程”而不是“调用”；重入的一种实现方法是为每个锁关联一个计数器和持有者线程ID。当计数值为0时，认为该锁没有被任何线程持有；当线程请求一个未被持有的锁时，JVM将记录下该线程ID并将计数器置为1，如果同一个线程再次获取这个锁，计数值将递增，退出同步快或release()时计数值递减；当计数值为0，这个锁被真正释放。

(e)公平锁与非公平锁。对于公平锁，锁的获取顺序与锁的请求顺序一致。当线程请求获取资源时，若有其它线程因该资源而等待，则直接把该线程加入到等待队列。公平锁保证了锁的获取顺序严格按照FIFO原则，而代价是大量的线程切换。对于非公平锁，当前线程首先会尝试竞争获取锁，如果获取失败才会进入等待队列。若一个线程连续多次成功获取一个锁，可以有效减少线程切换次数，非公平锁的缺点是可能导致线程饥饿。

8.银行家算法

安全状态：系统按照某种进程的执行顺序(P1,P2,...Pn)，为每个进程Pi一次性分配其目前所需的最大资源数(Need(Pi)=Max(Pi)-Allocated(Pi))，使每个进程都可以顺序的完成，当为Pi分配资源时，进程(P1,P2,...Pi-1)均已经结束且归还了系统资源。此时称P1,P2,...Pn是一个安全序列。如果系统无法找到一个安全序列，则称系统处于不安全状态。

思路：当一个进程请求系统资源时，Need(Pi)=Max(Pi)-Allocated(Pi)，Max(Pi)是进程Pi对资源的最大需求量，Allocated(Pi)是Pi已经分配到的资源量，Need(Pi)是进程Pi目前的最大需求量，Avaiable(j)代表目前系统资源j可用量；若当前申请量Requesti>Need(Pi)，则认为出错；若Request(i,j)>Avaiable(j)则延迟分配，否则试探分配Requesti，执行安全性检测算法，若此次资源分配后，系统处于安全状态，则本次分配完成，否则本次的试探分配作废，恢复原原来的资源分配状态，让进程Pi等待。

优缺点：可以有效避免死锁的产生；需要预先知道进程的最大需求量(这点不太好做)，每次试探分配资源时都需要进行一次安全性检测算法，效率较低；安全性检测算法相等于一次为该进程分配所需的所有资源(Max)，但一个进程一般只需要部分资源就可以运行，不利于并发，且对于这种安全性检测算法，不安全状态也不一定会导致死锁。

参:

java并发编程的艺术，实战java高并发程序设计，Java多线程编程实战指南。

https://blog.dreamtobe.cn/2015/11/13/java_synchronized/

http://brokendreams.iteye.com/blog/2250109

https://blog.csdn.net/guyuealian/article/details/52525724

away_lit

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java并发(2)一些基本问题

一些问题：synchronized原理，特点、volatile的作用、如何提升索性能、各种锁的适用场景、CAS描述 ,ABA问题的产生及解决方案、银行家算法的过程、缺点。1.Java的线程安全当对个线程访问同一个对象时，不管运行时环境采用何种方式调度或者这些线程如何交替执行，也不需要进行额外的同步或协同，这个类都能表现出正确的行为，那么就称这个类是线程安全的。2线程安全三要素：...
复制链接

扫一扫