多线程安全问题之锁策略,程序员一定要掌握的东西

多线程安全问题之锁策略,程序员一定要掌握的东西


前言

本节目标

围绕锁策略解决线程安全

一、常见的锁策略

1.1 乐观锁

乐观锁:乐观锁假设认为数据一般情况下不会产生并发冲突,所以在数据进行提交更新的时候,才会正 式对数据是否产生并发冲突进行检测,如果发现并发冲突了,则让返回用户错误的import java.util.concurrent.atomic.AtomicInteger; public class happylock { private static AtomicInteger count = new AtomicInteger(0); private static final int MAXSIZE = 100000; public static void main(String[] args) throws InterruptedException { Thread t1 = new Thread(new Runnable() { @Override public void run() { for(int i = 0;i<MAXSIZE;i++){ count.getAndIncrement(); } } }); t1.start(); t1.join(); Thread t2= new Thread(new Runnable() { @Override public void run() { for(int j = 0;j<MAXSIZE;j++){ count.getAndDecrement(); } } }); t2.start(); t2.join(); System.out.println("结果"+count); } //结果是0,如果不加AtomicInteger,那么线程执行完以后不会是0,存在线程不安全! }

1.2 悲观锁

悲观锁:他认为通常情况下会出现并发冲突,所以它在一开始就加锁;
import java.util.concurrent.locks.ReadWriteLock; import java.util.concurrent.locks.ReentrantLock; import java.util.concurrent.locks.ReentrantReadWriteLock; public class Readerlock { //读写锁的具体实现 public static void main(String[] args) { //创建读写锁 ReentrantReadWriteLock reentrantReadWriteLock = new ReentrantReadWriteLock(); //分离读锁 ReentrantReadWriteLock.ReadLock readLock= ReadWriteLock.ReadLock(); //分离写锁 ReentrantReadWriteLock.WriteLock readLock= ReadWriteLock.WriteLock(); } }

1.4 公平锁与非公平锁

公平锁:锁的获取顺序必须合线程方法的先后顺序是保存一致的,就叫公平锁 优点:执行时顺序的,所以结果是可以预期的
非公平锁:锁的获取方式循序和线程获取锁的顺序无关。优点:性能比较高

1.5 自旋锁(Spin Lock)

按之间的方式处理下,线程在抢锁失败后进入阻塞状态,放弃 CPU,需要过很久才能再次被调度。但经过测算,实际的生活中,大部分情况下,虽然当前抢锁失败,但过不了很久,锁就会被释放。基于这个 事实,自旋锁诞生了。
你可以简单的认为自旋锁就是下面的代码

只要没抢到锁,就死等。

自旋锁的缺点:
缺点其实非常明显,就是如果之前的假设(锁很快会被释放)没有满足,则线程其实是光在消耗 CPU 资源,长期在做无用功的。

1.6 可重入锁

可重入锁的字面意思是“可以重新进入的锁”,即允许同一个线程多次获取同一把锁。比如一个递归函数 里有加锁操作,递归过程中这个锁会阻塞自己吗?如果不会,那么这个锁就是可重入锁(因为这个原因 可重入锁也叫做递归锁)。
Java里只要以Reentrant开头命名的锁都是可重入锁,而且JDK提供的所有现成的Lock实现类,包括
synchronized关键字锁都是可重入的。

1.5 相关题目

面试题:

1.你是怎么理解乐观锁和悲观锁的,具体怎么实现呢?

乐观锁——> CAS ——> Atomic.(CAS是由v(内存值) A(预期值)B(新值))组成,然后执行的时候是使用V=A对比,如果结果为true,这表明没有并发冲突,则可以直接进行修改,否则返回错误信息*

2.有了解什么读写锁么?

多线程之间,数据的读取方之间不会产生线程安全问题,但数据的写入方互相之间以及和读者之间都需 要进行互斥。如果两种场景下都用同一个锁,就会产生极大的性能损耗。所以读写锁因此而产生。
读写锁(readers-writer lock),看英文可以顾名思义,在执行加锁操作时需要额外表明读写意图,复数读者之间并不互斥,而写者则要求与任何人互斥。
把锁分成两个锁,一个是读锁,一个是写锁,其中读锁可以多个线程拥有,而写锁是一个线程拥有

3.什么是自旋锁,为什么要使用自旋锁策略呢,缺点是什么?

按之间的方式处理下,线程在抢锁失败后进入阻塞状态,放弃 CPU,需要过很久才能再次被调度。但经过测算,实际的生活中,大部分情况下,虽然当前抢锁失败,但过不了很久,锁就会被释放。基于这个 事实,自旋锁诞生了。
你可以简单的认为自旋锁就是下面的代码
只要没抢到锁,就死等。
自旋锁的缺点:
缺点其实非常明显,就是如果之前的假设(锁很快会被释放)没有满足,则线程其实是光在消耗 CPU 资源,长期在做无用功的。

4.synchronized 是可重入锁么?
synchronized 是可重入锁,
代码如下:

public class Chonglock {     private  static   Object lock = new Object();      public static void main(String[] args) {         //第一次进入锁         synchronized (lock){             System.out.println("第一次进入锁");             synchronized (lock){                 System.out.println("第二次进入锁");             }         }     } }  

二、CAS问题

2.1 什么是CAS问题

CAS: 全称Compare and swap,字面意思:”比较并交换“,一个 CAS 涉及到以下操作:
我们假设内存中的原数据V,旧的预期值A,需要修改的新值B。 1. 比较 A 与 V 是否相等。(比较) 2. 如果比较相等,将 B 写入 V。(交换) 3. 返回操作是否成功。
当多个线程同时对某个资源进行CAS操作,只能有一个线程操作成功,但是并不会阻塞其他线程,其他线程只会收到操作失败的信号。可见 CAS 其实是一个乐观锁。

2.2 CAS 是怎么实现的

针对不同的操作系统,JVM 用到了不同的 CAS 实现原理,简单来讲:
java 的 CAS 利用的的是 unsafe 这个类提供的 CAS 操作;
unsafe 的 CAS 依 赖 了 的 是 jvm 针 对 不 同 的 操 作 系 统 实 现 的 Atomic::cmpxchg(一个原子性的指令)

/Atomic::cmpxchg 的实现使用了汇编的 CAS 操作,并使用 cpu 硬件提供的 lock 机制保证其原子性。
简而言之,是因为硬件予以了支持,软件层面才能做到。
多线程安全问题之锁策略,程序员一定要掌握的东西

2.3 CAS 有哪些应用

2.3.1 实现自旋锁

 public class SpinLock { private AtomicReference<Thread> sign =new AtomicReference<>();  public void lock(){ Thread current = Thread.currentThread();  // 不放弃 CPU,一直在这里旋转判断 while(!sign .compareAndSet(null, current)){ } }  public void unlock (){ Thread current = Thread.currentThread(); sign.compareAndSet(current, null); } } 

用于实现原子类

示例代码:

public class AtomicInteger { public final int incrementAndGet() { return unsafe.getAndAddInt(this, valueOffset, 1) + 1; } }  public class Unsafe { public final int getAndAddInt(Object var1, long var2, int var4) { int var5; do { var5 = this.getIntVolatile(var1, var2); } while(!this.compareAndSwapInt(var1, var2, var5, var5 + var4));  return var5; } } 

三. ABA问题

3.1 什么是ABA问题

 ABA 的问题,就是一个值从A变成了B又变成了A,而这个期间我们不清楚这个过程。 

3.2 实现ABA问题场景

我来举一个例子,如果你向别人转钱,你需要转100元,但是你点击了两次转钱,第一次会成功,但是第二次肯定会失败,但是,在你点击第二次转钱的同一时刻,你的公司给你转了100元工资,那么你就会莫名其妙的把100又转了出去,你丢失了100,别人也没有获得100.
代码演示:
1.正常转钱流程

import java.util.concurrent.atomic.AtomicReference;  public class Aba {     //ABA问题的演示      private  static AtomicReference money = new AtomicReference(100);//转账       public static void main(String[] args) {         //转账线程1         Thread t1 = new Thread(new Runnable() {             @Override             public void run() {                boolean result =  money.compareAndSet(100,0);                 System.out.println("点击第一次转出100"+result);             }         });         t1.start();         //转账线程2         Thread t2 = new Thread(new Runnable() {             @Override             public void run() {                boolean result =  money.compareAndSet(100,0);                 System.out.println("点击第二次转出100"+result);                 if(!result){                     System.out.println("余额不足,无法转账!");                 }             }         });         t2.start();       } }  

多线程安全问题之锁策略,程序员一定要掌握的东西
2.错误操作后:

import java.util.concurrent.atomic.AtomicReference;  public class ABas {      private  static AtomicReference money = new AtomicReference(100);//转账       public static void main(String[] args) throws InterruptedException {         //转账出线程1         Thread t1 = new Thread(new Runnable() {             @Override             public void run() {                 boolean result =  money.compareAndSet(100,0);                 System.out.println("第一次"+result);             }         });         t1.start();         t1.join();         //转入100         Thread t3 = new Thread(new Runnable() {             @Override             public void run() {                 boolean result =  money.compareAndSet(0,100);                 System.out.println("转账"+result);             }         });         t3.start();         //转账线程2         t3.join();         Thread t2 = new Thread(new Runnable() {             @Override             public void run() {                 boolean result =  money.compareAndSet(100,0);                 System.out.println("第二次"+result);             }         });         t2.start();       } }  
多线程安全问题之锁策略,程序员一定要掌握的东西

解决ABA方法

解决方法:加入版本信息,例如携带 AtomicStampedReference 之类的时间戳作为版本信息,保证不会 出现老的值。 

代码实现:

import java.util.concurrent.atomic.AtomicReference; import java.util.concurrent.atomic.AtomicStampedReference;  public class Abaack {      //private  static AtomicReference money = new AtomicReference(100);//转账 private  static AtomicStampedReference money = new AtomicStampedReference(100,1);   //     public static void main(String[] args) throws InterruptedException {         //转账出线程1         Thread t1 = new Thread(new Runnable() {             @Override             public void run() {                 boolean result =  money.compareAndSet(100,0,1,2);                 System.out.println("第一次转账100:"+result);             }         });         t1.start();         t1.join();         //转入100         Thread t3 = new Thread(new Runnable() {             @Override             public void run() {                 boolean result =  money.compareAndSet(0,100,2,3);                 System.out.println("其他人给你转账了100:"+result);             }         });         t3.start();         //转账线程2         t3.join();         Thread t2 = new Thread(new Runnable() {             @Override             public void run() {                 boolean result =  money.compareAndSet(100,0,1,2);                 System.out.println("第二次点击转账100:"+result);             }         });         t2.start();  //Integer的高速缓存是-128--127(AtomicStampedReference)         //如果大于127,那么就开始new对象了         /*         * 解决方法,调整边界值*/     }   }   
多线程安全问题之锁策略,程序员一定要掌握的东西

总结

以上就是今天要讲的内容,本文仅仅简单介绍了锁策略,解决线程安全。

版权声明:玥玥 发表于 2021-05-31 23:12:24。
转载请注明:多线程安全问题之锁策略,程序员一定要掌握的东西 | 女黑客导航