2024年网络安全最新同步锁-线程安全问题解决方案，2024年最新网络安全大厂面试笔试题分享

给大家的福利

零基础入门

对于从来没有接触过网络安全的同学，我们帮你准备了详细的学习成长路线图。可以说是最科学最系统的学习路线，大家跟着这个大的方向学习准没问题。

同时每个成长路线对应的板块都有配套的视频提供：

因篇幅有限，仅展示部分资料

网络安全面试题

绿盟护网行动

还有大家最喜欢的黑客技术

网络安全源码合集+工具包

所有资料共282G，朋友们如果有需要全套《网络安全入门+黑客进阶学习资源包》，可以扫描下方二维码领取（如遇扫码问题，可以在评论区留言领取哦）~

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

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

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

package cn.tedu.tickets;

/本类用于改造多线程售票案例，解决数据安全问题/

public class TestRunnableV2 {

public static void main(String[] args) {

//5.创建目标业务类对象

TicketR2 target = new TicketR2();

//6.创建线程对象

Thread t1 = new Thread(target);

Thread t2 = new Thread(target);

Thread t3 = new Thread(target);

Thread t4 = new Thread(target);

//7.以多线程的方式运行

t1.start();

t2.start();

t3.start();

t4.start();

}

}

/1.多线程中出现数据安全问题的原因：多线程程序+共享数据+多条语句操作共享数据/

/*2.同步锁：相当于给容易出现问题的代码加了一把锁，包裹了所有可能会出现数据安全问题的代码

• 加锁之后，就有了同步(排队)的效果，但是加锁的话，需要考虑：

• 锁的范围：不能太大，太大，干啥都得排队，也不能太小，太小，锁不住，还是会有安全隐患*/

//1.创建自定义多线程类

class TicketR2 implements Runnable {

//3.定义成员变量，保存票数

int tickets = 100;

//创建锁对象

Object o = new Object();

//2.实现接口中未实现的方法，run()中放着的是我们的业务

@Override

public void run() {

//4.通过循环结构完成业务

while (true) {

/*3.同步代码块：synchronized(锁对象){会出现安全隐患的所有代码}

• 同步代码块在同一时刻，同一资源只会被一个线程独享*/

/这种写法不对，相当于每个线程进来的时候都会new一个锁对象，线程间使用的并不是同一把锁/

//synchronized (new Object()){

//修改同步代码块的锁对象为成员变量o,因为锁对象必须唯一

synchronized (o) {//同步代码块解决的是重卖的问题

//如果票数>0就卖票

if (tickets > 0) {

try {

Thread.sleep(10);

} catch (InterruptedException e) {

e.printStackTrace();

}

//4.1打印当前正在售票的线程名以及票数-1

System.out.println(Thread.currentThread().getName() + “=” + tickets–);

}

//4.2退出死循环–没票的时候就结束

if (tickets <= 0) break;

}

}

}

}

1.4.2 练习-改造售票案例

---

_创建包: cn.tedu.tickets

创建类:TestThreadV2.java_

package cn.tedu.tickets;

/本类用于改造多线程售票案例，解决数据安全问题/

public class TestThreadV2 {

public static void main(String[] args) {

//5.创建多个线程对象并以多线程的方式运行

TickectT2 t1 = new TickectT2();

TickectT2 t2 = new TickectT2();

TickectT2 t3 = new TickectT2();

TickectT2 t4 = new TickectT2();

t1.start();

t2.start();

t3.start();

t4.start();

}

}

//1.自定义多线程类

class TickectT2 extends Thread {

//3.新增成员变量用来保存票数

static int tickets = 100;

//static Object o = new Object();

//2.添加重写的run()来完成业务

@Override

public void run() {

//3.创建循环结构用来卖票

while (true) {

//Ctrl+Alt+L调整代码缩进

//7.添加同步代码块，解决数据安全问题

//synchronized (new Object()) {

/static的Object的对象o这种写法也可以/

//synchronized (o) {

/*我们每通过class关键字创建一个类，就会在工作空间中生成一个唯一对应的类名.class字节码文件

• 这个类名.class对应的对象我们称之为这个类的字节码对象

• 字节码对象极其重要，是反射技术的基石，字节码对象中包含了当前类所有的关键信息

• 所以，用这样一个唯一且明确的对象作为同步代码块的锁对象，再合适不过了*/

synchronized (TickectT2.class) {/比较标准的写法/

if(tickets > 0){

//6.添加线程休眠，暴露问题

try {

Thread.sleep(10);//让线程休眠，增加线程状态切换的频率

} catch (InterruptedException e) {

e.printStackTrace();

}

//4.1打印当前正在售票的线程名与票数-1

System.out.println(getName() + “=” + tickets–);

}

//4.2给程序设置一个出口，没有票的时候就停止卖票

if (tickets <= 0) break;

}

}

}

}

注意:如果是继承的方式的话,锁对象最好用"类名.class",否则创建自定义线程类多个对象时,无法保证锁的唯一

1.5 之前遇到过的同步例子

---

StringBuffer JDK1.0

加了synchronized ,性能相对较低(要排队,同步),安全性高

StringBuilder JDK1.5

去掉了synchronized,性能更高(不排队,异步),存在安全隐患

快速查找某个类的快捷键:Ctrl+Shift+T

2 线程创建的其他方式

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

2.1 ExecutorService/Executors

---

ExecutorService:用来存储线程的池子,把新建线程/启动线程/关闭线程的任务都交给池来管理

• execute(Runnable任务对象) 把任务丢到线程池

Executors 辅助创建线程池的工具类

• newFixedThreadPool(int nThreads) 最多n个线程的线程池

• newCachedThreadPool() 足够多的线程,使任务不必等待

• newSingleThreadExecutor() 只有一个线程的线程池

2.2 练习:线程的其他创建方式

---

_创建包: cn.tedu.tickets

创建类: TestThreadPool.java_

package cn.tedu.tickets;

import java.util.concurrent.ExecutorService;

import java.util.concurrent.Executors;

/本类用于测试线程池/

public class TestThreadPool {

public static void main(String[] args) {

//5.创建接口实现类TicketR3类的对象作为目标业务对象

TicketR3 target = new TicketR3();

/*Executors是用来辅助创建线程池的工具类对象

• 常用方法是newFixedThreadPool(int)这个方法可以创建指定数目的线程池对象

• 创建出来的线程池对象是ExecutorService:用来存储线程的池子，负责：新建/启动/关闭线程*/

//6.使用Executors工具创建一个最多有5个线程的线程池对象ExecutorService池对象

ExecutorService pool = Executors.newFixedThreadPool(5);

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

/execute()让线程池中的线程来执行业务，每次调用都会将一个线程加入到就绪队列/

pool.execute(target);/本方法的参数就是你要执行的业务，也就是目标业务类对象/

}

}

}

//同步锁问题解决方案笔记：1.4.1从26行复制到58行，TicketR2改成TicketR3

//1.创建自定义多线程类

class TicketR3 implements Runnable {

//3.定义成员变量，保存票数

int tickets = 100;

//创建锁对象

Object o = new Object();

//2.实现接口中未实现的方法，run()中放着的是我们的业务

@Override

public void run() {

//4.通过循环结构完成业务

while (true) {

/*3.同步代码块：synchronized(锁对象){会出现安全隐患的所有代码}

• 同步代码块在同一时刻，同一资源只会被一个线程独享*/

/这种写法不对，相当于每个线程进来的时候都会new一个锁对象，线程间使用的并不是同一把锁/

//synchronized (new Object()){

//修改同步代码块的锁对象为成员变量o,因为锁对象必须唯一

synchronized (o) {//同步代码块解决的是重卖的问题

//如果票数>0就卖票

if (tickets > 0) {

try {

Thread.sleep(10);

} catch (InterruptedException e) {

e.printStackTrace();

}

//4.1打印当前正在售票的线程名以及票数-1

System.out.println(Thread.currentThread().getName() + “=” + tickets–);

}

//4.2退出死循环–没票的时候就结束

if (tickets <= 0) break;

}

}

}

}

3 拓展:线程锁

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

3.1 悲观锁和乐观锁

---

悲观锁：像它的名字一样，对于并发间操作产生的线程安全问题持悲观状态.

写在最后

在结束之际，我想重申的是，学习并非如攀登险峻高峰，而是如滴水穿石般的持久累积。尤其当我们步入工作岗位之后，持之以恒的学习变得愈发不易，如同在茫茫大海中独自划舟，稍有松懈便可能被巨浪吞噬。然而，对于我们程序员而言，学习是生存之本，是我们在激烈市场竞争中立于不败之地的关键。一旦停止学习，我们便如同逆水行舟，不进则退，终将被时代的洪流所淘汰。因此，不断汲取新知识，不仅是对自己的提升，更是对自己的一份珍贵投资。让我们不断磨砺自己，与时代共同进步，书写属于我们的辉煌篇章。

需要完整版PDF学习资源私我

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

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

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