2024年网安最新Java多线程（多线程基本操作，多线程安全问题等）

public void run() {

while(true){

System.out.println(“haha”);

try {

Thread.sleep(1000);

} catch (InterruptedException e) {

e.printStackTrace();

}

}

}

}

可以看到两个线程并发执行，

而如果是调用run（）方法，就是普通的调用，没有创建新线程，一直在循环里出不来

四、中断一个线程

===========================================================================

4.1 让线程的入口方法执行完毕

---

线程执行完毕，运行5S 线程执行完毕

public class Demo {

//中断一个线程

static boolean isRunning=true;

public static void main(String[] args) {

Thread t1=new Thread(){

@Override

public void run() {

while(isRunning){

System.out.println(“hello”);

try {

Thread.sleep(1000);

} catch (InterruptedException e) {

e.printStackTrace();

}

}

}

};

t1.start();

try {

Thread.sleep(5000);

} catch (InterruptedException e) {

e.printStackTrace();

}

isRunning=false;

System.out.println(“线程运行5S结束”);

}

}

4.2 使用Thread类提供的interrupt方法

---

针对上面的方式进行修改

1，把上面的while()中判断条件进行修改

2，把catch里面的代码，加一个break

调用 interrupt()是通知线程结束，具体还是看内部代码的实现

public class Demo {

//使用Thread 方法来中断线程

public static void main(String[] args) {

Thread t1=new Thread(){

@Override

public void run() {

while(!Thread.currentThread().isInterrupted()){

System.out.println(“hello”);

try {

Thread.sleep(1000);

} catch (InterruptedException e) {

// e.printStackTrace();

break;

}

}

}

};

t1.start();

try {

Thread.sleep(5000);

} catch (InterruptedException e) {

e.printStackTrace();

}

System.out.println(“线程结束”);

t1.interrupt();

}

}

五、等待线程

=========================================================================

我们在创建多个线程之后，每个线程都是一个独立的执行流~

这些线程每个线程的执行顺序都是不确定的，完全取决于操作系统的调度，这里的等待线程机制就是一种确定线程先后顺序方式，确定线程的结束顺序，无法确定谁先开始，可以确定谁先结束 使用join()

join 起到的效果就是等待某个线程结束，谁调用join就等待谁结束

通过代码来解释：

public class Demo {

//使用Thread 方法来中断线程

public static void main(String[] args) {

Thread t1=new Thread(){

@Override

public void run() {

for(int i=0;i<5;i++){

System.out.println(“hello”);

try {

Thread.sleep(1000);

} catch (InterruptedException e) {

e.printStackTrace();

}

}

}

};

t1.start();

try {

t1.join();

} catch (InterruptedException e) {

e.printStackTrace();

}

}

}

这里在main 方法中调用了join，相当于在主线程中，等待t1线程结束

main方法在执行的时候，遇到join就会堵塞等待，一直等t1线程执行完毕，这个时候join才会继续往下执行

也就是说谁调用join 谁先结束

六、线程休眠

=========================================================================

当执行sleep时就是让线程休眠，所谓的休眠就是把线程的task struct放入等待队列

CPU在执行的时候是挑等待队列中的线程来执行的，而sleep的线程在等待队列不在就绪队列，所以不会被执行

也可以在sleep中加上时间，等时间过去后，等待队列的线程才有机会到就绪队列，至于什么时候到就绪队列还是要看调度器执行

等待队列可能有好多了，具体谁先出队列，先回到就绪队列和设定的时间相关，如果时间一样就看系统的调度

七、线程的状态

==========================================================================

在我们调试多线程程序有帮助

| NEW | Thread 对象刚创建，还没有在系统中创建线程，相当于任务交给了线程，但是线程还没有开始执行 |

| — | — |

| Runnable | 线程是一个准备就绪的状态，随时可能调度到CPU上执行，或者正在CPU上执行（线程的task struct在就绪队列中） |

| Blocked | 线程堵塞（线程在等待队列里）没有竞争到锁 |

| Waiting | 线程堵塞（线程在等待队列里）调用waiting 方法 |

| Timed_Waiting | 线程堵塞（线程在等待队列里）调用sleep方法 |

| Terminated | 线程结束了（Thread对象还没销毁） |

八、线程安全（重要）！！！

================================================================================

多线程虽然是更轻量的并发编程（相比于进程），但是线程是访问同一份内存资源，由于线程是一个抢占式执行的过程中谁先执行，谁后执行，不确定，完全却决于系统的调度。由于这里不确定性太多就可能导致多个线程访问同一个资源的时候，出现BUG所以引出了线程安全问题。 访问分为读和写操作，读操作不会涉及到线程安全问题，只有写操作涉及线程安全工作

多线程修改同一变量

public class Demo {

//线程安全问题

static class Counter{

//创建一个自增类，通过线程调度来展示线程安全问题

public int count=0;

public void increase(){

count++;

}

}

public static void main(String[] args) {

//通过两个线程同时对count进行自增

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

}

}

此处代码就是t1,t2 两个线程修改同一变量，存在线程安全问题，正常情况下count值应该是100000，但是运行下来，count值是在50000~100000之间，每次都在变化，这是为什么呢？ 这里就是触发了线程安全的问题

这里我们先看count ++ 具体做了什么事情，这里我们就要引入JMM了

JMM（JVM 实现方式的抽象，Java 程序和内存之间是如何交互的）

1）先把内存数据读取到CPU的寄存器中

2）针对寄存器中的内容，通过类似于ADD这样的指令进行+1，操作的结果仍然是放在寄存器中里

3）把寄存器中的数据，写回到内存中

由于多线程之间是抢占式执行的，可能第一个线程执行自增一半时，就可能被调度出CPU，由第二个线程再次自增

LOAD就是从内存中读取数据到寄存器 ADD就是进行自增效果 SAVE就是将寄存器中数据写回内存中

如果出现第一个线程读取到数据为0时，在进行自增操作时，线程二也进行读取数据，两个线程都读到的是0，相当于两次自增操作只增加了一次，只要是线程二的读取不是在线程一SAVE操作后，就会发生自增异常的情况！所以两个线程分别自增50000次，数据最后的数值是在50000~100000之间的。这就是抢占式执行同一个资源所带来的异常！

如果这里是两个CPU也是同样的情况，这样的不确定性，不符合预期的要求，就认为是BUG，因为我们执行代码就是追求的是确定性

8.1导致线程不安全的原因：

---

由于多线程是抢占式执行，可能会出现第一个线程自增执行到一半就被调度出去，就会执行第二个线程。

1）线程的抢占式执行过程（无法修改）操作系统内核实现的

2）多个线程修改同一变量

3）修改操作不是原子性 （原子性：不可拆分）如果三个操作（读取，自增，写回）打包成一个整体，这就能解决了线程不安全问题，保证操作原子性，是保证线程安全的主要手段

4）内存可见性

两个线程同时操作一个内存，比如一个读一个写，写操作的线程进行修改时，读线程读取到的可能是修改之前的结果，也可能是读取到修改之后的结果，也会带来线程安全问题

内存可见性也可能是编译器优化，假设执行一个循环自增，这样的操作就涉及到大量的读写操作，读写内存的操作比访问CPU寄存器要慢几千倍，所以JVM往往对指令进行优化，把它等价转换成另外一种情况 保证逻辑不变的情况下，读取一次内存，之后进行自增，自增结束后在写回内存，节省了很多的 读写内存的开销，但是这样会触发线程不安全。

解决可见性，方案就是直接禁止这样的编译器的优化，让程序跑慢点，关键是要对，不能在多线程情况下出错

5）指令重排序

和线程不安全直接相关，也是和编译器优化直接相关，为了让程序跑的更快，调整了执行顺序~（调整的前提逻辑不改变，但是效率提高），如果是多线程的情况下可能重排会改变逻辑，会导致线程不安全问题。

8.2解决线程安全问题方法

---

1）多线程不修改同一变量

synchronized

synchronized(关键字) 监视器锁 ，我们通过加锁来保证操作原子性，同时禁止指令重排序和保证内存可见性

用法：

1.修饰一个方法 （方法前加上，就是针对代码进行加锁工作，调用方法就加锁，出了代码块就解锁）

2.修饰一个代码块（包裹起来） 针对哪个对象加锁，括号内就填哪个对象

分析synchroized 工作过程

使用synchronized 就是 相当于增加于给操作增加了两个指令 LOCK UNLOCK

LOCK 操作的特性，只有一个线程能执行成功，直到另一个线程释放UNLOCK 另一个线程才能执行

就比如上面演示的自增操作，加锁就相当于把LOAD ADD SAVE 三个操作打包为一个操作，这样就解决了线程的原子性，并且synchronized也能禁止编译器的进行内存可见性和指令重排序，所以使用synchronized就解决了线程安全问题，但是synchronized也付出了代价，程序运行的效率大大降低了。

注意synchroized 括号内填什么

针对哪个对象加锁，就填哪个对象，每一个对象能都加锁，如果多个线程竞争同一锁对象（尝试对同一个对象加锁，此时就会出现一个竞争成功，其他等待的情况），如果两个线程竞争不同的锁，两个线程都能成功获取到锁。

如果synchronized修饰的就是方法，相当于加锁的对象是this

如果synchronized修饰静态方法，相当于加锁的对象是类对象

错误示范：1）加锁对象错误

此时由于我们加锁的不是同一个对象，第一个为t1,第二个是t2，这两个加锁操作就不会构成竞争，没有作用

2）嵌套加锁 ：

这里我们在给increase方法加了锁，还对counter加了一次锁，相当于连续加了两次锁，这会产生什么情况？

会产生死锁，因为

1）执行程序时，运行到循环时，因为对counter 对象就行了加锁，此时用LOCK将counter 对象锁起来

2）当程序运行到调用increase () 方法时，这个方法也有加锁，但是此时无法加锁，因为有锁在上面，所以increase ()方法就进入堵塞等待，等待上一个加锁操作进行释放~

3）但是上一个加锁释放是要执行完increase ()方法的，但是此时方法无法执行，这里就产生了死锁情况！

但是如果运行程序的话，可以运行成功，因为synchroized 内部对这种状况进行了解决，利用特殊的手段来处理这个场景“可重入锁”

synchroized 如何实现的可重入锁效果？

synchroized内部记录了当前这把锁时哪个线程持有的， 如果当前加锁线程和持有线程是同一线程，而不是真的进行加锁，而是把一个计数器++ ，如果后续该线程继续尝试获取锁，继续判定加锁线程和持有线程是不是同一线程，只要是同一线程，就不真正加锁，而是计数器++，如果该线程调用解锁操作，也不是立即解锁，而是计数器- - ，直到计数器减为0了，才认为真的要“释放锁了 ”，才允许其他线程来获取锁~

volatile

起到的效果也是辅助保证线程安全~~ 主要是用于读写同一个变量的时候

volatile能够禁止指令重排序，和内存可见性，但是不能保证原子性

我们来设计一个场景 线程一进行循环，线程二通过修改循环条件，来使得线程1循环结束

import java.util.Scanner;

public class Demo {

static class Counter{

public int flag=0;

}

public static void main(String[] args) {

Counter counter=new Counter();

Thread t1=new Thread(){

@Override

public void run() {

while(counter.flag==0){

//do nothing

}

System.out.println(“线程一循环结束”);

}

};

t1.start();

Thread t2=new Thread(){

@Override

public void run() {

Scanner scanner=new Scanner(System.in);

System.out.println(“请输入一个整数”);

counter.flag=scanner.nextInt();

}

};

t2.start();

}

}

我们预想的效果是输入一个非0整数之后，循环停止，但是运行程序发现，循环并没有停止，这是因为内存可见性，如果没有优化，此时CPU就需要频繁的读取内存数据，但是这时进行了优化，编译器就把这个读操作优化成只从内存中读一次，后续都直接读寄存器中数值，即使内存中数值发生变化，也不会读取到，

这种场景情况下，使用synchroized也可以，但是没必要因为volatile 比synchroized更轻量化，解决方法就是在flag 前加上volatile，加上volatile之后线程一每次读取flag的值都必须从内存中读取了（效率降低了，但是代码逻辑准确了）

但是volatile只使用于一读一写的情况，如果多个线程都要执行写操作，那么volatile就没有作用了，就要使用synchroized了

九、对象等待集

==========================================================================

功能: 协调多个线程之间执行的先后顺序

对象等待集的应用场景

由于多线程之间是一个”抢占式执行“，可能会导致某个线程一直占用，其他线程就会出现线程饿死的情况，等待集就是解决线程太频繁占用，

实现等待集： wait () ，notify() ，notifyAll ()

wait /notify 这一系列方法必须搭配，synchronized 来使用,如果不在synchronized 使用就会出现异常，因为当前预期是获取到锁的状态才能调用wait（）,没有synchronized相当于还没获取到锁，就尝试调用，于是就会出现异常

wait 内部做了三件事

1.释放锁

2. 等待其他线程的通知

3.等待通知之后，重新尝试获取锁

notify()

通知某个线程被唤醒，从wait中醒来，notify也是在synchroized中使用，调用notify()方法之后，代码不会立即释放锁，而是在执行完当前的synchroized之后才释放锁，同时等待中的线程就尝试重新竞争这个锁

演示wait 和 notify 用法

//演示wait 和 notify 用法

public class Demo {

//创建一个锁对象

static public Object Locker=new Object();

//用来等待的线程

static class WaitTask implements Runnable{

@Override

public void run() {

synchronized (Locker){

while (true){

try {

如何自学黑客&网络安全

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

初级黑客
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、超级黑客
这部分内容对零基础的同学来说还比较遥远，就不展开细说了，附上学习路线。

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

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

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

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

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

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化资料的朋友，可以点击这里获取

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！