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

最新推荐文章于 2024-07-12 15:51:39 发布

2401_84264536

最新推荐文章于 2024-07-12 15:51:39 发布

阅读量926

点赞数 13

文章标签： java 开发语言

本文链接：https://blog.csdn.net/2401_84264536/article/details/139944493

版权

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：  
 **第一次运行**  
 ![在这里插入图片描述](https://img-blog.csdnimg.cn/4b4e966c53de47b2820b40189c2026ad.png)  
 **第二次运行**  
 ![在这里插入图片描述](https://img-blog.csdnimg.cn/ddfcc5369ced431bb7caafbc9aa8477b.png)  
 之前我们学过的解决方法是使用`synchronized`保证线程的安全性，代码如下：

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


改动部分如上图所示（其他部分一样），打印结果如下：![在这里插入图片描述](https://img-blog.csdnimg.cn/a29854147b724855b761c73a06cdfe27.png)  
 但此时我们可以通过创建`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);
}

}


打印结果如下：  
 ![在这里插入图片描述](https://img-blog.csdnimg.cn/28ccb1a552a544d5b1f837f68ad11c37.png)


### 3. 与synchronized区别


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


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


### 4. 总结


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


## 二. 原子类


### 1. 理解


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

public AtomicInteger count = new AtomicInteger(0);

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


这里只展示改动后的代码，其打印结果如下：  
 ![在这里插入图片描述](https://img-blog.csdnimg.cn/ebe5856981784d16a27402f6b702487b.png)


### 2. 常见的原子类


1. AtomicBoolean
2. AtomicInteger
3. AtomicIntegerArray
4. AtomicLong
5. AtomicReference
6. AtomicStampedReference


### 3. 常见的方法


以 `AtomicInteger` 举例，常见方法有


1. addAndGet(int delta); **相当于 i += delta;**
2. decrementAndGet(); **相当于–i;**
3. getAndDecrement(); **相当于i–;**
4. incrementAndGet(); **相当于++i;**
5. getAndIncrement(); **相当于i++;**


![在这里插入图片描述](https://img-blog.csdnimg.cn/d774d2c35986447b884576ea37c650da.png?x-oss-process=image/watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,text_Q1NETiBA5pil6aOO772e5Y2B5LiA6L29,size_12,color_FFFFFF,t_70,g_se,x_16)


## 三. 线程池


### 1. 为什么要引入线程池


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


### 2. 引入线程池的好处


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


### 3. 创建线程池的方法


#### （1）ThreadPoolExecutor


使用Java标准库中的ThreadPoolExecutor方式创建，但需注意里面各自的参数代表的含义，使用起来相对而言比较复杂。  
 **构造方法**  
 ![在这里插入图片描述](https://img-blog.csdnimg.cn/2c8eb6255b774b5f8baacdaecf991803.png?x-oss-process=image/watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,text_Q1NETiBA5pil6aOO772e5Y2B5LiA6L29,size_20,color_FFFFFF,t_70,g_se,x_16)  
 为了更好地理解每个参数的具体含义，大家可以利用空闲时间去jdk的官方文档学习学习，对自己是非常有帮助的：![在这里插入图片描述](https://img-blog.csdnimg.cn/f21eeefb8df94bbdbad487c8e9eceb25.png?x-oss-process=image/watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,text_Q1NETiBA5pil6aOO772e5Y2B5LiA6L29,size_20,color_FFFFFF,t_70,g_se,x_16)


#### （2） Executors


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


1. Executors.newFixedThreadPool：创建一个固定大小的线程池
2. Executors.newCachedThreadPool：创建一个可缓存的线程池，若线程数超过处理所需，缓存一段时间后会回收，若线程数不够，则新建线程。
3. Executors.newSingleThreadExecutor：创建出只包含一个线程数的线程池，它可以保证先进先出的执行顺序。
4. Executors.newScheduledThreadPool：创建一个可以执行延迟任务的线程池（放入的任务能够过一会再执行）
5. 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”);
}
});
}
}
}


运行结果：  
 ![在这里插入图片描述](https://img-blog.csdnimg.cn/b7bd71e7406241fd91f1322b38c7a4ae.png?x-oss-process=image/watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,text_Q1NETiBA5pil6aOO772e5Y2B5LiA6L29,size_20,color_FFFFFF,t_70,g_se,x_16)


## 四. 信号量Semaphore


### 1. 定义


信号量Semaphore一般用来表示可用资源的个数，相当于一个计数器，可类比生活中停车场牌子上面显示的停车场剩余车位数量。


1. 当有车开进去的时候, 就相当于申请一个可用资源，可用车位就 -1 (这个称为信号量的 P 操作)
2. 当有车开出来的时候, 就相当于释放一个可用资源, 可用车位就 +1 (这个称为信号量的 V 操作)
3. 如果计数器的值已经为 0 了，还尝试申请资源，就会阻塞等待，直到有其他线程释放资源（计数器的值是大于等于0的）


### 2. 作用


1. 在创建信号量的时候，可以给定一个初始值（可用资源个数），当可用资源个数用完时，就会阻塞等待，以确保线程安全
2. 若把信号量的初始值设成1，则计数器的值只能取0或1了，此时把这个信号量称为**二元信号量**，和锁的功能类似，有加锁（没法申请资源）和解锁状态（可以申请资源）


### 3. 用法示例


下面我们创建15个线程，给定初始资源量为3个，然后先尝试申请资源（acquire），申请完资源后再休眠1秒，然后释放资源（release）：

mport java.util.concurrent.Semaphore;

public class Test {
public static void main(String[] args) {
Semaphore semaphore = new Semaphore(3);
Runnable runnable = new Runnable() {
@Override
public void run() {
try {
System.out.println(“准备申请资源”);
semaphore.acquire();
System.out.println(“申请资源成功”);

本人从事网路安全工作12年，曾在2个大厂工作过，安全服务、售后服务、售前、攻防比赛、安全讲师、销售经理等职位都做过，对这个行业了解比较全面。

最近遍览了各种网络安全类的文章，内容参差不齐，其中不伐有大佬倾力教学，也有各种不良机构浑水摸鱼，在收到几条私信，发现大家对一套完整的系统的网络安全从学习路线到学习资料，甚至是工具有着不小的需求。

最后，我将这部分内容融会贯通成了一套282G的网络安全资料包，所有类目条理清晰，知识点层层递进，需要的小伙伴可以点击下方小卡片领取哦！下面就开始进入正题，如何从一个萌新一步一步进入网络安全行业。

学习路线图

其中最为瞩目也是最为基础的就是网络安全学习路线图，这里我给大家分享一份打磨了3个月，已经更新到4.0版本的网络安全学习路线图。

相比起繁琐的文字，还是生动的视频教程更加适合零基础的同学们学习，这里也是整理了一份与上述学习路线一一对应的网络安全视频教程。

网络安全工具箱

当然，当你入门之后，仅仅是视频教程已经不能满足你的需求了，你肯定需要学习各种工具的使用以及大量的实战项目，这里也分享一份我自己整理的网络安全入门工具以及使用教程和实战。

项目实战

最后就是项目实战，这里带来的是SRC资料&HW资料，毕竟实战是检验真理的唯一标准嘛~

面试题

归根结底，我们的最终目的都是为了就业，所以这份结合了多位朋友的亲身经验打磨的面试题合集你绝对不能错过！

2401_84264536

关注

13
点赞
踩
20

收藏

觉得还不错? 一键收藏
0
评论
【Java之多线程】JUC常见知识点全面总结_juc 考点

count++;i < 20;@Overridetry {System.out.println(“准备申请资源”);System.out.println(“申请资源成功”);本人从事网路安全工作12年，曾在2个大厂工作过，安全服务、售后服务、售前、攻防比赛、安全讲师、销售经理等职位都做过，对这个行业了解比较全面。
复制链接

扫一扫