难吗？教会你什么线程安全以及如何实现线程安全，一步一步搞定难点(1)

}

public void getCount(){
count++;
System.out.println(" "+count);
}
}

public static void main(String[] args) {
XRunnable runnable = new XRunnable();
Thread t1 = new Thread(runnable);
Thread t2 = new Thread(runnable);
Thread t3 = new Thread(runnable);
t1.start();
t2.start();
t3.start();
}
}

1234567891011121314151617181920212223242526272829

输出的结果为：

2
3
2
5
4
7
6
10
11
12
9
8
13
14
15
123456789101112131415

从代码上进行分析，当启动了三个线程，每个线程应该都是循环5次得出1到15的结果，但是从输出的结果，就可以看到有两个2输出，出现像这种情况表明这个方法根本就不是线程安全的。我们可以这样理解：在每个进程的内存空间中都会有一块特殊的公共区域，通常称为堆（内存），之所以会输出两个2，是因为进程内的所有线程都可以访问到该区域，当第一个线程已经获得2这个数了，还没来得及输出，下一个线程在这段时间的空隙获得了2这个值，故输出时会输出2的值。

三、线程安全问题

要考虑线程安全问题，就需要先考虑Java并发的三大基本特性：原子性、可见性以及有序性。

3.1 原子性

原子性是指在一个操作中就是cpu不可以在中途暂停然后再调度，即不被中断操作，要不全部执行完成，要不都不执行。就好比转账，从账户A向账户B转1000元，那么必然包括2个操作：从账户A减去1000元，往账户B加上1000元。2个操作必须全部完成。

那程序中原子性指的是最小的操作单元，比如自增操作，它本身其实并不是原子性操作，分了3步的，包括读取变量的原始值、进行加1操作、写入工作内存。所以在多线程中，有可能一个线程还没自增完，可能才执行到第二部，另一个线程就已经读取了值，导致结果错误。那如果我们能保证自增操作是一个原子性的操作，那么就能保证其他线程读取到的一定是自增后的数据。

3.2 可见性

当多个线程访问同一个变量时，一个线程修改了这个变量的值，其他线程能够立即看得到修改的值。

若两个线程在不同的cpu，那么线程1改变了i的值还没刷新到主存，线程2又使用了i，那么这个i值肯定还是之前的，线程1对变量的修改线程没看到这就是可见性问题。

3.3 有序性

程序执行的顺序按照代码的先后顺序执行，在多线程编程时就得考虑这个问题。

案例：抢票

当多个线程同时共享，同一个全局变量或静态变量（即局部变量不会），做写的操作时，可能会发生数据冲突问题，也就是线程安全问题。但是做读操作是不会发生数据冲突问题。

Consumer类：

package com.company;

public class Consumer implements Runnable{

private int ticket = 100;

public void run(){
while(ticket>0){
System.out.println(Thread.currentThread().getName() + “售卖第” + (100-ticket+1) + “张票”);
ticket–;
}
}

}
1234567891011121314

主类：

package com.company;

public class ThreadSafeProblem {
public static void main(String[] args){
Consumer abc = new Consumer();

new Thread(abc, “窗口1”).start();
new Thread(abc, “窗口2”).start();
}
}
12345678910

结果：

从输出结果来看，售票窗口买票出现了计票的问题，这就是线程安全出现问题了。

四、如何确保线程安全？

解决办法：使用多线程之间使用关键字synchronized、或者使用锁（lock），或者volatile关键字。

①synchronized（自动锁，锁的创建和释放都是自动的）；

②lock 手动锁（手动指定锁的创建和释放）。

③volatile关键字

为什么能解决？如果可能会发生数据冲突问题(线程不安全问题)，只能让当前一个线程进行执行。代码执行完成后释放锁，然后才能让其他线程进行执行。这样的话就可以解决线程不安全问题。

4.1 synchronized关键字

4.1.1 同步代码块

synchronized(同一个锁){
//可能会发生线程冲突问题
}
123

将可能会发生线程安全问题地代码，给包括起来，也称为同步代码块。synchronized使用的锁可以是对象锁也可以是静态资源，如×××.class，只有持有锁的线程才能执行同步代码块中的代码。没持有锁的线程即使获取cpu的执行权，也进不去。

锁的释放是在synchronized同步代码执行完毕后自动释放。

同步的前提：

1，必须要有两个或者两个以上的线程 ，如果小于2个线程，则没有用，且还会消耗性能(获取锁，释放锁)

2，必须是多个线程使用同一个锁

弊端：多个线程需要判断锁，较为消耗资源、抢锁的资源。

例子：

public class ThreadSafeProblem {
public static void main(String[] args) {
Consumer abc = new Consumer();
// 注意要使用同一个abc变量作为thread的参数，
// 如果你使用了两个Consumer对象，那么就不会共享ticket了，就自然不会出现线程安全问题
new Thread(abc,“窗口1”).start();
new Thread(abc,“窗口2”).start();
}
}
class Consumer implements Runnable{
private int ticket = 100;
@Override
public void run() {
while (ticket > 0) {
synchronized (Consumer.class) {
if (ticket > 0) {
System.out.println(Thread.currentThread().getName() + “售卖第” + (100-ticket+1) + “张票”);
ticket–;
}
}
}
}
}
1234567891011121314151617181920212223

4.1.2 同步函数

就是将synchronized加在方法上。

分为两种：

第一种是非静态同步函数，即方法是非静态的，使用的this对象锁，如下代码所示

第二种是静态同步函数，即方法是用static修饰的，使用的锁是当前类的class文件（xxx.class）。

public synchronized void sale () {
if (ticket > 0) {
System.out.println(Thread.currentThread().getName() + “售卖第” + (100-ticket+1) + “张票”);
ticket–;
}
}
123456

4.1.3 多线程死锁线程

如下代码所示，

线程t1，运行后在同步代码块中需要oj对象锁，，运行到sale方法时需要this对象锁

线程t2，运行后需要调用sale方法，需要先获取this锁，再获取oj对象锁

那这样就会造成，两个线程相互等待对方释放锁。就造成了死锁情况。简单来说就是：

同步中嵌套同步,导致锁无法释放。

class ThreadTrain3 implements Runnable {
private static int count = 100;
public boolean flag = true;
private static Object oj = new Object();
@Override
public void run() {
if (flag) {
while (true) {
synchronized (oj) {
sale();
}
}

} else {
while (true) {
sale();
}
}
}

public static synchronized void sale() {
// 前提 多线程进行使用、多个线程只能拿到一把锁。
// 保证只能让一个线程 在执行 缺点效率降低
synchronized (oj) {
if (count > 0) {
try {
Thread.sleep(50);
} catch (Exception e) {
// TODO: handle exception
}
System.out.println(Thread.currentThread().getName() + “,出售第” + (100 - count + 1) + “票”);
count–;
}
}
}
}

public class ThreadDemo3 {
public static void main(String[] args) throws InterruptedException {
ThreadTrain3 threadTrain1 = new ThreadTrain3();
Thread t1 = new Thread(threadTrain1, “①号窗口”);
Thread t2 = new Thread(threadTrain1, “②号窗口”);
t1.start();
Thread.sleep(40);
threadTrain1.flag = false;
t2.start();
}
}
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748

4.2 Lock

可以视为synchronized的增强版，提供了更灵活的功能。该接口提供了限时锁等待、锁中断、锁尝试等功能。synchronized实现的同步代码块，它的锁是自动加的，且当执行完同步代码块或者抛出异常后，锁的释放也是自动的。

Lock l = …;
l.lock();
try {
// access the resource protected by this lock
} finally {
l.unlock();
}
1234567

但是Lock锁是需要手动去加锁和释放锁，所以Lock相比于synchronized更加的灵活。且还提供了更多的功能比如说

tryLock()方法会尝试获取锁，如果锁不可用则返回false，如果锁是可以使用的，那么就直接获取锁且返回true，官方代码如下：

Lock lock = …;
if (lock.tryLock()) {
try {
// manipulate protected state
} finally {
lock.unlock();
}

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

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

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

学习路线图

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

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

网络安全工具箱

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

项目实战

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

面试题

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

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

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

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

35fc46df24091ce3c9a5032a9919b755.jpeg)

面试题

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

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

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

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