JUC常用类介绍

最新推荐文章于 2024-05-02 21:28:00 发布
最新推荐文章于 2024-05-02 21:28:00 发布
阅读量1.5k 收藏 7
点赞数 2
分类专栏： java 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/raulism1117/article/details/105216213
版权

文章目录

JUC常用类介绍

Volatile

volatie只能保证线程之间的可见性，不能保证原子性。

/**
* 不能保证原子性的代码
*/
public class VolatileNotSync {
    volatile int count = 0;

    void m() {
        for (int i = 0; i < 10000; i++) {
            count++;
        }
    }

    public static void main(String[] args) {
        VolatileNotSync volatileNotSync = new VolatileNotSync();
        List<Thread> list = new ArrayList<>();
        for (int i = 0; i < 10; i++) {
            Thread thread = new Thread(volatileNotSync::m);
            list.add(thread);
        }
        list.forEach(Thread::start);
        for (Thread thread : list) {
            try {
                thread.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println(volatileNotSync.count);
    }
}

Synchronized

既保证了可见性，也保证了原子性。jdk1.6 Synchronized做了优化，锁升级（无锁 -> 偏向锁 -> 乐观锁 -> 重量级锁）

锁升级.png

AtomicXXX

AtomXXX类本身方法都是原子性的，但不能保证多个方法连续调用是原子性的。底层利用CAS实现

public class TestAtomic {
    AtomicInteger count = new AtomicInteger();

    void m() {
        for (int i = 0; i < 10000; i++) {
            // 多个方法连续调用，不能保证原子性
            if (count.get() < 1000)
                count.incrementAndGet();
        }
    }

    public static void main(String[] args) {
        TestAtomic testAtomic = new TestAtomic();
        List<Thread> list = new ArrayList<>();
        for (int i = 0; i < 1000; i++) {
            list.add(new Thread(testAtomic::m, "thread-" + i));
        }
        list.forEach(Thread::start);
        list.forEach((o) -> {
            try {
                o.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        System.out.println(testAtomic.count);
    }
}

Reentrantlock

可以替代Synchronized，必须手动释放锁。而且可以指定公平锁。

public class TestReentrantLock {
    // true为公平锁，false为非公平锁，默认为false
    private static ReentrantLock lock = new ReentrantLock(true);

    void run() {
        for (int i = 0; i < 100; i++) {
            lock.lock();
            System.out.println(Thread.currentThread().getName() + "---");
            lock.unlock();
        }
    }

    public static void main(String[] args) {
        TestReentrantLock t = new TestReentrantLock();
        Thread t1 = new Thread(t::run);
        Thread t2 = new Thread(t::run);
        t1.start();
        t2.start();
    }
}

CountDownLatch

java1.5被引入，使一个线程等待其他线程各自执行完毕后再执行。

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

public class TestCountdownLatch {
    public static void main(String[] args) {
        usingCountDownLatch();
    }

    private static void usingCountDownLatch() {
        Thread[] threads = new Thread[100];
        CountDownLatch latch = new CountDownLatch(threads.length);
        for (int i = 0; i < threads.length; i++) {
            threads[i] = new Thread(() -> {
                int result = 0;
                for (int j = 0; j < 10000; j++) result += j;
                latch.countDown();
            });
        }
        for (int i = 0; i < threads.length; i++) {
            threads[i].start();
        }
        try {
            latch.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("end latch");
    }
}

CyclicBarrier

会让所有线程都等待完成后才会继续下一步行动。

比如，就像生活中我们会约朋友们到某个餐厅一起吃饭，有些朋友可能会早到，有些朋友可能会晚到，但是这个餐厅规定必须等到所有人到齐之后才会让我们进去。这里的朋友们就是各个线程，餐厅就是 CyclicBarrier。

参考：https://www.jianshu.com/p/333fd8faa56e

CountDownLatch和CyclicBarrier区别：

  1. countDownLatch是一个计数器，线程完成一个记录一个，计数器递减，只能只用一次
  2. CyclicBarrier的计数器更像一个阀门，需要所有线程都到达，然后继续执行，计数器递增，提供reset功能，可以多次使用
public class TestCyclicBarrier {
    public static void main(String[] args) {
        CyclicBarrier barrier = new CyclicBarrier(20, () -> {
            System.out.println(Thread.currentThread().getName() + ":完成最后任务");
        });

        for (int i = 0; i < 20; i++) {
            new Thread(() -> {
                try {
                    System.out.println(Thread.currentThread().getName() + "到达");
                    Thread.sleep(100);
                    barrier.await();
                } catch (InterruptedException | BrokenBarrierException e) {
                    e.printStackTrace();
                }
            }).start();
        }
    }
}

Phaser

JAVA 1.7引入了一个新的并发API：Phaser，一个可重用的同步barrier。用来解决控制多个线程分阶段共同完成任务的情景问题。

比如：5个学生一起参加考试，一共有三道题，要求所有学生到齐才能开始考试，全部同学都做完第一题，学生才能继续做第二题，全部学生做完了第二题，才能做第三题，所有学生都做完的第三题，考试才结束。分析这个题目：这是一个多线程（5个学生）分阶段问题（考试考试、第一题做完、第二题做完、第三题做完），所以很适合用Phaser解决这个问题。

参考：https://blog.csdn.net/u010739551/article/details/51083004

ReadWriterLock

JUC包主要是 ReentrantReadWriteLock。提供 readLock 和 writeLock 方法。

  1. ReetrantReadWriteLock读写锁的实现中，读锁使用共享模式；写锁使用独占模式，换句话说，读锁可以在没有写锁的时候被多个线程同时持有，写锁是独占的
  2. ReetrantReadWriteLock读写锁的实现中，需要注意的，当有读锁时，写锁就不能获得；而当有写锁时，除了获得写锁的这个线程可以获得读锁外，其他线程不能获得读锁
  3. 读写锁的实现必须确保写操作对读操作的内存影响。换句话说，一个获得了读锁的线程必须能看到前一个释放的写锁所更新的内容，读写锁之间为互斥
  4. ReentrantReadWriteLock支持锁降级，不支持锁升级（同一个线程中，在没有释放读锁的情况下，就去申请写锁）。
public class TestReadWriteLock {
    static ReentrantReadWriteLock lock = new ReentrantReadWriteLock();

    static Lock readLock = lock.readLock();
    static Lock writeLock = lock.writeLock();

    void read() {
        readLock.lock();
        if (!lock.isWriteLocked()) {
            System.out.println(Thread.currentThread().getName() + "获取到读锁");
        }
        for (int i = 0; i < 5; i++) {
            System.out.println(Thread.currentThread().getName() + "正在读...");
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        readLock.unlock();
        System.out.println(Thread.currentThread().getName() + "释放读锁");
    }

    void write() {
        writeLock.lock();
        if (lock.isWriteLocked()) {
            System.out.println(Thread.currentThread().getName() + "获取到写锁");
        }
        for (int i = 0; i < 5; i++) {
            System.out.println(Thread.currentThread().getName() + "正在写...");
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        writeLock.unlock();
        System.out.println(Thread.currentThread().getName() + " 释放写锁");
    }

    public static void main(String[] args) {
        TestReadWriteLock t = new TestReadWriteLock();
        for (int i = 0; i < 3; i++) {
            new Thread(t::read).start();
        }
        for (int i = 0; i < 2; i++) {
            new Thread(t::write).start();
        }
        for (int i = 0; i < 3; i++) {
            new Thread(t::read).start();
        }
    }
}

Semaphore

Semaphore 是一个计数信号量，必须由获取它的线程释放。

常用于限制可以访问某些资源的线程数量，例如通过 Semaphore 限流。

Semaphore 只有3个操作：

  1. 初始化
  2. 增加
  3. 减少
public class TestSemaphore {
    public static void main(String[] args) {
        Semaphore s = new Semaphore(2, true);
        new Thread(() -> {
            try {
                s.acquire();
                System.out.println("t1.start");
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                s.release();
            }
        }).start();
        new Thread(() -> {
            try {
                s.acquire();
                System.out.println("t2.start");
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                s.release();
            }
        }).start();
    }
}

Exchanger

Exchanger 是 JDK 1.5 开始提供的一个用于两个工作线程之间交换数据的封装工具类，简单说就是一个线程在完成一定的事务后想与另一个线程交换数据，则第一个先拿出数据的线程会一直等待第二个线程，直到第二个线程拿着数据到来时才能彼此交换对应数据。

public class TestExchanger {
    static Exchanger<String> exchanger = new Exchanger<>();

    public static void main(String[] args) {
        Thread t1 = new Thread(() -> {
            String t = "t1";
            try {
                t = exchanger.exchange(t);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "-" + t);
        });
        Thread t2 = new Thread(() -> {
            String t = "t2";
            try {
                t = exchanger.exchange(t);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "-" + t);
        });
        t1.start();
        t2.start();
    }
}

LockSupport

主要有park()和unpark()方法。park()阻塞当前线程，unpark()恢复当前线程。

与wait和notify的主要区别表现在 1.不需要获取某个对象的锁。2.没有前后顺序的区别

public class TestLockSupport {
    public static void main(String[] args) {
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                System.out.println(i);
                if (i == 5) {
                    LockSupport.park();
                }
                try {
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        t1.start();
        try {
            // 保证先park后unpark
            Thread.sleep(8000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        LockSupport.unpark(t1);
    }
}
怀瑾握瑜1117
关注
专栏目录
【多线程】JUC的常见类
程序猿教你打篮球的博客
08-18 7316
本期主要讲解： 1.Callable接口 2.ReentrantLock可重入锁 2.1认识ReentrantLock 2.2 ReentrantLock 的优势 3. Semaphroe信号量 3.1认识信号量 3.2信号量与锁 4.CountDownLatch 5.多线程环境使用集合类 5.1多线程使用ArrayList 5.2多线程使用HashMap(重点)
Java基础学习总结（193）—— JUC 常用并发工具类总结
科技D人生
04-15 697
什么是 JUC JUC 就是 java.util.concurrent 包,这个包俗称 JUC,里面都是解决并发问题的一些东西。该包的位置位于 java 下面的 rt.jar 包下面。4大常用并发工具类：CountDownLatch、CyclicBarrier、Semaphore、ExChanger。 CountDownLatch： CountDownLatch, 俗称闭锁,作用是类似加强版的 Join, 是让一组线程等待其他的线程完成工作以后才执行，就比如在启动框架服务的时候,我们主线程需要在环境线
JUC常见类
最新发布
2301_77053417的博客
05-02 853
JUC是java.util.concurrent的简称，这个包里面存放的都是和多线程相关的类，在面试中非常的重要。
JUC下的常见类
DavenportChen的博客
05-31 383
JUC下常见的类JUC（ java.util.concurrent）: JUC（ java.util.concurrent）: ReentranLocal（lock写在try之外；一定要在finaly里面进行unlock()） 信号量（Semaphore）： Semaphore 是一种基于计数的信号量。它可以设定一个阈值，基于此，多个线程竞争获取许可信号，做完自己的申请后归还，超过阈值后，线程申请许可信号将会被阻塞。Semaphore 可以用来构建一些对象池，资源池之类的，比如数据库连接池。
JUC中常用的三种辅助类，你知道吗？
qq_36525300的博客
05-28 383
JUC中提供了三种常用的辅助类，通过这些辅助类可以很好的解决线程数量过多时Lock锁的频繁操作。这三种辅助类为： CountDownLatch CyclicBarrier 2 1.CountDownLatch 下图是Jdk中解释的CountDownLatch类功能，简单而言，在实例化时，需要传入一个信号量，每当一个线程执行后，信号量减1，当信号量为0时，释放阻塞的线程。 用个小Demo模拟，需求是启动5个线程，当5个线程执行完后，main线程才能继续执行，如果不使用CountDownLatch，线程
JUC常用到的类
qq_28908085的博客
08-28 1567
JUC（java.util.concurrent）并发包中包含了许多并发编程中需要用到的类。 锁，如ReentratLock，ReadWriteLock。 ReentrantLock重入锁，可以替代synchronized使用，并且有更多强大的功能，比如说可以中断锁，trylock，超时等待，公平锁等。 ReadWriteLock，读写锁，更是对读和写进行了锁分离，在读多写少的场景下，能极大的提高程序的性能。 原子类 基本类，数组类，引用类等。AtomicInteger比较常用。使用原子类，可以不
JUC 常用类、锁
qq_48019875的博客
01-17 883
目录一、JUC 常用类1、ConcurrentHashMap 一、JUC 常用类 Java 5.0 在 java.utilconcurrent 包中提供了多种并发容器类来改进同步容器的性能. 1、ConcurrentHashMap ConcurrentHashMap 采用锁分段机制，并没有将整个hash表锁住，jdk8之后没有使用分段锁（给每个位置创建一个锁标志对象）。 采用CAS思想 + synchronized来实现 插入元素时，检测hash表对应位置是否是第一个节点，如果采用CAS机制（循环检查）
JUC并发编程（八）-JUC常用辅助类
二总的猫
02-26 582
8、常用辅助类 8.1、CountDownLatch CountDownLatch:减计数器，使用场景： ​ 乘坐飞机时，乘务服务员都要根据手中的订票人数清点人数，只有人数到齐了才关门起飞，那怎么有效精准的控制什么时候关门起飞呢，使用CountDownLatch减法计数器有效控制。 CountDownLatch 编码模型： CountDownLatch countDownLatch = ne...
java juc包常用类解析
05-13
Java中的JUC（java.util.concurrent）包提供了一些并发编程中常用的类，这些类可以帮助我们更方便地实现多线程编程。以下是一些常用的JUC类及其解析： 1. CountDownLatch（倒计时器） CountDownLatch是一个计数器...
JUC常见类以及线程安全的集合类
weixin_58850105的博客
04-17 1613
这是关于线程的最后一更啦~~~ 目录 1.JUC常见类 1.1Callable接口 1.2ReentrantLock 1.3信号量 Semaphore 1.4CountDownLatch 2.线程安全的集合类 2.1多线程环境使用 ArrayList 2.2多线程环境使用队列 2.3多线程环境使用哈希表 2.3.1Hashtable 2.3.2ConcurrentHashMap 1.JUC常见类 JUC的全称：java.util.concurrent（concurrent指..
【多线程进阶】JUC中常见类
一些普普通通的学习笔记
10-08 280
本文主要讲解 JUC ---- java.util.concurrent 中的一些常见类. concurrent 就是并发的意思, 所以该类中放的都是一些多线程并发编程, 常常使用到的东西.✨ 本文主要讲解了 JUC 中的一些常见类, 需要掌握 Callable 接口, ReentrantLock 锁, 原子类, 线程池, 信号量以及 CountDownLatch.多线程学习专栏, 里面会持续更新本人的学习记录, 跟随我一起不断学习.!!!!
JUC类（ReentrantLock、Semaphore、CountDownLatch、CyclicBarrier）
m0_48273471的博客
04-18 745
java.util.concurrent 下的类就叫 JUC 类，JUC 下典型的类有： ● ReentrantLock ● Semaphore ● CountDownLatch ● CyclicBarrier 1. ReentrantLock：可重⼊锁 public class ThreadDemo22 { public static void main(String[] arg...
常用的几个JUC工具类
weixin_40920882的博客
05-12 264
CountDownLatch CountDownLatch初始化的时候给定一个计数，每次调用countDown计数减一 当计数未到达0之前调用await方法阻塞，直到计数减到0 使用场景，多用于划分任务由多个线程执行，例如，我们要写一个爬虫，需要爬取每个电影的前五页短评，可以划分五个线程来处理数据，通过latch.swait保证全部完成在返回 public class CountDownLatch { public void latch() throws InterruptedException {
JUC下典型的类
m0_48273471的博客
08-17 382
JUC
JUC常用类
爱敲代码的三毛的博客
08-06 467
原子类、信号量、ReentrantLock
JUC(java.util.concurrent)的常见类
buhuisuanfa的博客
01-15 1692
我们的停车场的大牌子上就写着，当前剩余车位xx个，当有车进去，就相当于进行了一次P操作，计数器-1，当有车从停车场出来，就相当于进行了一次V操作，计数器+1，当我们的停车场的剩余车位为0时，也就是计数器为0时，如果有车想停车，要么在这里等，要么就去其他停车场。不能直接放进去，也很简单，因为我们的Callable是带有返回值的，可能有多个线程去执行同一个callable的任务，而且啥时候执行完并不确定，所以我们这里无法获取到返回值，我们的Synchronized也是我们标准库提供的锁，那么它们有什么区别呢?
JUC工具类
qq_35151346的博客
08-21 531
一、概述 1.在并发编程中，我们会用到并发容器，线程池，线程方法。同时如果能够很好的使用JUC下的一些常用工具，对并发编程事半功倍。 2.常见的工具：Semaphore、CountDownLatch、CyclicBarrier、ExChanger、Phaser 二、作用 1.Semaphore 通俗来讲这个工具类的作用就是来控制某一资源同一时间段线程数量的访问...
JUC下的常用类
ZJH
08-24 708
juc常用类
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值