【Java EE 初阶】JUC常见工具类介绍

最新推荐文章于 2024-04-23 19:50:58 发布

小锦鲤yaw

最新推荐文章于 2024-04-23 19:50:58 发布

阅读量989

点赞数 3

分类专栏： Java EE 文章标签： java 开发语言

本文链接：https://blog.csdn.net/m0_57248981/article/details/130721718

版权

Java EE 专栏收录该内容

25 篇文章 0 订阅

订阅专栏

1.JUC

1.Callable接口（描述线程任务的接口）

2.Callable接口和Runnable接口区别

3.Reentrant Lock和Synchronized的区别

1.JUC

java.util.concurrent 包的简称，JDK1.5之后对多线程的一种实现，这个包下放的类都与多线程有关，提供了很多工具类

1.Callable接口（描述线程任务的接口）

用Callable接口创建一个线程

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

public class Callable01 {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        Callable<Integer> callable = new Callable<Integer>() {
            @Override
            public Integer call() throws Exception {
                System.out.println("我是Callable实现的Call方法");
                int res = 0;
                for (int i = 0; i < 10; i+=2) {
                    res += i;
                }
                return res;
            }
        };
        FutureTask<Integer> futureTask = new FutureTask<>(callable);
        Thread thread = new Thread(futureTask);
        thread.start();
        System.out.println(futureTask.get());
    }
}

2.Callable接口和Runnable接口区别

1.Callable实现的是Call方法，Runnable实现的是Run方法

2.Callable可以返回一个结果，Runnable没有返回值

3.Callable需要搭配Future task一起使用，Future Task是一个实现了Runnable接口的子类，所以Callable也可以传入Thread

4.Callable可以抛出异常，Runnable不可以

2.Reentrant Lock

是基于CAS实现的一个纯用户态的锁

1.常用的方法：

1.演示基本方法

public static void main(String[] args) throws InterruptedException {
        ReentrantLock reentrantLock = new ReentrantLock();
        //加锁
        reentrantLock.lock();
        //死等
        reentrantLock.tryLock();
        //等一秒
        reentrantLock.tryLock(1, TimeUnit.SECONDS);
        //释放锁
        reentrantLock.unlock();
    }

2.出现异常，如何确保释放锁

    public static void main(String[] args) throws Exception {
        ReentrantLock reentrantlock = new ReentrantLock();
        reentrantlock.lock();
        try {
            //模拟业务出现异常
            throw  new Exception("出现错误！");
        }finally {
            //无论是否出现异常，锁一定会释放
            reentrantlock.unlock();
        }
    }

3.创建一个公平锁

ReentrantLock reentrantLock1 = new ReentrantLock(true);

4.创建一个读写锁

    public static void main(String[] args) {
        //创建
        ReentrantReadWriteLock reentrantReadWriteLock = new ReentrantReadWriteLock();
        //获取读锁
        reentrantReadWriteLock.readLock();
        //获取写锁
        reentrantReadWriteLock.writeLock();
    }

3.Reentrant Lock和Synchronized的区别

4.原子性

Java.util.concurrent.atomic包下

5.JUC工具类常用类

1.Semaphore-信号量

指定了资源的数量，申请资源的时候，如果没有空闲资源，那么当前申请资源的线程就必须等待

Semaphore 的 PV 操作中的加减计数器操作都是原子的, 可以在多线程环境下直接使用.

遇到需要指定有限的资源个数时，可以考虑使用Semaphore来处理

以停车场为例

import java.util.concurrent.Semaphore;
import java.util.concurrent.TimeUnit;

public class Demo03 {
    private static Semaphore semaphore = new Semaphore(3);
    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            int flag = i+1;
            Thread thread = new Thread(new Runnable() {
                @Override
                public void run() {
                    try {
                        System.out.println("车辆"+flag+"尝试获取资源");
                        semaphore.acquire();
                        System.out.println("车辆"+flag+"获取到了资源");
                        TimeUnit.SECONDS.sleep(1);
                        semaphore.release();
                        System.out.println("车辆"+flag+"释放了资源");
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            });
            thread.start();
        }
    }
}

2.CountDownLatch

CountDownLatch的作用就是可以设置所有的线程都必须到达某一个关键点，然后再执行后续的操作

使用场景：把一个大任务分成若干个小任务，或者是等待一写前置资源的时候，可以考虑用Count DownLoach

以颁奖为例

好像跑步比赛，10个选手依次就位，哨声响才同时出发；所有选手都通过终点，才能颁奖。

构造 CountDownLatch 实例, 初始化 10 表示有 10 个任务需要完成.
每个任务执行完毕, 都调用 latch.countDown() . 在 CountDownLatch 内部的计数器同时自减.
主线程中使用 latch.await(); 阻塞等待所有任务执行完毕. 相当于计数器为 0 了.

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;

public class Demo04 {
    public static void main(String[] args) throws InterruptedException {
        CountDownLatch count = new CountDownLatch(10);
        for (int i = 0; i < 10; i++) {
            int flag = i+1;
            Thread thread = new Thread(new Runnable() {
                @Override
                public void run() {
                    try {
                        System.out.println("运动员"+flag+"号已出发");
                        TimeUnit.SECONDS.sleep(1);
                        System.out.println("运动员"+flag+"号已到达");
                        count.countDown();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            });
            thread.start();

        }
        count.await();
        System.out.println("开始颁奖");
    }
}