Java 并发编程(CAS,JUC常用类)(3)

最新推荐文章于 2024-03-17 15:45:32 发布

面向c v编程

最新推荐文章于 2024-03-17 15:45:32 发布

阅读量512

点赞数

分类专栏：笔记 java并发编程文章标签： java

本文链接：https://blog.csdn.net/m0_49797779/article/details/124146964

版权

笔记同时被 2 个专栏收录

52 篇文章 0 订阅

订阅专栏

java并发编程

6 篇文章 0 订阅

订阅专栏

CAS.JUC常用类

CAS

CAS(Compare-And-Swap) ：比较并交换，该算法是硬件对于并发操作的支持.适用于低并发的情况下

CAS 是乐观锁的一种实现方式，他采用的是自旋锁的思想，是一种轻量级的锁机制。

在这里插入图片描述

CAS 包含了三个操作数：

①内存值 V ;

②预估值 A (比较时,从内存中再次读到的值) ;

③更新值 B (更新后的值).

当且仅当预期值 A==V，将内存值 V=B，否则什么都不做。

优点:

这种做法的效率高于加锁,当判断不成功不能更新值时,不会导致线程阻塞,继续获得 cpu 执行权,继续判断执行

缺点:

CAS 使用自旋锁的方式，由于该方式会不断循环判断，因此不会类似 synchronize 线程阻塞导致线程切换。但是不断的自旋，会导致 CPU 的消耗，在并发量大的时候(高并发)容易导致 CPU 跑满。

可能会产生ABA问题.

ABA 问题:

ABA 问题，即某个线程将内存值由 A 改为了 B，再由 B 改为了 A。当另外一个线程使用预期值去判断时，预期值与内存值相同，误以为该变量没有被修改过而导致的问题。

ABA问题的解决

解决 ABA 问题的主要方式，通过使用类似添加版本号的方式，来避免 ABA 问题。如原先的内存值为（A，1），线程将（A，1）修改为了（B，2），再由（B，2）修改为（A，3）。此时另一个线程使用预期值（A，1）与内存值（A，3）进行比较，只需要比较版本号 1 和 3，即可发现该内存中的数据被更新过了。

JUC 常用类

Java 5.0 在 java.utilconcurrent 包中提供了多种并发容器类来改进同步容器的性能.

在这里插入图片描述

1.ConcurrentHashMap

ConcurrentHashMap 同步容器类是 Java 5 增加的一个线程安全的哈希表。对与多线程的操作，介于 HashMap 与 Hashtable 之间。内部采用“锁分段”机制(jdk8 弃用了分段锁，使用 cas+synchronized)替代 Hashtable 的独占锁。进而提高性能。

放弃分段锁的原因:

1.加入多个分段锁浪费内存空间。

2.生产环境中， map 在放入时竞争同一个锁的概率非常小，分段锁反而会造成更新等操作的长时间等待。

jdk8 放弃了分段锁而是用了 Node 锁，减低锁的粒度，提高性能，并使用 CAS 操作来确保 Node 的一些操作的原子性，取代了锁。
put 时首先通过 hash 找到对应链表过后，查看是否是第一个 Node，如果是，直接用 cas 原则插入，无需加锁。
然后，如果不是链表第一个 Node，则直接用链表第一个 Node 加锁，这里加的锁是 synchronized。

在这里插入图片描述

HashMap:


import java.util.HashMap;
import java.util.Random;

public class HashmapDemo {

    /*
    HashMap是线程不安全的.不能并发操作的

    ConcurrentModificationException 并发修改异常
     */
    public static void main(String[] args) {

        HashMap<String, Integer> map = new HashMap<>();
        //模拟多个线程对HashMap操作
        for (int i = 0; i < 20; i++) {
            new Thread(
                    () -> {
                        map.put(Thread.currentThread().getName(), new Random().nextInt());
                        System.out.println(map);
                    }
            ).start();
        }

    }
}

运行结果:( ConcurrentModificationException 并发修改异常,HashMap是线程不安全的)
在这里插入图片描述
Hashtable

import java.util.Hashtable;
import java.util.Random;

public class HashtableDemo {

    /*
   Hashtable是线程安全的.可以进行并发操作
    */
    public static void main(String[] args) {
        
        // Map<String, Integer> map = Collections.synchronizedMap(new HashMap<>());
        Hashtable<String, Integer> map = new Hashtable<>();
        //模拟多个线程对Hashtable操作
        for (int i = 0; i < 20; i++) {
            new Thread(
                    () -> {
                        map.put(Thread.currentThread().getName(), new Random().nextInt());
                        System.out.println(map);
                    }
            ).start();
        }

    }
}

运行结果:
Hashtable的方法用synchronized 修饰的,因此是线程安全的
锁直接加在方法上面,锁粒度比较大,效率比较低,用在低并发情况下可以 --> 独占锁
在这里插入图片描述
ConcurrentHashMap:

import java.util.Random;
import java.util.concurrent.ConcurrentHashMap;

public class ConcurrentHashMapDemo {

    /*
      ConcurrentHashMap.可以进行并发操作
    */
    public static void main(String[] args) {
        // Map<String, Integer> map = Collections.synchronizedMap(new HashMap<>());
        ConcurrentHashMap<String, Integer> map = new ConcurrentHashMap<>();
        //模拟多个线程对ConcurrentHashMap操作
        for (int i = 0; i < 20; i++) {
            new Thread(
                    () -> {
                        map.put(Thread.currentThread().getName(), new Random().nextInt());
                        System.out.println(map);
                    }
            ).start();
        }

    }
}

运行也是没有问题的,支持并发操作.

总结:

ConcurrentHashMap采用锁分段机制,并没有将整个hash表锁住, jdk8之后没有使用分段锁(给每个位置创建一个锁标志对象).

采用的是CAS思想+synchronized来实现

插入时,检测hash表对应位置是否是第一个节点, 如果是采用CAS机制(循环检查) 向第一个位置插入数据.

如果此位置已经有值,那么就以第一个Node对象为锁标志进行加锁,使用的是synchronized实现.

2.CopyOnWriteArrayList

ArrayList 是线程不安全的,在高并发情况下可能会出现问题, Vector 是线程安全的
但是在很多应用场景中，读操作可能会远远大于写操作。由于读操作根本不会修改原有的数据，因此如果每次读取都进行加锁操作，其实是一种资源浪费。我们应该允许多个线程同时访问 List 的内部数据，毕竟读操作是线程安全的。

JDK 中提供了 CopyOnWriteArrayList 类，将读取的性能发挥到极致，取是完全不用加锁的，并且更厉害的是：写入也不会阻塞读取操作，只有写入和写入之间需要进行同步等待，读操作的性能得到大幅度提升。

ArrayList:


import java.util.ArrayList;
import java.util.Random;

public class ArrayListDemo {
    /*
     ArrayList<> list = new ArrayList<>(); 
     并发情况下不能使用ArrayList;不能同时有两个线程对其操作
     */
    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList<Integer>();
        for (int i = 0; i < 20; i++) {
            new Thread(
                    () -> {
                        list.add(new Random().nextInt());
                        System.out.println(list);
                    }
            ).start();
        }
    }
}

运行会报错; 并发情况下不能使用ArrayList;不能同时有两个线程对其操作
在这里插入图片描述
Vector:

import java.util.Random;
import java.util.Vector;

public class VectorDemo {
    /*
     Vector<> vector = new Vector<>();
     是线程安全的,但是对读操作也叫锁,锁的粒度大,效率低;读和写用的是同一把锁
     */
    public static void main(String[] args) {
        Vector<Integer> vector = new Vector<Integer>();
        for (int i = 0; i < 20; i++) {
            new Thread(
                    () -> {
                        vector.add(new Random().nextInt());
                        System.out.println(vector);
                    }
            ).start();
        }
    }
}

运行结果没有报错.

CopyOnWriteArrayList

import java.util.Random;
import java.util.concurrent.CopyOnWriteArrayList;

public class CopyOnWriteArrayListDemo {
    /*
     CopyOnWriteArrayList<> list = new CopyOnWriteArrayList<>();
     CopyOnWriteArrayList，对读和写进行了分离,读操作不需要加锁,读不影响数据,
     写操作加锁,写操作时不影响读操作,只有两个线程同时添加时会互斥
     将读取的性能发挥到极致，取是完全不用加锁的，并且更厉害的是：写入也不会阻塞读取操作，
     只有写入和写入之间需要进行同步等待，读操作的性能得到大幅度提升。
     */
    public static void main(String[] args) {
        CopyOnWriteArrayList<Integer> list = new CopyOnWriteArrayList<Integer>();
        for (int i = 0; i < 20; i++) {
            new Thread(
                    () -> {
                        list.add(new Random().nextInt());
                        System.out.println(list);
                    }
            ).start();
        }
    }
}

运行也是没有问题的.

CopyOnWriteArrayList 类的所有可变操作（add，set 等等）都是通过创建底层数组的新副本来实现的。当 List 需要被修改的时候，并不直接修改原有数组对象，而是对原有数据进行一次拷贝，将修改的内容写入副本中。写完之后，再将修改完的副本替换成原来的数据，这样就可以保证写操作不会影响读操作了。

    /*
    CopyOnWriteArrayList的add方法源码
    添加时先将原数组复制出一个副本,然后将数据添加到副本中,不影响读操作,最后再用副本替换原数组.
     */
    public boolean add(E e) {
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
            Object[] elements = getArray();
            int len = elements.length;
            Object[] newElements = Arrays.copyOf(elements, len + 1);
            newElements[len] = e;
            setArray(newElements);
            return true;
        } finally {
            lock.unlock();
        }
    }

3.CopyOnWriteArraySet

CopyOnWriteArraySet 的实现基于 CopyOnWriteArrayList,不能存储重复数据.

import java.util.Random;
import java.util.concurrent.CopyOnWriteArraySet;

public class CopyOnWriteArraySetDemo {

    /*
     CopyOnWriteArraySet不允许重复数据的单例集合,底层实现 CopyOnWriteArrayList
     添加数据时会判断是否有重复数据.
     */
    public static void main(String[] args) {
        CopyOnWriteArraySet<Integer> set = new CopyOnWriteArraySet<Integer>();
        //模拟多个线程对其操作
        for (int i = 0; i < 20; i++) {
            new Thread(
                    () -> {
                        set.add(new Random().nextInt());
                        System.out.println(set);
                    }
            ).start();
        }
    }
}

4.辅助类 CountDownLatch

CountDownLatch这个类使一个线程等待其他线程各自执行完毕后再执行。是通过一个计数器来实现的，计数器的初始值是线程的数量。每当一个线程执行完毕后，计数器的值就-1，当计数器的值为 0 时，表示所有线程都执行完毕，然后在闭锁上等待的线程就可以恢复工作了。

import java.util.concurrent.CountDownLatch;

public class CountDownLatchDemo {

    /*
      CountDownLatch 辅助类  递减计数器
         使一个线程 等待其他线程执行结束后再执行
         相当于一个线程计数器,是一个递减的计数器
         先指定一个数量,当有一个线程执行结束后就减一 直到为0 关闭计数器
         这样线程就可以执行了
     */

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

        CountDownLatch downLatch = new CountDownLatch(6);//计数
        for (int i = 0; i <6 ; i++) {
            new Thread(
                ()->{
                    System.out.println(Thread.currentThread().getName());
                    downLatch.countDown();//计数器减一操作
                }
            ).start();
        }
        downLatch.await();//关闭计数

        System.out.println("main线程执行");
    }
}

当我们把CountDownLatch 注释了的话,运行后输出语句不一定最后执行,具有随机性.

在这里插入图片描述

但是当我们加上CountDownLatch 后,设置一个大小,这时我们可以保证输出语句最后执行在这里插入图片描述

但是要注意,当我们如果设置的大小比线程数大,则会导致计数器无法减到0;会导致线程阻塞!

在这里插入图片描述

5.辅助类 CyclicBarrier

CyclicBarrier是一个同步辅助类，让一组线程到达一个屏障时被阻塞，直到最后一个线程到达屏障时，屏障才会开门

import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;

public class CyclicBarrierDemo {

    /*
       CyclicBarrier 让一组线程到达一个屏障时被阻塞，直到最 后一个线程到达屏障时，屏障才会开门
       是一个加法计数器,当线程数量到达指定数量时,开门放行
     */

    public static void main(String[] args) {
        CyclicBarrier c = new CyclicBarrier(5, ()->{
            System.out.println("大家都到齐了 该我执行了");
        });

        for (int i = 0; i < 5; i++) {
            new Thread(
                    ()->{
                        System.out.println(Thread.currentThread().getName());
                        try {
                            c.await();//加一计数器
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        } catch (BrokenBarrierException e) {
                            e.printStackTrace();
                        }
                    }
            ).start();
        }
    }
}

在这里插入图片描述

面向c v编程

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
Java 并发编程(CAS,JUC常用类)(3)

CAS.JUC常用类CASJUC 常用类1.ConcurrentHashMap2.CopyOnWriteArrayListCASCAS(Compare-And-Swap) ：比较并交换，该算法是硬件对于并发操作的支持.适用于低并发的情况下CAS 是乐观锁的一种实现方式，他采用的是自旋锁的思想，是一种轻量级的锁机制。CAS 包含了三个操作数：①内存值 V ;②预估值 A (比较时,从内存中再次读到的值) ;③更新值 B (更新后的值).当且仅当预期值 A==V，将内存值 V=B，否则什么都不
复制链接

扫一扫