高并发多线程安全之原子性问题、CAS机制及问题解决方案

最新推荐文章于 2024-07-26 12:28:02 发布

踩踩踩从踩

最新推荐文章于 2024-07-26 12:28:02 发布

阅读量1.1k

点赞数 2

分类专栏： java高并发多线程文章标签： java 线程安全多线程

本文链接：https://blog.csdn.net/qq_33373609/article/details/120301965

版权

java高并发多线程专栏收录该内容

16 篇文章 1 订阅

订阅专栏

多线程编程之java内存模型(JMM)与可见性问题

前言

在java内存模型中，对多线程间交互，涉及到原子性问题、可见性问题、以及有序性问题；

这篇文章主要讲解的是多线程高并发的原子性问题，以及解决原子性问题、CAS机制、自旋锁的优缺点、以及ABA问题等解决

什么是原子操作

定义

即一个操作或者多个操作，要么全部执行并且执行的过程不会被任何因素打断，要么就都不执行。

通过下面代码来看出来

public class Counter {
    volatile int i = 0;

    public void add() {
        i = i + +;
    }
}

public class Demo1_CounterTest {

	public static void main(String[] args) throws InterruptedException {
		final Counter ct = new Counter();
		CountDownLatch cl = new CountDownLatch(6);
		for (int i = 0; i < 6; i++) {
			new Thread(new Runnable() {
				@Override
				public void run() {
					for (int j = 0; j < 10000; j++) {
						ct.add();
					}
					cl.countDown();
					System.out.println("done...");
				}
			}).start();
		}
		cl.await();
		System.out.println(ct.i);
	}
}

上面得到的结果完全不可控，得到了下面的打印结果；明显产生了冲突，在预想的时候应该产生60000，但只得到了34684；多执行一次结果值又不一样

done...
done...
done...
done...
done...
done...
34684

产生情况的原因，为什么会出现值减少的情况

i++不是原子操作，这在多线程操作时会出现非原子性行为

这是在每个线程中的私有方法内存中进行操作，就可能导致冲突，出现非原子性行为；但不是可见性问题，因此我们写入内存时，其他线程一定能看到，通过 volatile 已经发生happens-before原则

原子操作可以是一个步骤，也可以是多个操作步骤，但是其顺序不可以被打乱，也 不可以被切割 而只执行其中的一部分(不可中断性)。

将整个操作视作一个整体， 资源在该次操作中保持一致 ，这是原子性的核心特征

结论：

i++不是原子操作，存在竞态条件，线程不安全，需要转变为原子操作才能安全。要保证数据安全

public synchronized void add() {
		i = i + 1;
	}

竞态条件与临界区

竞态条件：两个线程竞争同一个资源时，如果对资源的访问顺序敏感，就称存在竞态条件。

临界区：就是导致静态条件发生的代码区。比如上图的 i++;代码

CAS(Compare and swap) 机制

public class CounterAtomic {
    AtomicInteger at = new AtomicInteger(0);

    public void add(){
        at.getAndIncrement();
    }

    public int getValue(){
        return at.get();
    }
}

这里用到的AtomicInteger 就是利用的cas机制来达到原子性的

CAS 属于硬件同步原语，处理器提供的内存操作指令， 保证原子性 。
CAS操作需要两个参数，一个旧值和目标值，修改前比较旧值是否改变，如果没变，将新值赋给变量，否则则不做改变。

如下图，去对比值，如果没变就赋值为111

如果两个线程同时进行操作，对于内存来说，其实还是分为两次操作，它保证同一时刻只能有一个进行修改

修改值之前进行检查，如果值是正常，就修改成功，修改失败就在更新老值进行重试。

CAS 属于硬件同步原语，处理器提供的内存操作指令，而jvm虚拟机提供给一个可以使用的类unsafe;

JAVA中的sun.misc.Unsafe类提供了CAS机制。

例如AtomicInteger中使用到的

 // setup to use Unsafe.compareAndSwapInt for updates
    private static final Unsafe unsafe = Unsafe.getUnsafe();
    private static final long valueOffset;

    static {
        try {
            valueOffset = unsafe.objectFieldOffset
                (AtomicInteger.class.getDeclaredField("value"));
        } catch (Exception ex) { throw new Error(ex); }
    }

    private volatile int value;

这个可以在自己仿造着AtomicInteger 写一个unsafe的原子操作类

	static {
		unsafe = Unsafe.getUnsafe();
		try {
			valueOffset = unsafe.objectFieldOffset(CountUnsafe.class.getDeclaredField("value"));
		} catch (Exception ex) {
			throw new Error(ex);
		}
	}

在写到上面代码时，出现了安全异常，而automicInteger中则没有异常，jdk不允许我们拿。然后就使用反射去解决

Exception in thread "main" java.lang.ExceptionInInitializerError
Caused by: java.lang.SecurityException: Unsafe
	at sun.misc.Unsafe.getUnsafe(Unsafe.java:90)
	at org.cao.learn.CountUnsafe.<clinit>(CountUnsafe.java:12)

按照automicinteger可以写一个，先定义属性

private static final Unsafe unsafe;
	private static final long valueOffset;

	private volatile int value = 0;

定义好静态方法块

static {
//		unsafe = Unsafe.getUnsafe();

		try {
			Field field = Unsafe.class.getDeclaredField("theUnsafe");
			field.setAccessible(true);
			unsafe = (Unsafe) field.get(null);
			valueOffset = unsafe.objectFieldOffset(CountUnsafe.class.getDeclaredField("value"));
		} catch (Exception ex) {
			throw new Error(ex);
		}
	}

然后总的代码

package org.cao.learn;

import java.lang.reflect.Field;

import sun.misc.Unsafe;

public class CountUnsafe {
	private static final Unsafe unsafe;
	private static final long valueOffset;

	private volatile int value = 0;

	static {
//		unsafe = Unsafe.getUnsafe();

		try {
			Field field = Unsafe.class.getDeclaredField("theUnsafe");
			field.setAccessible(true);
			unsafe = (Unsafe) field.get(null);
			valueOffset = unsafe.objectFieldOffset(CountUnsafe.class.getDeclaredField("value"));
		} catch (Exception ex) {
			throw new Error(ex);
		}
	}

	public final int getAndIncrement() {
		return unsafe.getAndAddInt(this, valueOffset, 1);
	}

	public void add() {
		// i++; 
		for (;;) {
			if (unsafe.compareAndSwapInt(this, valueOffset, value, value + 1)) {
				return;
			}
		}
	}

	public int getValue() {
		return value;
	}

}

这里的getAndIncrement方法和add方法是一样的，最好是使用getAndAddInt 方法这是native方法做了内循环，并做了优化的.

J.U.C包内的原子操作封装类

AtomicBoolean：原子更新布尔类型
AtomicInteger：原子更新整型
AtomicLong ：原子更新长整型
AtomicIntegerArray ：原子更新整型数组里的元素。

  public AtomicIntegerArray(int[] array) {
        // Visibility guaranteed by final field guarantees
        this.array = array.clone();
    }

底层存的int类型，需要对其中一个元素做原子性操作

    public final int getAndSet(int i, int newValue) {
        return unsafe.getAndSetInt(array, checkedByteOffset(i), newValue);
    }

AtomicLongArray ：原子更新长整型数组里的元素。
AtomicReferenceArray：原子更新引用类型数组里的元素。

AtomicIntegerFieldUpdater：原子更新整型的字段的更新器。

这里做的引用就是修改对象的某个值，是它为原子操作。

ublic class Demo2_AtomicIntegerFieldUpdater {
    // 新建AtomicIntegerFieldUpdater对象，需要指明是哪个类中的哪个字段


    private static AtomicIntegerFieldUpdater<User> atom =
            AtomicIntegerFieldUpdater.newUpdater(User.class, "id");

    public static void main(String[] args) {

        User user = new User(100, 100,"Kody");

        atom.addAndGet(user, 50);
        System.out.println("addAndGet(user, 50)             调用后值变为：" + user);

    }
}

class User {
    volatile int id;
    volatile int age;

    private String name;

    public User(int id, int age, String name) {
        this.id = id;
        this.age = age;
        this.name = name;
    }

    public String toString() {
        return "id：" + id + " " + "age：" + age;
    }
}

AtomicLongFieldUpdater：原子更新长整型字段的更新器。
AtomicReferenceFieldUpdater：原子更新引用类型里的字段

AtomicReference：原子更新引用类型。

这里也是对比对象应用，包括下面的锁机制的一部分抢锁时，对比的是锁引用是否相等。

 public boolean tryLock() {
        //如果锁没有占用     存在原子性问题
    
        return owner.compareAndSet(null, Thread.currentThread());
    }

AtomicStampedReference：原子更新带有版本号的引用类型
AtomicMarkableReference：原子更新带有标记位的引用类型。

1.8更新

计数器： DoubleAdder 、 LongAdder

计数器增强版，高并发下性能更好，多个道路进行累加，然后进行相加

public long testLongAdder() throws InterruptedException {
        LongAdder lacount = new LongAdder();
        for (int i = 0; i < 3; i++) {
            new Thread(() -> {
                long starttime = System.currentTimeMillis();
                while (System.currentTimeMillis() - starttime < 2000) { // 运行两秒
                    lacount.increment();
                }
                long endtime = System.currentTimeMillis();
            }).start();
        }
        Thread.sleep(3000);
        return lacount.sum();
    }

DoubleAccumulator、 LongAccumulator

是计数器的增强版，可自定义累加规则可以指定逻辑规则，做一个增强版操作。自定义规则，x和y值其中0为x ,y为每次规则过后结果

public class Demo3_LongAccumulator {
    public static void main(String[] args) throws InterruptedException {

        LongAccumulator accumulator = new LongAccumulator(
                (x,y)->{
                    System.out.println("x:" + x);
                    System.out.println("y:" + y);
                    return  x+y;
                },
                0L);

        for (int i = 0; i < 3; i++) {
            accumulator.accumulate(1);
        }

        System.out.println(accumulator.get());

    }
}

CAS存在的问题

仅针对单个变量的操作，不能用于多个变量来实现原子操作
循环+CAS,自旋的实现让所有线程都处于高频运行，争抢CPU执行时间的状态。如果操作长时间不成功，会消耗大量的cpu资源。

ABA问题，无法体现出数据的变动。

主要是多线程操作时，其中一个线程操作过后，得到的新值

上述的方式，在automicinteger里面不出问题，在AtomicReference中可能出现问题，也是链表结构的情况

public class Stack {
    // top cas无锁修改
    AtomicReference<Node> top = new AtomicReference<Node>();

    public void push(Node node) { // 入栈
        Node oldTop;
        do {
            oldTop = top.get();
            node.next = oldTop;
        }
        while (!top.compareAndSet(oldTop, node)); // CAS 替换栈顶
    }


    // 出栈
    public Node pop(int time) {

        Node newTop;
        Node oldTop;
        do {
            oldTop = top.get();
            if (oldTop == null) {   //如果没有值，就返回null
                return null;
            }
            newTop = oldTop.next;
            if (time != 0) {    
                LockSupport.parkNanos(1000 * 1000 * time); 
            }
        }
        while (!top.compareAndSet(oldTop, newTop));     //将下一个节点设置为top
        return oldTop;      //将旧的Top作为值返回
    }
}

测试方法

 public static void main(String[] args) throws InterruptedException {
        Stack stack = new Stack();
        //ConcurrentStack stack = new ConcurrentStack();

        stack.push(new Node("B"));      
        stack.push(new Node("A"));      

        Thread thread1 = new Thread(() -> {
            Node node = stack.pop(800);
            System.out.println(Thread.currentThread().getName() +" "+ node.toString());

            System.out.println("done...");
        });
        thread1.start();

        Thread thread2 = new Thread(() -> {
            LockSupport.parkNanos(1000 * 1000 * 300L);

            Node nodeA = stack.pop(0);      
            System.out.println(Thread.currentThread().getName()  +" "+  nodeA.toString());

            Node nodeB = stack.pop(0);      //取出B，之后B处于游离状态
            System.out.println(Thread.currentThread().getName()  +" "+  nodeB.toString());

            stack.push(new Node("D"));      
            stack.push(new Node("C"));      
            stack.push(nodeA);                    

            System.out.println("done...");
        });
        thread2.start();

        LockSupport.parkNanos(1000 * 1000 * 1000 * 2L);


        System.out.println("开始遍历Stack：");
        Node node = null;
        while ((node = stack.pop(0))!=null){
            System.out.println(node.value);
        }
    }

线程1在拿到老的top值，和新的node值时过后，进行cas比较并赋值的情况等待状态了；然后线程2中间插入了很多数据，又插回了原来那个对象，因此出现了ABA问题。线程2put进去的数据都变不在了，其实里面属性已经变了

解决ABA问题的办法

主要是我们不能将top引用作为对比的对象，如果按照引用去对比，属性修改，数据肯定不正确了。

AtomicStampedReference<Node> top =
            new AtomicStampedReference<>(null, 0);

AtomicStampedReference添加了版本号，不只是对比引用，加入了版本号维护；

package org.cao.learn;

import java.util.concurrent.atomic.AtomicStampedReference;
import java.util.concurrent.locks.LockSupport;

// 实现一个 栈（后进先出）
public class Stack {
	// top cas无锁修改
	AtomicStampedReference<Node> top = new AtomicStampedReference<Node>(null, 0);
//	AtomicReference<Node> top = new AtomicReference<Node>();

	public void push(Node node) { // 入栈
		Node oldTop;
		int v = 0;
		do {
			v = top.getStamp();
			oldTop = top.getReference();
			node.next = oldTop;
		} while (!top.compareAndSet(oldTop, node, v, v + 1)); // CAS 替换栈顶
	}

	// 出栈 -- 取出栈顶 ,为了演示ABA效果， 增加一个CAS操作的延时
	public Node pop(int time) {

		Node newTop;
		Node oldTop;
		int v = 0;
		do {
			oldTop = top.getReference();
			v = top.getStamp();
			if (oldTop == null) { // 如果没有值，就返回null
				return null;
			}
			newTop = oldTop.next;
			if (time != 0) { // 模拟延时
				LockSupport.parkNanos(1000 * 1000 * time); 
			}
		} while (!top.compareAndSet(oldTop, newTop, v, v + 1)); 
		return oldTop; 
	}
}

踩踩踩从踩

关注

2
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
高并发多线程安全之原子性问题、CAS机制及问题解决方案

多线程编程之java内存模型(JMM)与可见性问题前言在java内存模型中，对多线程间交互，涉及到原子性问题、可见性问题、以及有序性问题；这篇文章主要讲解的是多线程高并发的原子性问题，以及解决原子性问题、CAS机制、自旋锁的优缺点、以及ABA问题等什么是原子操作定义即一个操作或者多个操作，要么全部执行并且执行的过程不会被任何因素打断，要么就都不执行。通过下面代码来看出来public class Counter { volatile int i = 0;
复制链接

扫一扫