Callable接口_JUC的常见类_多线程环境使用ArrayList

爱被打了一巴掌 2023-10-10 16:02 32阅读 0赞

![2d8b044c9aa74626af93f6da7df31ef7.png][]

**目录**

1.Callable接口

相关面试题

3.信号量Semaphore

4.CountDownLatch

5.多线程环境使用ArrayList

热加载

--------------------

## 1.Callable接口 ##

Callable是一个接口,把线程封装了一个"返回值",方便程序员借助多线程的方式计算结果.

类似于Runnable,是用来描述一个任务,区别就是Runnable描述的任务没有返回值,而Callable描述的任务有返回值

看这个例子

创建线程计算 1 + 2 + 3 + ... + 1000, 不使用 Callable 版本

public class Test {
        static class Result {
            public int sum = 0;
            public Object lock = new Object();
        }
        public static void main(String[] args) throws InterruptedException {
            Result result = new Result();
            Thread t = new Thread() {
                @Override
                public void run() {
                    int sum = 0;
                    for (int i = 1; i <= 1000; i++) {
                        sum += i;
                    }
                    synchronized (result.lock) {
                        result.sum = sum;
                        result.lock.notify();
                    }
                }
            };
            t.start();
            synchronized (result.lock) {
                while (result.sum == 0) {
                    result.lock.wait();
                }
                System.out.println(result.sum);
            }
        }
    
    }

使用Runnable来描述任务,没有返回值,这里使用了一个辅助类result,还需要使用一些加锁和wait,notify操作,比较复杂易出错

我们使用Callable来解决这个问题

public static void main(String[] args) throws ExecutionException, InterruptedException {
            Callable<Integer> callable = new Callable<Integer>() {
                @Override
                public Integer call() throws Exception {
                    int sum = 0;
                    for (int i = 1; i <= 1000 ; i++) {
                        sum+=i;
                    }
                    return sum;
                }
            };
    创建线程, 线程的构造方法传入 FutureTask . 此时新线程就会执行 FutureTask 内部的 Callable 的 call 方法, 完成计算. 计算结果就放到了 FutureTask 对象中
            FutureTask<Integer> futureTask = new FutureTask<>(callable);
            Thread t = new Thread(futureTask);
            t.start();
    在主线程中调用 futureTask.get() 能够阻塞等待新线程计算完毕. 并获取到 FutureTask 中的结
    果. 
    
            Integer result = futureTask.get();
            System.out.println(result);
        }

![4beed12ae467463081a957696503fd6f.png][]

call方法就相当于Runnable的run方法,只不过call方法会返回一个泛型返回值,run返回void

![21376584e3d34a86b9524d6d1644f47a.png][]

创建好任务后,需要一个线程来执行,但是这里不能把callable直接传入Thread的构造方法中,需要给它套上一个辅助类

![00b3956ed50e497a93142d0eaf1ee72f.png][]

FutureTask实现了RunnableFuture<V>接口，RunnableFuture<V>接口继承了Runnable, Future<V>

public class FutureTask<V> implements RunnableFuture<V>{
            ...
    }
    public interface RunnableFuture<V> extends Runnable, Future<V> {
        /**
         * Sets this Future to the result of its computation
         * unless it has been cancelled.
         */
        void run();
    }

FutureTask既是Runnable对象，也是Future对象。Future是对于具体的Runnable或者Callable任务的执行结果进行取消、查询是否完成、获取结果、设置结果操作，get方法会阻塞，直到任务返回结果

get方法就是获取结果.get会发生阻塞,直到callable执行完毕,get才阻塞完成,获取到结果

Callable也是创建线程的一种方式

### 相关面试题 ###

介绍下 Callable 是什么

Callable是一个接口,相当于把线程封装了一个"返回值",方便程序员借助多线程方式计算结果

Callable和Runnable相对,都描述一个任务,Callable描述的是带有返回值的任务,Runnable描述的是不带返回值的任务

Callable通常搭配FutureTask使用,FutureTask用来保存Callable的返回结果,因为Callable往往是在另一个线程中执行的,不知道具体执行完的时间,FutureTask就是负责等待结果出来并保存的

> JUC的常见类:

## 2.ReentrantLock ##

ReentrantLock是标准库提供的另一种锁,是可重入锁

> synchronized是基于代码块的方式加锁解锁的
> 
> ReentrantLock比较传统,使用了lock和unlock方式加锁解锁

> ReentrantLock 的用法:
> 
> lock(): 加锁, 如果获取不到锁就死等.
> 
> trylock(超时时间): 加锁, 如果获取不到锁, 等待一定的时间之后就放弃加锁.
> 
> unlock(): 解锁

public static void main(String[] args) {
            ReentrantLock reentrantLock = new ReentrantLock();
            reentrantLock.lock();
            
            reentrantLock.unlock();
        }

在lock和unlock之间就是加锁的部分,但是这样写有可能unlock执行不到,加锁的代码块中间如果存在return或者异常都可能导致unlock不能顺利进行

![2dddff73adcf4c18bc8c0a0927ae4190.png][]

或者在return之前加上unlock,但是如果这种条件语句很多,那么就会很麻烦,此时用finally来解决

![e3f7d073514f4998b207213d2e85727a.png][]

上述是ReentrantLock的劣势,但是它也是有优势的

> 1.ReentrantLock提供了公平锁版本的实现
> 
> ![59cd695e9c8244f3947ef0210671a934.png][]
> 
> 2.synchronized提供的加锁操作是"死等",只要获取不到锁就一直等待,ReentrantLock提供了更灵活的等待方式:tryLock
> 
> ![9bc08104ea5e42b28377dbf6a5f924b4.png][]
> 
> 无参数版本:能加锁就加,加不上锁就放弃
> 
> 有参数版本:指定了超时时间,加不上锁就等待,如果超时了还没获取到锁就放弃
> 
> 3.ReentrantLock提供了一个更强大,更方便的等待通知机制.
> 
> synchronized搭配的是waitnotify,notify的时候是随机唤醒一个wait的线程
> 
> ReentrantLock搭配一个Condition类,进行唤醒的时候可以唤醒指定的线程

虽然ReentrantLock有一定的优势,但是实际开发常用的是synchronized

### 相关面试题 ###

为什么有了 synchronized 还需要 juc 下的 lock？

> synchronized使用时不需要手动释放锁,ReentrantLock 使用时需要手动释放. 使用起来更 灵活
> 
> synchronized 是非公平锁, ReentrantLock 默认是非公平锁. 可以通过构造方法传入一个 true 开启公平锁模式
> 
> synchronized 是通过 Object 的 wait / notify 实现等待-唤醒. 每次唤醒的是一个随机等待的 线程. ReentrantLock 搭配 Condition 类实现等待-唤醒, 可以更精确控制唤醒某个指定的线程

## 3.信号量Semaphore ##

操作系统中的信号量和此处的信号量是相同的,只不过此处的信号量是Java把操作系统原生的信号量封装了一下

信号量本质是一个"计数器",用于描述可用资源的个数

就相当于停车场的入口的显示牌,有多少个车位可用!如果车位满了,那么牌子就是显示可用为0.那么再想要停车,就只能换地方,或者等待.

围绕这个计数器有两个操作:

> P操作:申请一个可用资源,计数器就-1
> 
> V操作:释放一个可用资源,计数器就+1
> 
> P操作如果要是计数器为0了,继续P操作,就会阻塞等待
> 
> P操作使用acquire申请
> 
> V操作使用release释放

考虑一个计数初始值为1的信号量,针对这个值,只能有1和0两个取值,不会是负值.

> 如果执行P操作,1->0
> 
> 如果执行V操作,0->1
> 
> 如果进行一次P操作了,再进行一次P操作,就会阻塞等待
> 
> 那么根据这个特性我们很容易联想到锁(锁可以视为计数器为1的信号量,有两个取值,称为二元信号量)
> 
> 锁是信号量的一种特殊情况,信号量是锁的一般表达

实际开发中信号量也会用到,比如说,图书馆中有某本书有20本,那么就可以用初始值为20的信号量.借书就P操作,还书就V操作.如果书为0了,再P操作就会阻塞等待!

public static void main(String[] args) throws InterruptedException {
            Semaphore semaphore = new Semaphore(3);
            semaphore.acquire();
            System.out.println("第一次P操作");
    
            semaphore.acquire();
            System.out.println("第二次P操作");
    
            semaphore.acquire();
            System.out.println("第三次P操作");
    
            semaphore.acquire();
            System.out.println("第四次P操作");
        }

![1350775822a14545ba6c4b3ef06eace4.png][]

申请了3个可用资源,当申请第四个就会阻塞等待,等到别的线程调用release释放可用资源,才能停止阻塞

![8102458095d64ac197833ca072e5375f.png][]

无参版本是申请一个资源,带参数版本可以指定申请的资源数

代码中也可以使用Semaphore来实现类似于锁的功能,保证线程安全

## 4.CountDownLatch ##

同时等待 N 个任务执行结束

类似于跑步比赛，多个选手都就位，哨声响才同时出发,所有选手都通过终点，才公布成绩

跑步比赛开始时间都是相同的,但是结束时间是不明确的,为了衡量这个时间引入了CountDownLatch,主要提供了两个方法

> 1.await 方法,主线程来调用该方法,很多"a"为前缀的术语都表示异步.
> 
> 同步和异步是相对的,同步:发送请求方自己主动等待响应结果
> 
> 异步:发送请求方请求完就不管了,等有结果了,对方主动将结果推送出来
> 
> 2.countDown表示冲过了终点线.

CountDown在构造的时候,指定一个计数器(选手的个数).例如,指定了四个选手进行比赛,初始情况下,调用await,就会阻塞,每个选手冲过终点后都会调用countDown方法,前三次调用countDown,await没有任何影响,第四次调用countDown,await就会被唤醒,返回,解除阻塞,此时认为整个比赛结束!

在开发中CountDownLatch也有很多应用场景,比如下载一个大的文件.使用多线程下载,把一个大的文件切分成多个小块儿的文件,安排多个线程分别下载,多线程下载,不是充分利用了多核CPU,而是充分利用了带宽(下载是IO操作,与CPU关系不大),此处就可以用CountDownLatch来区分是不是整体都下载完了

## 5.多线程环境使用ArrayList ##

Java标准库中的大部分集合都是"线程不安全"的,多个线程使用同一个集合类对象,很可能会出现问题

Vector, Stack, HashTable, 这几个集合是线程安全的,关键方法带有synchronized

多线程环境使用ArrayList:

1.自己加锁,使用synchronized或者ReentrantLock

2.Collections.synchronizedList,可以使用这个方法把集合类套一层,这里会提供一些Array List相关的方法,同时是带锁的

3.CopyOnWriteArrayList

简称为"COW",即"写时拷贝",如果针对这个ArrayList进行读操作,不做任何额外的工作,如果进行写操作,则拷贝一份新的ArrayList,针对新的进行修改,修改过程中如果有读操作,就继续读旧的这份数据,当修改完毕了,使用新的替换旧的(本质上是一个引用之间的赋值,是原子的)

这种方案的优势很明显,就是不用加锁了,缺点也很明显,就是这个Array List不能太大了,只适用于这种数组比较小的情况下

### 热加载 ###

我们知道服务器程序的配置与维护是需要修改配置文件的,修改配置后就需要重启才能生效,但是重启操作成本比较高,重启过程中服务就中断了,用户发送的请求就没有响应了,产生的后果是很不好的,因此,很多服务器提供了"热加载"(reload)这样的功能

> "热加载"功能可以不重启服务器,实现服务器程序的配置的更新,热加载的实现就是用写时拷贝的思想,新的配置放到新的对象中,加载过程里,请求仍然基于旧的配置进行工作,当新的对象加载完毕,使用新的对象代替旧的对象(替换完成之后,旧的对象就可以释放了)

[2d8b044c9aa74626af93f6da7df31ef7.png]: https://img-blog.csdnimg.cn/img_convert/2d8b044c9aa74626af93f6da7df31ef7.png
[4beed12ae467463081a957696503fd6f.png]: https://img-blog.csdnimg.cn/4beed12ae467463081a957696503fd6f.png
[21376584e3d34a86b9524d6d1644f47a.png]: https://img-blog.csdnimg.cn/21376584e3d34a86b9524d6d1644f47a.png
[00b3956ed50e497a93142d0eaf1ee72f.png]: https://img-blog.csdnimg.cn/00b3956ed50e497a93142d0eaf1ee72f.png
[2dddff73adcf4c18bc8c0a0927ae4190.png]: https://img-blog.csdnimg.cn/2dddff73adcf4c18bc8c0a0927ae4190.png
[e3f7d073514f4998b207213d2e85727a.png]: https://img-blog.csdnimg.cn/e3f7d073514f4998b207213d2e85727a.png
[59cd695e9c8244f3947ef0210671a934.png]: https://img-blog.csdnimg.cn/59cd695e9c8244f3947ef0210671a934.png
[9bc08104ea5e42b28377dbf6a5f924b4.png]: https://img-blog.csdnimg.cn/9bc08104ea5e42b28377dbf6a5f924b4.png
[1350775822a14545ba6c4b3ef06eace4.png]: https://img-blog.csdnimg.cn/1350775822a14545ba6c4b3ef06eace4.png
[8102458095d64ac197833ca072e5375f.png]: https://img-blog.csdnimg.cn/8102458095d64ac197833ca072e5375f.png