【十四】一文带你了解下JUC中的常见组件

最新推荐文章于 2024-04-29 02:55:00 发布

一个想打拳的程序员

最新推荐文章于 2024-04-29 02:55:00 发布

阅读量281

点赞数 1

分类专栏：多线程文章标签： java 开发语言

本文链接：https://blog.csdn.net/hero_jy/article/details/129896085

版权

多线程专栏收录该内容

15 篇文章 0 订阅

订阅专栏

1. Callable的用法

Callable的用法非常类似于 Runnable，描述了一个任务，一个线程要干什么

Runnable 是通过 run 方法进行描述，返回值类型 void
Callable 是通过 call 方法进行描述，是有返回值的

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

在这里插入图片描述

2. ReentrantLock

可重入互斥锁. 和 synchronized 定位类似, 都是用来实现互斥效果, 保证线程安全.

ReentrantLock的用法：

lock()：加锁，获取不到锁就死等
trylock()：加锁，获取不到锁，就等待一段时间，放弃加锁，不会阻塞
unlock()：解锁

在大部分情况下，使用 synchronized 就足够了，但是可能也会需要用 ReentrantLock，接下来介绍下两者的一些区别（三个方面）

synchronized 只是加锁和解锁，加锁的时候如果发现锁被占用，只能阻塞等待！
ReentrantLock 额外提供了 trylock 方法，可以加锁失败后，直接返回false,不会阻塞等待
synchronized 是非公平锁（概率均等，不遵循先来后到）
ReentrantLock 提供了公平和非公平两种工作模式（在构造方法中，传入 true 开启公平锁）
synchronized 搭配 wait notify 进行等待交换，如果多个线程 wait 同一个对象，notify 的时候是随机唤醒一个
ReentrantLock 则是搭配 Condition 这个类，这个类也能起到等待通知，可以功能更强大

3. 原子类

不懂CAS ，可以参考此篇博客 ------> CAS
原子类的内部用的是 CAS 实现的，性能会比加锁实现的 i++ 高很多，原子类有以下几个

AtomicBoolean
AtomicInteger
AtomicIntegerArray
AtomicLong
AtomicReference
AtomicStampedReference

以 AtomicInteger 为例，常见的方法有以下

addAndGet(int delta);   i+=delta
decrementAndGet();      --i
getAndDecrement();      i--
incrementAndGet();      ++i
getAndIncrement();      i++

4. 线程池

可以参考之前博客—> 线程池的介绍

5. 信号量 semaphore

信号量, 用来表示 “可用资源的个数”. 本质上就是一个计数器.
P操作：申请资源，计数器 -1
V操作：释放资源，计数器 +1
如果计数器已经是0，继续申请资源，就会阻塞等待！

其实所谓的 ”锁“，本质上是计数器为1 的信号量，取值只有 1 和 0 两种，也叫做二元信号量

public class Demo29 {
    public static void main(String[] args) {
        Semaphore semaphore = new Semaphore(4);
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                try {
                    System.out.println("申请资源");
                    semaphore.acquire();
                    System.out.println("获取到资源");
                    Thread.sleep(1000);
                    System.out.println("释放资源");
                    semaphore.release();
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        };
        for (int i = 0; i <4; i++) {
            Thread t = new Thread(runnable);
            t.start();
        }
    }
}

6. CountDownLatch

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

可以举一个例子：在日常生活中，假设我们下载一部电影，有10个G，此时我们如果要进行多线程下载。由于文件太大，把这个文件分成10份，每个线程负责下载其中一份！
此时只有，多个线程下载完对应的资源，此时才算下载完毕

构造 CountDownLatch 实例, 初始化 10 表示有 10 个任务需要完成.
主线程调用一个 CountDownLatch.await方法，来阻塞等待所有任务完成
10个线程每一个执行完任务以后，都会调用 CountDownLatch.coutDown方法
只有当 10个任务都调用过 CountDownLatch，主线程的 await 就阻塞解除

public class Demo {
    public static void main(String[] args) throws Exception {
        CountDownLatch latch = new CountDownLatch(10);
        Runnable r = new Runable() {
            @Override
            public void run() {
                try {
                    Thread.sleep(Math.random() * 10000);
                    latch.countDown();
               } catch (Exception e) {
                    e.printStackTrace();
               }
           }
       };
        for (int i = 0; i < 10; i++) {
            new Thread(r).start();
       }
   // 必须等到 10 人全部回来
        latch.await();
        System.out.println("比赛结束");
    }
}

7. JUC 中的一些线程安全集合类

Vector、Stack、HashTable是线程安全
ArrayList、LinkedList、HashMap、PriorityQueue…线程不安全，如果在多线程的环境下使用，就可能会出现问题！

7.1 多线程使用 ArrayList

可以自己使用 synchronized 或者 ReentrantLock 进行加锁

使用Collections.synchronizedList(new ArrayList);
synchronizedList 是标准库提供的一个基于 synchronized 进行线程同步的 List.
synchronizedList 的关键操作上都带有 synchronized

CopyOnWriteArrayList 支持 ”写时拷贝“ 集合类~~
线程安全是多个线程修改不同的变量
当线程去修改一个容器的元素时候，并不是直接操作，而是额外拷贝一份，进行操作，然后将引用指向新的容器
优点：在读多写少的情况下，性能很高，不需要加锁竞争
缺点：占用内存大，新写的数据不一定能第一时间读取到

7.2 多线程使用队列

ArrayBlockingQueue ：基于数组实现的阻塞队列
LinkedBlockingQueue：基于链表实现的阻塞队列
PriorityBlockingQueue：基于堆实现的带优先级的阻塞队列
TransferQueue：最多只包含一个元素的阻塞队列

7.3 多线程使用哈希表（JDK1.8）

HashMap 本身不是线程安全的

加锁的粒度不同，触发锁冲突频率不同
HashTable：线程安全的，也是给关键方法，加上 synchronized

HashTable 是针对整个哈希表进行加锁，任何的增删改查操作，都会触发加锁，也都会可能会锁竞争。

ConcurrentHashMap则很好解决了上问题

简单用一个伪代码表示下

void put(String key , String value){
	// 先找到头节点
	int index = hashCode(key);
	Node head = getHead(index);
	synchronized(head){
		//执行链表插入节点操作
	}
}

其他方面的改进

更充分的利用了 CAS 机制，例如获取元素和更新元素个数，就可以使用CAS完成，不必加锁了~
优化了扩容策略：
- 对于HashTable,如果元素太多，就会涉及到扩容，扩容需要重新申请空间+搬运元素（把元素从旧的哈希表上删掉，插入到新的哈希表上），如果元素个数非常多，成本就会很高
- 对于 ConcurrentHashMap ，需要进行扩容，并不会试图一次性搬运过去。而是创建一个新的哈希表，每次只搬运一小部分。后续操作，插入实在新的哈希表，删除是在旧的哈希表，而且每次操作都会搬运一小部分；这个期间，查找需要同时查新哈希表和老哈希表