初始JavaEE篇——多线程（8）：JUC的组件

找往期文章包罗但不限于本期文章中不懂的知识点：
   个人主页：我要学编程程(ಥ_ಥ)-CSDN博客
  所属专栏：JavaEE
  目次
Callable接口
ReentrantLock
synchronized 与 ReentrantLock的区别 
信号量（Semaphore）
CountDownLatch
多线程下使用ArrayList、哈希表

---

JUC 是值 java.util.current 包，如今我们要学习这些包中的一些常用的类。
Callable接口

Callable 接口与Runnable接口一样，都是用来包装使命的，只不外Callable接口有泛型参数且其方法有返回值，我们下面就来演示Callable接口的使用。
代码演示：

1. public class Test {
2.     private static int count = 0;
3.     public static void main(String[] args) throws InterruptedException {
4.         Callable<Integer> callable = new Callable<Integer>() {
5.             @Override
6.             public Integer call() throws Exception { // 这里面是任务与run方法类似
7.                 for (int i = 0; i < 10000; i++) {
8.                     count++;
9.                 }
10.                 return count;
11.             }
12.         };
14.         // 将任务进一步分装起来
15.         FutureTask<Integer> task = new FutureTask<>(callable);
17.         // 再将任务给到Thread
18.         Thread t = new Thread(task);
19.         t.start();
20.         t.join();
22.         System.out.println("count: "+ count);
23.     }
24. }

复制代码

下面是lambda表达式的写法：

1. public class Test {
2.     private static int count = 0;
3.     public static void main(String[] args) throws InterruptedException {
4.         // 使用lambda表达式代替匿名内部类
5.         FutureTask<Integer> task = new FutureTask<>(()->{
6.             for (int i = 0; i < 10000; i++) {
7.                 count++;
8.             }
9.             return count;
10.         });
12.         Thread t = new Thread(task);
13.         t.start();
14.         t.join();
16.         System.out.println("count: "+count);
17.     }
18. }

复制代码

上面是我们手动使 main线程壅闭期待 t线程实验完毕，我们还可以使用 FutureTask 中的get方法，从而去被动壅闭 main线程。

1. public class Test {
2.     private static Object locker = new Object();
3.     public static void main(String[] args) throws InterruptedException, ExecutionException {
4.         FutureTask<Integer> task = new FutureTask<>(()->{
5.            int sum = 0;
6.             for (int i = 1; i <= 1000; i++) {
7.                 sum += i;
8.             }
9.             return sum;
10.         });
12.         Thread t = new Thread(task);
13.         t.start();
14.         // 在调用get方法时，得到的是call方法的返回值，即主线程会阻塞等待t线程执行完call方法
15.         System.out.println(task.get());
16.     }
17. }

复制代码

总结：Callable 接口也是函数式接口，通过 call 方法来完成使命，终极的使命须要被 FutureTask进一步分装，从而给到Thread。
ReentrantLock

ReentrantLock是可重入互斥锁，和 synchronized 定位类似，都是用来实现互斥结果，包管线程安全。但是ReentrantLock 是Java尺度库提供的一个类，而不是关键字。
ReentrantLock 有三种方法：
1、lock()：加锁，如果获取不到锁就会不绝期待，也就是死等。
2、tryLock(超时时间，时间级别)：加锁，如果在超时时间之内没有获取到锁，也是不绝期待，但如果超出了超时时间的话，就会放弃期待。
3、unlock()：解锁。
代码演示：
1、lock—unlock方法的使用：

1. public class Test {
2.     private static int count = 0;
3.     public static void main(String[] args) throws InterruptedException {
4.         ReentrantLock reentrantLock = new ReentrantLock();
5.         Thread t1 = new Thread(()->{
6.             for (int i = 0; i < 100000; i++) {
7.                 reentrantLock.lock();
8.                 count++;
9.                 reentrantLock.unlock();
10.             }
11.         });
12.         Thread t2 = new Thread(()->{
13.             for (int i = 0; i < 100000; i++) {
14.                 reentrantLock.lock();
15.                 count++;
16.                 reentrantLock.unlock();
17.             }
18.         });
19.         t1.start();
20.         t2.start();
21.         t1.join();
22.         t2.join();
23.         System.out.println("count: "+count);
24.     }
25. }

复制代码

 2、tryLock方法的使用：

1. public class Test {
2.     public static void main(String[] args) throws InterruptedException {
3.         ReentrantLock reentranLock = new ReentrantLock();
4.         Thread t = new Thread(()->{
5.             try {
6.                 reentranLock.lock();
7.                 System.out.println("t线程开始");
8.                 Thread.sleep(3000);
9.                 System.out.println("t线程结束");
10.                 reentranLock.unlock();
11.             } catch (InterruptedException e) {
12.                 throw new RuntimeException(e);
13.             }
14.         });
15.         t.start();
16.         Thread.sleep(1000); // 确保t线程先加锁成功
17.         // 等待1s之后，就会不等了
18.         boolean state = reentranLock.tryLock(1000, TimeUnit.MILLISECONDS);
19.         if (state) {
20.             System.out.println("main线程成功获取锁");
21.             reentranLock.unlock();
22.         } else {
23.             System.out.println("main线程获取锁失败");
24.         }
25.         System.out.println("main线程结束");
26.     }
27. }

复制代码

运行结果：

tryLock另有一个重载的方法，是不带有任何参数的，其寄义是：实验去获取锁时，如果锁处于空闲状态就返回true，否则就返回false。这个是不会去期待的。 
synchronized 与 ReentrantLock的区别 

1、synchronized 是关键字，其底层的实现是JVM内部通过C++实现的，而 ReentrantLock 是尺度库中的类，是用Java实现的。
2、synchronized 是通过代码块来控制加锁与解锁的，而 ReentrantLock是通过lock 与 unlock 方法来控制加锁与解锁的，且肯定要记得及时去解锁。
3、ReentrantLock 除了寻常的加锁、解锁利用之外，还提供了 tryLock方法。不带参数的版本，就是直接去判定这个锁的状态，如果没有线程持有的话，就会举行加锁利用，然后返回true；反之，则会直接返回false，不会举行期待。而带有参数的版本就会期待对应的超时时间去实验获取锁，如果在超时时间之外了，就会直接返回false。
4、ReentrantLock 本身默认好坏公平锁，但是其提供了 公平锁的实现方式。
5、ReentrantLock搭配的期待关照机制，是Condition类，相比wait notify来说功能更强大一些，但是使用的方法是类似的。也是须要先加锁，然后再举行使用的。await 方法是可以更精准地叫醒期待的线程。在有多个期待线程的环境下，signal 可以选择叫醒特定的线程，而Object 类的notify方法在叫醒线程时是相对随机的。
代码演示：

1. public class Test {
2.     public static void main(String[] args) throws InterruptedException {
3.         // 下面的锁就是公平锁，是在参数内部传入一个true即可
4.         ReentrantLock reentrantLock = new ReentrantLock(true);
5.         Condition condition = reentrantLock.newCondition();
6.         Thread t1 = new Thread(()->{
7.             System.out.println("t线程开始执行");
8.             reentrantLock.lock();
9.             try {
10.                 System.out.println("t1线程即将被阻塞");
11.                 condition.await(); // 阻塞线程t1
12.                 System.out.println("t1线程被唤醒");
13.             } catch (InterruptedException e) {
14.                 throw new RuntimeException(e);
15.             }
16.             reentrantLock.unlock();
17.             System.out.println("t线程结束执行");
18.         });
19.         t1.start();
20.         Thread.sleep(1000); // 确保t1线程先加锁成功
22.         Thread t2 = new Thread(()->{
23.             System.out.println("t2线程开始执行");
24.             reentrantLock.lock();
25.             condition.signal(); // 唤醒正在处于阻塞状态的线程
26.             reentrantLock.unlock();
27.             System.out.println("t2线程结束执行");
28.         });
29.         t2.start();
30.         System.out.println("main线程结束");
31.     }
32. }

复制代码

信号量（Semaphore）

信号量重要用来调和历程与线程之间的资源分配。其底层是一个计数器，记载当前资源的可用个数。申请资源，对应的P利用，信号量会镌汰，开释资源，对应的V利用，信号量会增长。当信号量对应的计数器为0了，此时线程再去申请资源的话，就会线程壅闭。
在Java尺度库中，Semaphore 是对应的类。
代码演示：

1. public class Test {
2.     public static void main(String[] args) throws InterruptedException {
3.         // 通过参数指定“可用资源”的个数
4.         Semaphore semaphore = new Semaphore(5);
5.         System.out.println("可用资源的个数："+semaphore.availablePermits());
6.         // 获取资源
7.         for (int i = 0; i < 3; i++) {
8.             System.out.println("正在获取可用资源~");
9.             // 获取"可用资源"
10.             semaphore.acquire(); // 也可以传入参数来设定获取的个数，默认1
11.         }
12.         System.out.println("剩余可用资源的个数："+semaphore.availablePermits());
13.         // 释放资源
14.         for (int i = 0; i < 3; i++) {
15.             System.out.println("正在释放可用资源~");
16.             // 释放“可用资源”
17.             semaphore.release(); // 也可以传入参数来设定释放的个数，默认1
18.         }
19.         System.out.println("最终可用资源的个数："+semaphore.availablePermits());
20.     }
21. }

复制代码

运行结果：

留意：当信号量的初始容量为1时，此时就相当于是一把锁。 
CountDownLatch

当一个大的使命被分成多个小使命时，怎样知道全部的小使命全部实验完了呢？
1、可以使用 join 的寻常期待方法。
2、可以使用计数器来记载当前的完成使命的线程数。
而针对第二种方式，Java尺度库中给出了一个类：CountDownLatch。通过构造方法创建出多个使命，当与之对应的线程完成一个使命时，就可以调用 countDown方法来更新计数器的值，终极当计数器的值到达我们的预期时，便可以让主线程继承去实验别的的逻辑了。
代码实现：

1. public class Test {
2.     public static void main(String[] args) throws InterruptedException {
3.         int n = 3;
4.         CountDownLatch latch = new CountDownLatch(n); // 创建了初始值为n的计数器
5.         // 模拟下载的线程
6.         System.out.println("等待下载...");
7.         for (int i = 0; i < n; i++) {
8.             new Thread(() -> {
9.                 System.out.println("正在下载...");
10.                 try {
11.                     // 模拟下载过程
12.                     Thread.sleep(2000);
13.                 } catch (InterruptedException e) {
14.                     e.printStackTrace();
15.                 }
16.                 System.out.println("下载完成...");
17.                 latch.countDown(); // 更新计数器，计数器--
18.             }).start();
19.         }
20.         // 等待上述任务全部执行完毕，当计数器为0时，任务执行完毕，脱离阻塞。
21.         // 任务没有执行完成时，主线程会处于阻塞状态
22.         latch.await();
23.         System.out.println("下载完成，正在解压...");
24.         System.out.println("成功解压...");
25.     }
26. }

复制代码

多线程下使用ArrayList、哈希表

寻常的ArrayList是没有加锁的，那么在多线程的情境下使用，就会出现线程安全标题，而办理线程安全标题，有三种方法：
1、根据须要自行加锁。
2、无脑将全部的大概会出现线程安全标题的代码全部举行加锁。
3、CopyOnWriteArrayList。
第一二种方式都是接纳加锁利用，来确保线程安全。
代码演示：

1. public class Test {
2.     private static final Object locker = new Object();
3.     public static void main(String[] args) throws InterruptedException {
4.         ArrayList<Integer> arrayList = new ArrayList<>();
5.         Thread t1 = new Thread(()->{
6.             for (int i = 0; i < 100000; i++) {
7.                 synchronized (locker) {
8.                     arrayList.add(i);
9.                 }
10.             }
11.         });
12.         Thread t2 = new Thread(()->{
13.             for (int i = 0; i < 100000; i++) {
14.                 synchronized (locker) {
15.                     arrayList.add(i);
16.                 }
17.             }
18.         });
19.         t1.start();
20.         t2.start();
21.         t1.join();
22.         t2.join();
23.         System.out.println(arrayList.size());
24.     }
25. }

复制代码

上面这种方式就是按需加锁，只在出现线程安全标题的代码部分举行加锁利用，而不是对add这个方法举行无脑的加锁。 
第三种方式，接纳了写时拷贝的方法。当线程1在举行"写"利用时，如果线程2来举行"读"利用，这时就让线程2读取原来版本的数据，如许线程1在举行"写"利用时，就不会影响到线程2的"读"利用，也就不会造成线程不安全，那么也就没须要举行加锁利用，从而导致的步伐运行服从低沉。

缺陷：
1、当数据量过大时，拷贝的资本也就高了许多，如许终极的服从大概还不如加锁的利用呢。
2、当多个线程举行修改利用时，就不能包管线程安全了。由于多个线程举行修改利用，就会拷贝出多份数据，末了怎么归并呢？大概会出现覆盖的标题，其次这是并发实验，因此没发确定次序的先后，因此就导致了终极数据的不确定性。 
寻常的哈希表也是有线程安全标题的。Java尺度库中，给我们提供了两个类：Hashtable、ConcurrentHashMap。前者是对整个哈希表举行加锁利用，而后者是对哈希表的每个元素举行加锁利用。
不管是Java尺度库中的哈希表，还是我们之前手动实现的哈希表，针对哈希辩说的标题，我们接纳的都是数组+链表的方式，而不是去使用线性探测。而对于数组+链表这种方式，只有在同一个链表上面举行修改利用时，才会涉及线程安全标题，因此没须要对整个数组举行加锁。
ConcurrentHashMap相对于Hashtable有以下三个优化的地方：
1、针对数组的加锁利用，变成了对链表举行加锁利用；
2、使用原子类对size举行维护；
3、对于哈希扩容的标题，是分多次举行的，如许每一次所斲丧的时间就会比力少。比方，准备扩容时，就可以标记一下，比及下一次在举行put利用时，重新将这个元素地点原链表举行新的哈希映射，当每一个链表都修改完毕时，哈希表的扩容利用也就完成了。
好啦！本期 初始JavaEE篇——多线程（8）：JUC的组件 的学习之旅就到此竣事啦！我们下一期再一起学习吧！

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！qidao123.com:ToB企服之家，中国第一个企服评测及软件市场,开放入驻,技术点评得现金