【Java之多线程】JUC常见知识点全面总结_juc 考点

2401_84247617

于 2024-04-28 20:37:53 发布

阅读量305

点赞数 5

分类专栏：程序员文章标签： java 开发语言

本文链接：https://blog.csdn.net/2401_84247617/article/details/138290542

版权

程序员专栏收录该内容

218 篇文章 0 订阅

订阅专栏

+ [2. 引入线程池的好处](#2__169)
+ [3. 创建线程池的方法](#3__173)
+ - [（1）ThreadPoolExecutor](#1ThreadPoolExecutor_174)
	- [（2） Executors](#2_Executors_180)

四. 信号量Semaphore
- 1. 定义
  - 2. 作用
  - 3. 用法示例
五. CountDownLatch
- 1. 理解
  - 2. 用法
六. 高频面试题
- 1. 进程间通信有哪几种方式

一. ReentrantLock

1. 理解

之前我们讨论的可重入锁，翻译成英文就是ReentrantLock，大部分情况下这个英文单词要理解成这一锁特性，但少数情况下要理解成一个类
和 synchronized 定位类似，都是用来实现互斥效果，用来保证线程安全，同时这个锁是可重入的

2. 用法

下面我们来看一段代码实现两个线程分别对一个变量count累加操作：

public class Test {
    static class Counter{
        public int count=0;
        public void increase(){
            count++;
        }
    }

    public static void main(String[] args) {
        Counter counter=new Counter();
        Thread t1 = new Thread() {
            @Override
            public void run() {
                for (int i = 0; i < 50000; i++) {
                    counter.increase();
                }
            }
        };
        Thread t2 = new Thread() {
            @Override
            public void run() {
                for (int i = 0; i < 50000; i++) {
                    counter.increase();
                }
            }
        };
        t1.start();
        t2.start();

        try {
            t1.join();
            t2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(counter.count);
    }
}

经过之前的学习，我们认为此方法打印count是线程不安全的，不会每次都很准确地打印10000：
第一次运行
在这里插入图片描述
第二次运行

之前我们学过的解决方法是使用synchronized保证线程的安全性，代码如下：

static class Counter{
        public int count=0;
        synchronized public void increase(){
            count++;
        }
    }

改动部分如上图所示（其他部分一样），打印结果如下：在这里插入图片描述
但此时我们可以通过创建ReentrantLock这一对象对其实现加锁，完整代码如下：

import java.util.concurrent.locks.ReentrantLock;

public class Test {
    static class Counter {
        public int count;
        public ReentrantLock locker = new ReentrantLock();

        public void increase() {
            locker.lock();
            count++;
            locker.unlock();

        }
    }
    public static void main(String[] args) {
        Counter counter=new Counter();
        Thread t1 = new Thread() {
            @Override
            public void run() {
                for (int i = 0; i < 50000; i++) {
                    counter.increase();
                }
            }
        };
        Thread t2 = new Thread() {
            @Override
            public void run() {
                for (int i = 0; i < 50000; i++) {
                    counter.increase();
                }
            }
        };
        t1.start();
        t2.start();

        try {
            t1.join();
            t2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(counter.count);
    }
}

打印结果如下：
在这里插入图片描述

3. 与synchronized区别

那么，与synchronized同样都能对其实现加锁功能，这两者有什么区别呢？

ReentrantLock把加锁和解锁拆成了两个方法，确实存在遗忘解锁的风险，但可以让代码变得更加灵活，可以把加锁和解锁的代码分别放到两个方法之中
synchronized在申请锁失败时，代码会死等。而ReentrantLock 可以通过trylock这个方法等待一段时间就放弃，不会浪费时间
synchronized是非公平锁，而ReentrantLock默认是非公平锁。但可以通过构造方法传入一个 true 开启公平锁模式
ReentrantLock 有更强大的唤醒机制，synchronized 是通过 Object 的 wait / notify 方法实现等待唤醒过程的，每次唤醒的是一个随机等待的线程。而ReentrantLock搭配 Condition 类实现等待-唤醒，可以更精确控制唤醒某个指定的线程。

4. 总结

大部分情况下使用 synchronized就足够了
锁竞争激烈的时候，使用ReentrantLock , 搭配 trylock 方法可以更灵活地控制加锁的行为，而不是死等。
如果需要使用公平锁, 使用 ReentrantLock

二. 原子类

1. 理解

保证线程安全不一定非得加锁，当然也可以用原子类，从java1.5开始，jdk提供了java.util.concurrent.atomic包，这个包内包含一系列的原子操作类，提供了一种用法简单，性能高效，线程安全的更新一个变量的方式。其内部通常以CAS方式实现，因此性能通常比加锁实现i++要高很多，具体使用方法如下（上述例子）

  public AtomicInteger count = new AtomicInteger(0);

        public void increase() {
            count.getAndIncrement();
        }

这里只展示改动后的代码，其打印结果如下：
在这里插入图片描述

2. 常见的原子类

AtomicBoolean
AtomicInteger
AtomicIntegerArray
AtomicLong
AtomicReference
AtomicStampedReference

3. 常见的方法

以 AtomicInteger 举例，常见方法有

addAndGet(int delta); 相当于 i += delta;
decrementAndGet(); 相当于–i;
getAndDecrement(); 相当于i–;
incrementAndGet(); 相当于++i;
getAndIncrement(); 相当于i++;

在这里插入图片描述

三. 线程池

1. 为什么要引入线程池

解决并发编程的方案一般是靠多进程的，但是进程开销的资源是非常大的，因此我们进一步地引入了多线程。虽然创建销毁线程比创建销毁进程看起来似乎更轻量了，但是在频繁创建毁线程的时还是会比较低效。线程池就是为了解决这个问题。如果某个线程不再使用了，并不是真正把线程释放，而是放到一个 "池子"中。当我们需要使用多线程的时候，直接从之前创建好的池子中取出一个就行了，当我们不用的时候，直接把这个线程放回池子中即可。

2. 引入线程池的好处

当我们不用线程池的时候，频繁地创建或者销毁线程涉及到用户态和内核态的来回切换，从用户态切换到内核态会创建出对应的PCB（进程控制块，英文是Processing Control Block），这样会消耗大量的系统资源，而且效率还会比较低。
当我们引入线程池后，相当于只在用户态完成各种操作，这样代码执行效率和系统开销会大大优化

3. 创建线程池的方法

（1）ThreadPoolExecutor

使用Java标准库中的ThreadPoolExecutor方式创建，但需注意里面各自的参数代表的含义，使用起来相对而言比较复杂。
构造方法
在这里插入图片描述
为了更好地理解每个参数的具体含义，大家可以利用空闲时间去jdk的官方文档学习学习，对自己是非常有帮助的：

（2） Executors

使用 Executors 这个类创建，这个类相当于一个工厂类，通过这个工厂类中的一些方法，就可以创建出不同风格的线程池实例了。
部分方法

Executors.newFixedThreadPool：创建一个固定大小的线程池
Executors.newCachedThreadPool：创建一个可缓存的线程池，若线程数超过处理所需，缓存一段时间后会回收，若线程数不够，则新建线程。
Executors.newSingleThreadExecutor：创建出只包含一个线程数的线程池，它可以保证先进先出的执行顺序。
Executors.newScheduledThreadPool：创建一个可以执行延迟任务的线程池（放入的任务能够过一会再执行）
Executors.newSingleThreadScheduledExecutor：创建出具有一个单线程并且可以执行延迟任务的线程池

用法示例：

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class Test {
    public static void main(String[] args) {
        ExecutorService service = Executors.newFixedThreadPool(10);
        for (int i = 0; i < 20; i++) {
            service.submit(new Runnable() {
                @Override
                public void run() {
                    System.out.println("hello");
                }
            });
        }
    }
}

运行结果：
在这里插入图片描述