【JavaEE初阶系列】——一万字带你了解 JUC常见类以及线程安全集合类(哈希表）-CSDN博客

本文链接：https://blog.csdn.net/m0_74438843/article/details/137285222

🚩JUC(java.util.concurrent) 的常见类

🎈 ReentrantLock可重入锁

🌈ReentrantLock和synchronized区别：

🎈CountDownLatch任务进度

🚩JUC(java.util.concurrent) 的常见类

🎈Callable 接口

Callable 是一个 interface . 相当于把线程封装了一个 " 返回值 ". 方便程序猿借助多线程的方式计算结果。Runnable不在意结果，而Callable接口，创建线程，可直接返回结果。

代码示例: 创建线程计算 1 + 2 + 3 + ... + 1000, 不使用 Callable 版本

创建一个类 Result , 包含一个 sum 表示最终结果, lock 表示线程同步使用的锁对象.
main 方法中先创建 Result 实例, 然后创建一个线程 t. 在线程内部计算 1 + 2 + 3 + ... + 1000.
主线程同时使用 wait 等待线程 t 计算结束. (注意, 如果执行到 wait 之前, 线程 t 已经计算完了, 就不必等待了).
当线程 t 计算完毕后, 通过 notify 唤醒主线程, 主线程再打印结果

//实现1+2+3.。。+1000
class Result{
    public  int sum;//创建
    public Object lock=new Object();
}
public class Test2 {
    public static void main(String[] args) throws InterruptedException {
        Result result=new Result();//创建对象实例
        Thread thread=new Thread(new Runnable() {
            @Override
            public void run() {
                int sum=0;
                for (int i = 1; i <=1000 ; i++) {
                    sum+=i;
                }
                synchronized (result.lock){
                    result.sum=sum;//将结果赋值给result类中sum
                    result.lock.notify();//然后唤醒
                }
            }
        });
        thread.start();
        synchronized (result.lock)
        {
            while (result.sum==0){
                result.lock.wait();//如果sum里的值一直是0，那么就一直等待
            }
            System.out.println(result.sum);//之后唤醒之后，就打印sum的值。
        }
    }
}

可以看到 , 上述代码需要一个辅助类 Result, 还需要使用一系列的加锁和 wait notify 操作 , 代码复

杂 , 容易出错 .

代码示例: 创建线程计算 1 + 2 + 3 + ... + 1000, 使用 Callable 版本

创建一个匿名内部类, 实现 Callable 接口. Callable 带有泛型参数. 泛型参数表示返回值的类型.
重写 Callable 的 call 方法, 完成累加的过程. 直接通过返回值返回计算结果.
把 callable 实例使用 FutureTask 包装一下.
创建线程, 线程的构造方法传入 FutureTask . 此时新线程就会执行 FutureTask 内部的 Callable 的 call 方法, 完成计算. 计算结果就放到了 FutureTask 对象中.
在主线程中调用 futureTask.get() 能够阻塞等待新线程计算完毕. 并获取到 FutureTask 中的结果.

package Java_improvr;

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

public class Callable_test2 {
    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<Integer>futureTask=new FutureTask<>(callable);
        Thread thread=new Thread(futureTask);
        thread.start();
        System.out.println(futureTask.get());
此处的get就能获取到Callable里面的返回结果，由于线程是并发执行的，
执行到主线程的get的时候，t线程可能还没执行完，没执行完的话，get就会阻塞。
    }
}

可以看到, 使用 Callable 和 FutureTask 之后, 代码简化了很多, 也不必手动写线程同步代码了

🌈理解 Callable(相关面试题)

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

Callable 通常需要搭配 FutureTask 来使用. FutureTask 用来保存 Callable 的返回结果. 因为 Callable 往往是在另一个线程中执行的, 啥时候执行完并不确定.

FutureTask 就可以负责这个等待结果出来的工作.FutureTask对象就是放在线程中等待线程执行完后，调用get方法就得到了返回值。

🌈理解 FutureTask

想象去吃麻辣烫. 当餐点好后, 后厨就开始做了. 同时前台会给你一张 "小票" . 这个小票就是

FutureTask. 后面我们可以随时凭这张小票去查看自己的这份麻辣烫做出来了没.做出来了get方法调用成功然后菜就出来了，如果没做出了，get方法就等待线程完成，直到出来后，就返回值。

📝线程创建方式

继承Thread，重写run(创建单独的类，也可以匿名内部类)
实现Runnable，重写run(创建单独的类，也可以匿名内部类)
实现Callable，重写call(创建单独的类，也可以匿名内部类)
实现lambda表达式
ThreadFactory线程工厂
线程池

🎈 ReentrantLock可重入锁

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

ReentrantLock 也是可重入锁. "Reentrant" 这个单词的原意就是 "可重入"

ReentrantLock 的用法:

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

ReentrantLock lock = new ReentrantLock(); 
-----------------------------------------
lock.lock();   
try {    
 // working    
} finally {    
 lock.unlock()    
}

我们之前学到try()..catch()..，如果加上finally的话，finally是肯定会被调用的，一般用于释放或者释放锁的作用，所以finally的话是肯定会执行到的代码。

🌈ReentrantLock 优势：

ReentrantLock，在加锁的时候，有俩种方式，lock,trylock
ReentrantLock提供了公平锁的实现（默认情况下是非公平锁）
ReentrantLock提供了更强大的等待通知机制，搭配了Condition类，实现等待通知的。

虽然ReentrantLock有上述的优势，但是咱们在加锁的时候，还是首选synchronized（而且synchronized背后还有一系列的优化手段，锁升级，锁粗化，锁消除），ReentrantLock使用更加的复杂，尤其是容易忘记解锁。

🌈ReentrantLock和synchronized区别：

库的一个类, 在 JVM 外实现的(基于 Java 实现). synchronized 使用时不需要手动释放锁. ReentrantLock 使用时需要手动释放. 使用起来更灵活, 但是也容易遗漏 unlock.
synchronized 在申请锁失败时, 会死等. ReentrantLock 可以通过 trylock 的方式等待一段时间就放弃.(trylock没有加锁就直接放弃，给了更多可操作的空间，放弃申请锁之后就可以做其他的事情。)
synchronized 是非公平锁, ReentrantLock 默认是非公平锁. 可以通过构造方法传入一个 true 开启公平锁模式。
// ReentrantLock 的构造方法
public ReentrantLock(boolean fair) {
    sync = fair ? new FairSync() : new NonfairSync();
}
更强大的唤醒机制. synchronized 是通过 Object 的 wait / notify 实现等待-唤醒. 每次唤醒的是一个随机等待的线程. ReentrantLock 搭配 Condition 类实现等待-唤醒, 可以更精确控制唤醒某个指定的线程.(在多线程中等待的情况下，synchronized唤醒的是随机等待的线程，而ReentrantLock则唤醒的是指定的线程）。

如何选择使用哪个锁?

锁竞争不激烈的时候, 使用 synchronized, 效率更高, 自动释放更方便.
锁竞争激烈的时候, 使用 ReentrantLock, 搭配 trylock 更灵活控制加锁的行为, 而不是死等.
如果需要使用公平锁, 使用 ReentrantLock.

🎈原子类

在Java中，在java.util.Atomic包下有个，原子类（Atomic classes）是一组类，用于在多线程环境中进行原子操作。原子操作是不可分割的操作，可以看作是一组指令的执行过程中不会被中断的操作。原子类提供了一种线程安全的方式来执行诸如读取、写入和更新变量等操作，而无需显式地使用锁或同步块来保护数据。

Java中的原子类位于java.util.concurrent.atomic包中，主要有以下几个常见的原子类：

AtomicBoolean: 提供了对boolean类型变量的原子操作。
AtomicInteger: 提供了对int类型变量的原子操作。
AtomicLong: 提供了对long类型变量的原子操作。
AtomicReference: 提供了对引用类型变量的原子操作。
AtomicIntegerArray: 提供了对int类型数组的原子操作。
AtomicLongArray: 提供了对long类型数组的原子操作。
AtomicReferenceArray: 提供了对引用类型数组的原子操作。

这些原子类通过使用底层的CAS（Compare-And-Swap）操作来实现原子性。CAS是一种乐观锁的机制，它在操作之前先比较内存中的值是否与预期值相等，如果相等，则执行操作，否则放弃操作。CAS操作是一种非阻塞算法，因此在高并发情况下性能通常比传统的基于锁的同步方式更好。

以 AtomicInteger类举例，常见方法有

public class Test5 {
    public static AtomicInteger count=new AtomicInteger(0);//对int类型封装
    public static void main(String[] args) {
        count.addAndGet(1); //0+1=1         i+=delta
        System.out.println(count);
        count.decrementAndGet(); //--1=0 count=0  --i
        System.out.println(count);
        count.getAndIncrement(); //0++=0 count=1  i++
        System.out.println(count);
        count.incrementAndGet(); //++1=2          ++i
        System.out.println(count);
        count.getAndDecrement(); //2--=2 count=1  i--
        System.out.println(count);
    }
}

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

在多线程情况下，进行i++操作。这样就避免了加锁，底层用的是CAS。

package Java_improvr;

import java.util.concurrent.atomic.AtomicInteger;

public class Test1 {
    public static AtomicInteger count=new AtomicInteger(0);//对int类型封装
    public static void main(String[] args) throws InterruptedException {
        Thread t1=new Thread(()->{
            for (int i = 0; i < 50000; i++) {
                count.getAndIncrement();
            }
        });

        Thread t2=new Thread(()->{
            for (int i = 0; i < 50000; i++) {
                count.getAndIncrement();
            }
        });
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        System.out.println(count.get());
    }
}

🎈信号量 Semaphore

信号量 , 用来表示 "可用资源的个数". 本质上就是一个计数器 .

理解信号量

可以把信号量想象成是停车场的展示牌，当前有车位100个，表示有100个可用资源。

当有车开进去的时候，就相当于申请一个可用资源，可用车位就-1 （这个称为信号量的P操作)
当有车开出去的时候，就相当于释放一个可用资源，可用车位就+1 (这个称为信号量的V操作）

如果计数器的值已经为0了，还尝试申请资源，就会阻塞等待，直到有其他线程释放资源。
public class Test6 {
    public static void main(String[] args) throws InterruptedException {
        Semaphore semaphore=new Semaphore(4);//申请了4个资源
       semaphore.acquire();
        System.out.println("P操作");
        semaphore.acquire();
        System.out.println("P操作");
        semaphore.acquire();
        System.out.println("P操作");
        semaphore.acquire();
        System.out.println("P操作");
        semaphore.acquire();
        System.out.println("P操作");
    }
}
这样我们就会让我们想到锁。
锁就是可用资源为1的信号量。(二元信号量）

加锁操作，P操作，1->0
解锁操作，V操作，0->1

操作系统，提供了信号量实现，提供了api，JVM封装了这样的api，就可以在java代码中使用了。

🌈信号量代码示例

创建 Semaphore 示例, 初始化为 4, 表示有 4 个可用资源.
acquire 方法表示申请资源(P操作), release 方法表示释放资源(V操作)
创建 20 个线程, 每个线程都尝试申请资源, sleep 1秒之后, 释放资源. 观察程序的执行效果

package Java_improvr;

import java.util.concurrent.Semaphore;

public class Test6 {
    public static void main(String[] args) {
        Semaphore semaphore=new Semaphore(4);//申请了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){
                    e.printStackTrace();
                }
            }
        };
        for (int i = 0; i <20 ; i++) {
            Thread t=new Thread(runnable);
            t.start();
        }
    }
}

🎈CountDownLatch任务进度

同时等待 N 个任务执行。适用于，多个线程来完成一系列任务的时候，用来衡量任务的进度是否完成，比如需要把一个大的任务，拆分成多个小的任务，让这些任务并发的去执行。

就可以使用countDownLatch来判定说当前这些任务是否全都完成了。

比如说下载一个文件，就可以使用多线程下载。很多下载工具，下载速度，很一般，相比之下，有些专业的下载工具，就可以成倍的提升下载速度(IDM),多线程下载，(往往和资源服务器只有一个连接，服务器往往会对于连接传输的速度有限制），每个线程都建立一个连接，此时就需要把任务进行分割。

countDownLatch主要有俩个方法：

1.await，调用的时候就会阻塞，就会等待其他的线程完成任务，所有的线程都完成了任务之后，此时这个await才会返回，才会继续往下走。
2.countDown，告诉countDownatch，我当前这一个子任务已经完成了。

await代表所有任务完成，countDown代表分割成的小任务完成。
public class Test7 {
    public static void main(String[] args) throws InterruptedException {
        //10个选手参赛，await就会在10次调用完countDown之后才能继续执行
        CountDownLatch latch=new CountDownLatch(10);
        for (int i = 0; i < 10; i++) {
            int id=i;
            Thread t=new Thread(()->{
                System.out.println("thread"+id);
                latch.countDown();//代表一个小任务完成
            });
            t.start();
        }
        latch.await();//代表所有任务都完成
        System.out.println("await调用了代表所有任务都完成了");
    }
}
每个任务完成得顺序是随机得，就像10个选手参赛，选手就是线程，每个人得成绩都是不一样得，有先后区分。等到所有得选手都参赛完了后，就调用await方法。

🎈相关面试题

1) 线程同步的方式有哪些？

synchronized(锁), ReentrantLock(可重入锁), Semaphore(信号量) 等都可以用于线程同步.

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

以 juc 的 ReentrantLock 为例,

synchronized不用手动得释放锁，而ReentranLock需要手动得调用unlock释放锁，容易忽略。
synchronized申请锁失败后，就会死等，而ReentranLock可以通过trylock方式等待一段时间就会自动放弃。
synchronized是非公平锁，ReentranLock默认是非公平锁，可以通过构造方法传入一个true开启公平锁模式
synchronized搭配得wait/notify实现等待-唤醒线程，每次唤醒的是一个随机等待的线程。ReentranLock搭配的Condition类实现等待-唤醒，可以更精准控制唤醒某个指定的线程。

3) AtomicInteger 的实现原理是什么？

基于 CAS 机制. 伪代码如下

class AtomicInteger {
private int value;
public int getAndIncrement() {
     int oldValue = value;
     while ( CAS(value, oldValue, oldValue+1) != true) {
         oldValue = value;
     }
     return oldValue;
 }
}

4) 信号量听说过么？之前都用在过哪些场景下？

信号量"用来表示资源的个数",本质上是个计数器。

使用信号量可以实现"共享锁",比如某个资源允许3个线程同时使用，那么就可以使用P操作作为加锁，V操作作为解锁，前三个线程的P操作都能顺序返回，后续线程再进行P操作就会阻塞等待，直到前面的线程执行了V操作。

🚩线程安全的集合类

原来的集合类 , 大部分都不是线程安全的 .

Vector, Stack, HashTable, 是线程安全的(不建议用), 其他的集合类不是线程安全的.

针对这些线程不安全的集合类，要想在多线程环境下使用，就需要考虑好，线程安全问题了。

🎈多线程环境使用 ArrayList

1) Collections.synchronizedList(new ArrayList);

synchronizedList 是标准库提供的一个基于 synchronized 进行线程同步的 List.

synchronizedList 的关键操作上都带有 synchronized.

这个操作会返回新的对象，这个新的对象就相当于给ArrayList套了一层壳，这层壳就是在方法上直接使用synchronized的。

2) 使用 CopyOnWriteArrayList

写时拷贝，比如俩个线程使用同一个ArrayList，可能会读，也可能会修改。

如果要是俩个线程读，就直接读就好了，

如果某个线程需要修改，就把ArrayList复制出一份副本，就修改这个副本，与此同时，另一个线程仍然可以读取数据（从原来的数据上进行读取）一旦这边修改完毕，就会使用修改好的这份数据，替代掉原来的数据（往往就是一个引用赋值）

CopyOnWrite容器即写时复制的容器。

当我们往一个容器添加元素的时候，不直接往当前容器添加，而是先将当前容器进行Copy，复制出一个新的容器，然后新的容器里添加元素，
添加完元素之后，再将原容器的引用指向新的容器

这样做的好处是我们可以对CopyOnWrite容器进行并发的读，而不需要加锁，因为当前容器不会添加任何元素。

所以CopyOnWrite容器也是一种读写分离的思想，读和写不同的容器。

优点:

在读多写少的场景下, 性能很高, 不需要加锁竞争.

缺点:

1. 占用内存较多.

2. 新写的数据不能被第一时间读取到.

其实这种场景特别适合于服务器的配置更新，可以通过配置文件，来描述配置的详细内容（本身就不会很大）配置的内容会被读到内存中，再由其他线程，读取到这里的内容，但是修改这个配置内容，往往只有一个线程去修改，使用某个命令让服务器重新加载配置，就可以使用写时拷贝的方式了。

🎈多线程环境使用哈希表

HashMap 本身不是线程安全的 .

在多线程环境下使用哈希表可以使用 :

Hashtable
ConcurrentHashMap

Hashtable保证线程安全，主要就是给关键方法，加上synchronized，直接加到方法上的（相当于给this加锁），只要俩个线程，在操作同一个Hashtable就会出现锁冲突。

俩个不同key映射到同一个数组下标上，就会出现hash冲突，使用链表来解决hash冲突。

按照上述这样的方式来操作，并且在不考虑触发扩容的前提下，操作不同的链表的时候就是线程安全的，相比之下，如果俩个线程，操作的是同一个链表，才比较会出现问题。（就像之前说的，多线程对同一个变量进行修改，会出现线程安全问题）。

1》ConcurrentHashMap最核心的改进，就是把一个大局的大锁，改进成每个链表独立的一把小锁，这样做，大幅度的降低了锁冲突的概率。大锁-》小锁

如果一个大锁，当很多线程进行插入到哈希表的时候，此时每个线程都得等待前一个线程进入并且插入完成后，然后下一个线程进入，这就是造成了阻塞等待的状况。其实一个hash表中有很多这样的链表，俩个线程恰好同时访问同一个链表的情况，本身就很少。所以我们就想到
将一个大局的大锁，改进成每个链表独立的一把小锁，锁对象就是链表的头结点。遇到访问不同的链表的时候，是不产生锁冲突的，遇到访问同一个链表，会阻塞等待，但是比大锁更高效，因为这样其他所有的线程都被阻塞了，而小锁会避免不必要的锁冲突。

分段锁：java8之前 ConcurrentHashMap就是基于分段锁(多个链表公用一把锁）的方式实现的。等到java8开始之后，就成了直接在链表头结点加锁的形式。

2》充分利用到了CAS特性，把一些不必要的加锁环节省略加锁了

比如：需要使用变量记录hash表中的元素个数，此时，就可以使用原子操作（CAS）修改元素个数。

3》ConcurrentHashMap还有一些激进的操作，针对读操作没有加锁。读和读之间，读和写之间，都不会有锁竞争。

写和写之间还是要加锁的。

4》ConcurrentHashMap 针对扩容操作，做出了单独的优化

本身Hashtable或者HashMap 在扩容的时候，都是需要把所有的元素都拷贝一遍的（如果元素很多，拷贝的就比较耗时）

用户访问100次，99次都很流畅，其中一次卡了(正好触发了扩容的机制，导致了出现卡顿）

化整为零。一旦需要扩容，确实需要搬运，不是在一次操作中搬运完成，而是分成多次来搬运，每次只搬运一部分数据，避免这单次操作过去卡顿。