当前位置：主页 > JAVA语言

java多线程框架有哪些-关于JavaUtilConcurrent的几个常见问题解析

发布时间：2023-07-07 09:05 浏览次数：次作者：佚名

文章目录

在这里插入图片描述

1. JUC是什么

JUC是Java并发编程中的一个重要模块，全称为Java Util Concurrent（Java并发工具包），它提供了一组用于多线程编程的工具类和框架java多线程框架有哪些，帮助开发者更方便地编写线程安全的并发代码。

本文主要介绍Java Util Concurrent下的一些常用接口和类

2. Callable接口

Callable接口类似于Runnable. 有一点区别就是Runable描述的任务没有返回值,而Callable接口是带有返回值的

示例:

Callable<返回值类型> callable = new Callable<Integer>() {
    @Override
    public 返回值类型 call() throws Exception {
       // 执行的任务      
    }
};

Callable接口定义了一个call()方法，因此在创建实例的时要实现这个方法. 该方法在任务执行完成后返回一个结果，并且可以抛出异常。

与Runnable不同,Callable描述的任务不能直接传给线程去执行. 因此需要借助FutureTask这个类

FutureTask<返回值类型> futureTask = new FutureTask<>(callable);

获取上述任务的返回值可以使用 FuturTask提供的get方法.

示例:

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        Callable<Integer> callable = new Callable<Integer>() {
            @Override
            public Integer call() throws Exception {
                int ret = 0;
                for (int i = 1; i <= 10; i++) {
                    ret += i;
                }
                return ret;
            }
        };
        FutureTask<Integer> futureTask = new FutureTask<>(callable);
        Thread t1 = new Thread(futureTask);
        t1.start();
        System.out.println(futureTask.get());
    }

运行结果:

在这里插入图片描述

3. ReentrantLock

ReentrantLock：ReentrantLock是Lock接口的一个实现类，它实现了Lock接口的所有方法。ReentrantLock支持重入性，也就是说同一个线程可以多次获取同一个锁，而不会产生死锁。这种特性使得ReentrantLock可以用于更复杂的线程同步场景。

在ReentrantLock中,有三个十分重要的方法:

lock():加锁unlock():解锁.tryLock(): 用于尝试获取锁，如果锁是可用的，就立即获取并返回true，如果锁不可用，就立即返回false，而不会阻塞当前线程。还可以指定获取锁的最大等待时间.

与synchronized不同,它的加锁和解锁操作时分开的,需要自己去添加.

这也可能会导致如果在加锁之后,代码出现异常,则有可能执行不到unlock方法.这也是ReentranLock的一个小弊端.但我们可以通过使用try finally来避免.

tryLock方法有两个版本:

在这里插入图片描述

在实际开发中, 使用这种"死等的策略"往往要慎重,tryLock()让我们面对这种情况有更多的选择

ReentrantLock可以实现公平锁. 默认是非公平的.

但当我们创建实例时,传入参数true时.就变成公平锁了

ReentrantLock reentrantLock = new ReentrantLock(true);

synchronize搭配wait/notify方法来实现线程的等待通知的,唤醒的线程是随机的

ReentrantLock搭配Condition类实现线程等待通知的.可以指定线程来进行唤醒

synchronized是Java中的关键字,底层是JVM实现的(C++)

ReentranLock 是标准库的一个类,底层是基于Java实现的

4. 原子类

原子类是为了解决多线程环境下的竞态条件（Race Condition）和数据不一致的问题。在多线程环境下，如果多个线程同时对一个共享变量进行读取和写入操作，可能会导致数据的不一致性，从而产生错误的结果。

原子类是基于CAS实现的

Java提供了多种原子类，常用的原子类有以下四个：

AtomicInteger：用于对int类型的变量进行原子操作。AtomicLong：用于对long类型的变量进行原子操作。AtomicBoolean：用于对boolean类型的变量进行原子操作。AtomicReference：用于对引用类型的变量进行原子操作。

接下来使用原子类AtomicInteger来实现两个线程针对同一个变量自增50000次的操作.

因为是类的实例对象,我们不能直接对类的实例对象进行++操作. 只能借助类提供的一些方法

AtomicInteger的一些方法:

AtomicInteger atomicInteger = new AtomicInteger();
// atomicInteger++
atomicInteger.getAndIncrement();
// ++atomicInteger
atomicInteger.incrementAndGet();
// atomicInteger--
atomicInteger.getAndDecrement();
// --atomicInteger
atomicInteger.decrementAndGet();

public class Demo23 {
    public static void main(String[] args) throws InterruptedException {
        AtomicInteger atomicInteger = new AtomicInteger();
        
        Thread t1 = new Thread(()->{
            for (int i = 0; i < 50000; i++) {
                atomicInteger.getAndIncrement();
            }
        });
        Thread t2 = new Thread(() ->{
            for (int i = 0; i < 50000; i++) {
                atomicInteger.getAndIncrement();
            }
        });
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        System.out.println(atomicInteger);
    }
}

运行结果:

在这里插入图片描述

如果不用原子类,就需要使用synchronized来实现.

5. 线程池

线程池在我之前的文章中详细介绍过,这里就不再这里进行赘述了. 感兴趣的小伙伴可以看这篇文章: 【Java|多线程与高并发】线程池详解

6. 信号量

信号量(Semaphore)维护了一个许可计数器，表示可用的许可数量。当一个线程需要访问共享资源时，它必须先获取一个许可，如果许可数量为0，则线程将被阻塞，直到有可用的许可。当线程使用完共享资源后，它必须释放许可，以便其他线程可以获取许可并访问资源。

信号量的许可数量可以在创建信号量实例时进行设置

// 设置信号量的许可数量为 5
Semaphore semaphore = new Semaphore(5);

信号量中提供了两个主要操作：P（等待）和V（释放）。

P操作对应的方法为acquire()

V操作对应的方法为release()

例如:

public class Demo24 {
    public static void main(String[] args) throws InterruptedException {
        Semaphore semaphore = new Semaphore(5);
        semaphore.acquire();
        semaphore.acquire();
        semaphore.acquire();
        semaphore.acquire();
        semaphore.acquire();
        System.out.println("此时信号量的许可数量为0");
        semaphore.acquire();
        
        semaphore.release();
    }
}

运行结果:

在这里插入图片描述

信号量可以通过控制许可的数量，可以限制同时访问共享资源的线程数量，从而避免竞争条件和数据不一致性。

7. CoutDownLatch

CountDownLatch（倒计时门闩）是Java并发编程中的一种同步工具，用于等待一组线程完成某个任务。

通过CountDownLatch的构造方法,指定等待线程的数量(计数器).

// 设置等待线程的数量为 5
CountDownLatch countDownLatch = new CountDownLatch(5);

当一个线程完成了自己的任务后，可以调用CountDownLatch的countDown()方法将计数器减1。其他线程可以通过调用CountDownLatch的await()方法来等待计数器变为0。

示例:

public class Demo25 {
    public static void main(String[] args) throws InterruptedException {
        CountDownLatch countDownLatch = new CountDownLatch(5);
        for (int i = 0;i < 5;i++){
            Thread t = new Thread(() ->{
                System.out.println(Thread.currentThread().getName()+" 执行任务");
                countDownLatch.countDown();
            });
            t.start();
        }
        countDownLatch.await();
    }
}