最新并发编程专题七-什么是线程安全，网络安全基础面试题

还有兄弟不知道网络安全面试可以提前刷题吗？费时一周整理的160+网络安全面试题，金九银十，做网络安全面试里的显眼包！

王岚嵚工程师面试题（附答案），只能帮兄弟们到这儿了！如果你能答对70%，找一个安全工作，问题不大。

对于有1-3年工作经验，想要跳槽的朋友来说，也是很好的温习资料！

【完整版领取方式在文末！！】

93道网络安全面试题

内容实在太多，不一一截图了

黑客学习资源推荐

最后给大家分享一份全套的网络安全学习资料，给那些想学习 网络安全的小伙伴们一点帮助！

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

1️⃣零基础入门

① 学习路线

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

② 路线对应学习视频

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

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

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

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

(2)、根本就不提供任何可供修改成员变量的地方，同时成员变量也不作为方法的返回值

code：

/**

• @Auther: DarkKing

• @Date: 2019/5/12 12:09

• @Description:不可变的类

*/

public class ImmutetableToo {

//改类也属于线程安全的，因为没有提供任何获取和修改的地方。

private List list = new ArrayList<>(3);

public ImmutetableToo() {

list.add(1);

list.add(2);

list.add(3);

}

public boolean isContains(int i) {

return list.contains(i);

}

}

java开发建议:对于一个类，所有的成员变量应该是私有的，如果有可能，所有的成员变量应该加上final关键字.可以保证线程安全。

2.4、volatile

volatile关键字可以保证保证类的可见性，最适合一个线程写，多个线程读的情景，

2.5、加锁和CAS

恩，这个没啥好解释的了。。。。

2.6、安全的发布

类中持有的成员变量，特别是对象的引用，如果这个成员对象不是线程安全的，通过get等方法发布出去，会造成这个成员对象本身持有的数据在多线程下不正确的修改，从而造成整个类线程不安全的问题。

/**

• @Auther: DarkKing

• @Date: 2019/5/12 12:09

• @Description:存在不安全的发布

*/

public class UnsafePublish {

//要么用线程安全的容器替换

//要么发布出去的时候，提供副本，深度拷贝

private List list = new ArrayList<>(3);

public UnsafePublish() {

list.add(1);

list.add(2);

list.add(3);

}

//将list不安全的发布出去了，线程不安全。

public List getList() {

return list;

}

//也是安全的,加了锁--------------------------------

public synchronized int getList(int index) {

return list.get(index);

}

public synchronized void set(int index,int val) {

list.set(index,val);

}

}

2.7、TheadLocal

ThreadLocal的实例代表了一个线程局部的变量，每条线程都只能看到自己的值，并不会意识到其它的线程中也存在该变量。

三、线程安全引发的一些问题

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

3.1、死锁

死锁是指两个或两个以上的进程在执行过程中，由于竞争资源或者由于彼此通信而造成的一种阻塞的现象，若无外力作用，它们都将无法推进下去。

发生死锁的条件是，竞争资源一定是多于1个，同时小于等于竞争的线程数，当资源只有一个，只会产生激烈的竞争，不会死锁。

死锁的根本成因：获取锁的顺序不一致导致。

code：

/**

• @Auther: DarkKing

• @Date: 2019/5/12 12:09

• @Description:死锁的例子

*/

public class NormalDeadLock {

private static Object lockFirst = new Object();//第一个锁

private static Object lockSecond = new Object();//第二个锁

//先拿第一个锁，再拿第二个锁

private static void fisrtToSecond() throws InterruptedException {

String threadName = Thread.currentThread().getName();

synchronized (lockFirst) {

System.out.println(threadName+" get first");

SleepTools.ms(100);

synchronized (lockSecond) {

System.out.println(threadName+" get second");

}

}

}

//先拿第二个锁，再拿第一个锁

private static void SecondToFisrt() throws InterruptedException {

String threadName = Thread.currentThread().getName();

synchronized (lockFirst) {

System.out.println(threadName+" get first");

SleepTools.ms(100);

synchronized (lockSecond) {

System.out.println(threadName+" get second");

}

}

}

//执行先拿第二个锁，再拿第一个锁

private static class TestThread extends Thread{

private String name;

public TestThread(String name) {

this.name = name;

}

public void run(){

Thread.currentThread().setName(name);

try {

SecondToFisrt();

} catch (InterruptedException e) {

e.printStackTrace();

}

}

}

public static void main(String[] args) {

Thread.currentThread().setName(“TestDeadLock”);

TestThread testThread = new TestThread(“SubTestThread”);

testThread.start();

try {

fisrtToSecond();//先拿第一个锁，再拿第二个锁

} catch (InterruptedException e) {

e.printStackTrace();

}

}

}

3.1.1查找程序是否死锁的方式

1、代码逻辑查看

2、通过通过jps 查询应用的 id，再通过jstack id 查看应用的锁的持有情况，高版本的JDK可以直接检测到简单地死锁

解决办法：保证加锁的顺序性

3.1.2动态的死锁

动态顺序死锁，在实现时按照某种顺序加锁了，但是因为外部调用的问题，导致无法保证加锁顺序而产生的。

code:

/**

• @Auther: DarkKing

• @Date: 2019/5/12 12:09

• @Description:不安全的转账动作的实现

*/

public class TrasnferAccount implements ITransfer {

//当根据传参不一致，有可能会导致死锁。

//一个线程先锁了from，在锁了to同时另一个线程将to当做from传参，

// 将from当做to传参。那么第二个线程则先锁了to，又锁了from。导致死锁

@Override

public void transfer(UserAccount from, UserAccount to, int amount)

throws InterruptedException {

synchronized (from){//先锁转出

System.out.println(Thread.currentThread().getName()

+" get"+from.getName());

Thread.sleep(100);

synchronized (to){//再锁转入

System.out.println(Thread.currentThread().getName()

+" get"+to.getName());

from.flyMoney(amount);

to.addMoney(amount);

}

}

}

}

解决：

1. 通过内在排序，保证加锁的顺序性

2. 通过尝试拿锁，也可以。

3.2、活锁

例如我们生活中的例子，两个人在窄路相遇，同时向一个方向避让，然后又向另一个方向避让，如此反复。导致两个人都过不去。

活锁即是在尝试拿锁的机制中，发生多个线程之间互相谦让，不断发生拿锁，释放锁的过程。

解决办法：每个线程休眠随机数，错开拿锁的时间。

3.3、线程饥饿

低优先级的线程，总是拿不到执行时间。

3.4、性能和思考

使用并发的目标是为了提高性能，引入多线程后，其实会引入额外的开销，如线程之间的协调、增加的上下文切换，线程的创建和销毁，线程的调度等等。过度的使用和不恰当的使用，会导致多线程程序甚至比单线程还要低。

衡量应用的程序的性能：服务时间，延迟时间，吞吐量，可伸缩性等等，其中服务时间，延迟时间（多快），吞吐量（处理能力的指标，完成工作的多少）。多快和多少，完全独立，甚至是相互矛盾的。

对服务器应用来说：多少（可伸缩性，吞吐量）这个方面比多快更受重视，先保证可以横向扩展，在保证垂直扩展。

我们做应用的时候：

1. 先保证程序正确，确实达不到要求的时候，再提高速度。（黄金原则）

2. 一定要以测试为基准。

一个应用程序里，串行的部分是永远都有的。

Amdahl定律  ：  1/(F+(1-N)/N)   F:必须被串行部分,程序最好的结果为 1/F。

3.5、影响性能的因素

3.5.1、上下文切换

是指CPU 从一个进程或线程切换到另一个进程或线程。一次上下文切换花费5000~10000个时钟周期，几微秒。在上下文切换过程中，CPU会停止处理当前运行的程序，并保存当前程序运行的具体位置以便之后继续运行。从这个角度来看，上下文切换有点像我们同时阅读几本书，在来回切换书本的同时我们需要记住每本书当前读到的页码。

上下文切换通常是计算密集型的。也就是说，它需要相当可观的处理器时间。所以，上下文切换对系统来说意味着消耗大量的 CPU 时间，事实上，可能是操作系统中时间消耗最大的操作。

3.5.2、内存同步

一般指加锁，对加锁来说，需要增加额外的指令，这些指令都需要刷新缓存等等操作。

3.5.3、阻塞

会导致线程挂起【挂起：挂起进程在操作系统中可以定义为暂时被淘汰出内存的进程，机器的资源是有限的，在资源不足的情况下，操作系统对在内存中的程序进行合理的安排，其中有的进程被暂时调离出内存，当条件允许的时候，会被操作系统再次调回内存，重新进入等待被执行的状态即就绪态，系统在超过一定的时间没有任何动作】。很明显这个操作包括两次额外的上下文切换。

3.6、如何减少锁的竞争

3.6.1、减少锁的粒度

使用锁的时候，锁所保护的对象是多个，当这些多个对象其实是独立变化的时候，不如用多个锁来一一保护这些对象。但是如果有同时要持有多个锁的业务方法，要注意避免发生死锁

code

/**

• @Auther: DarkKing

• @Date: 2019/5/12 12:09

• @Description:

*/

public class FinenessLock {

public final Set users = new HashSet();

// 锁的粒度过大，在执行方法体是就进行加锁

// public void synchronized addUser(String u) {

// System.out.println(“test”);

// users.add(u);

// }

//只针对对操作的对象进行加锁，如果方法体重还有其他方法，则不影响其他业务进行。

public void addUser(String u) {

System.out.println(“test”);

synchronized (users) {

users.add(u);

}

}

}

加锁原则，能加锁对象别锁方法，能锁方法不要锁类。锁类尽量不要使用

3.6.2、缩小锁的范围

对锁的持有实现快进快出，尽量缩短持由锁的的时间。将一些与锁无关的代码移出锁的范围，特别是一些耗时，可能阻塞的操作

code:

/**

• @Auther: DarkKing

• @Date: 2019/5/12 12:09

• @Description:缩小锁的范围

*/

public class ReduceLock {

private Map<String,String> matchMap = new HashMap<>();

//加锁体力过多无关线程安全的操作

public boolean isMatch(String name,String regexp) {

synchronized(this){

String key = “user.”+name;

String job = matchMap.get(key);

if(job == null) {

先自我介绍一下，小编浙江大学毕业，去过华为、字节跳动等大厂，目前阿里P7

深知大多数程序员，想要提升技能，往往是自己摸索成长，但自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年最新网络安全全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友。

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上网络安全知识点，真正体系化！

由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新

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

ing job = matchMap.get(key);

if(job == null) {

先自我介绍一下，小编浙江大学毕业，去过华为、字节跳动等大厂，目前阿里P7

深知大多数程序员，想要提升技能，往往是自己摸索成长，但自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年最新网络安全全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友。
[外链图片转存中…(img-f7zweqq5-1715630991959)]
[外链图片转存中…(img-mAylZ5qv-1715630991961)]
[外链图片转存中…(img-Rtv193qw-1715630991961)]
[外链图片转存中…(img-EF5DlZ5Z-1715630991962)]
[外链图片转存中…(img-rZnqG4dR-1715630991963)]
[外链图片转存中…(img-HG6MOqeY-1715630991963)]

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上网络安全知识点，真正体系化！

由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新

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