【Java之多线程】JUC常见知识点全面总结_juc 考点，前方高能

用户08045119012
90 阅读11分钟 
+ - [（1）ThreadPoolExecutor](#1ThreadPoolExecutor_174)
	- [（2） Executors](#2_Executors_180)

一. ReentrantLock

1. 理解

  1. 之前我们讨论的可重入锁，翻译成英文就是ReentrantLock，大部分情况下这个英文单词要理解成这一锁特性，但少数情况下要理解成一个类
  2. 和 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同样都能对其实现加锁功能，这两者有什么区别呢？

  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();
        }

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

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++;

在这里插入图片描述

三. 线程池

1. 为什么要引入线程池

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

2. 引入线程池的好处

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

3. 创建线程池的方法

（1）ThreadPoolExecutor

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

（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");
                }
            });
        }
    }
}

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

四. 信号量Semaphore

如何自学黑客&网络安全

黑客零基础入门学习路线&规划

初级黑客
1、网络安全理论知识（2天）
①了解行业相关背景，前景，确定发展方向。
②学习网络安全相关法律法规。
③网络安全运营的概念。
④等保简介、等保规定、流程和规范。（非常重要）

2、渗透测试基础（一周）
①渗透测试的流程、分类、标准
②信息收集技术：主动/被动信息搜集、Nmap工具、Google Hacking
③漏洞扫描、漏洞利用、原理，利用方法、工具（MSF）、绕过IDS和反病毒侦察
④主机攻防演练：MS17-010、MS08-067、MS10-046、MS12-20等

3、操作系统基础（一周）
①Windows系统常见功能和命令
②Kali Linux系统常见功能和命令
③操作系统安全（系统入侵排查/系统加固基础）

4、计算机网络基础（一周）
①计算机网络基础、协议和架构
②网络通信原理、OSI模型、数据转发流程
③常见协议解析（HTTP、TCP/IP、ARP等）
④网络攻击技术与网络安全防御技术
⑤Web漏洞原理与防御：主动/被动攻击、DDOS攻击、CVE漏洞复现

5、数据库基础操作（2天）
①数据库基础
②SQL语言基础
③数据库安全加固

6、Web渗透（1周）
①HTML、CSS和JavaScript简介
②OWASP Top10
③Web漏洞扫描工具
④Web渗透工具：Nmap、BurpSuite、SQLMap、其他（菜刀、漏扫等）
恭喜你，如果学到这里，你基本可以从事一份网络安全相关的工作，比如渗透测试、Web 渗透、安全服务、安全分析等岗位；如果等保模块学的好，还可以从事等保工程师。薪资区间6k-15k

到此为止，大概1个月的时间。你已经成为了一名“脚本小子”。那么你还想往下探索吗？

如果你想要入坑黑客&网络安全，笔者给大家准备了一份：282G全网最全的网络安全资料包评论区留言即可领取！

7、脚本编程（初级/中级/高级）
在网络安全领域。是否具备编程能力是“脚本小子”和真正黑客的本质区别。在实际的渗透测试过程中，面对复杂多变的网络环境，当常用工具不能满足实际需求的时候，往往需要对现有工具进行扩展，或者编写符合我们要求的工具、自动化脚本，这个时候就需要具备一定的编程能力。在分秒必争的CTF竞赛中，想要高效地使用自制的脚本工具来实现各种目的，更是需要拥有编程能力.

如果你零基础入门，笔者建议选择脚本语言Python/PHP/Go/Java中的一种，对常用库进行编程学习；搭建开发环境和选择IDE,PHP环境推荐Wamp和XAMPP， IDE强烈推荐Sublime；·Python编程学习，学习内容包含：语法、正则、文件、 网络、多线程等常用库，推荐《Python核心编程》，不要看完；·用Python编写漏洞的exp,然后写一个简单的网络爬虫；·PHP基本语法学习并书写一个简单的博客系统；熟悉MVC架构，并试着学习一个PHP框架或者Python框架 (可选)；·了解Bootstrap的布局或者CSS。

8、超级黑客
这部分内容对零基础的同学来说还比较遥远，就不展开细说了，附上学习路线。
img

网络安全工程师企业级学习路线

img
如图片过大被平台压缩导致看不清的话，评论区点赞和评论区留言获取吧。我都会回复的

视频配套资料&国内外网安书籍、文档&工具

当然除了有配套的视频，同时也为大家整理了各种文档和书籍资料&工具，并且已经帮大家分好类了。

img
一些笔者自己买的、其他平台白嫖不到的视频教程。
img

详情docs.qq.com/doc/DSlhRRFFyU2pVZGhS

avatar
文章
阅读
粉丝