共计 3990 个字符，预计需要花费 10 分钟才能阅读完成。
第一次听到线程，可能是在接触淘宝后，双十一节日，国民纷纷抢购本人心仪的产品，让少数电商厂家赚的是盆满钵满，在咱们欢快的浏览网页，一件下单的时候，前面的操作可能很少有人理解，为了保障每笔订单都能正确成交领取，商品下单胜利，减掉库存，减少销量，调配仓库，物流地址，派送人员，以及工夫等，一环接着一环，像是行驶在拉萨的火车一样，必须保障平安，快捷，所以这次咱们就来聊聊对于下单背地，数据安全的那些事儿？
## 线程
线程，说的线程，咱们先要理解一个和它相相似的概念。
过程；对就是计算机的过程，资源调度的最小单位，（下图展现的就是计算机软件运行的过程列表）
而线程 CPU 调用的最小单位
<,>
举个例子：
把计算机比作中国的铁路, 其中每辆运行的火车就是一个过程（软件正在运行的状态），车厢就是一个个线程（其中有蕴含启动，存储的，数据转换等性能的），组成了能够继续工作的火车🚄；
线程和过程之间是如何工作的呢？
线程是小弟，过程那就是国王，过程是有多个有序逻辑的线程组成的形象产物，用来保障过程性能的残缺应用。
比方咱们罕用的微信聊天，其实微信的性能远不止聊天，其中打字输出（存储线程）小 A ，给老大如何传递数据，不会被其他人所打搅呢
—
场景：你正在输出的时候，为什么其余的音讯会给你发送接管到，然而丝毫不影响你正在输出的货色，能够接管到最新的，也能够保留最新的？
因为这个线程中小 A，有 超能力，当同一时间，小 A 拿到的信息，存储好之后要给他人发送的时候，保障只有本人能发送，不让别的线程来捣鬼，（为了平安，回绝他人，现代人民创造了🔐）— 加锁。
就像是你每次上厕所锁门是一样的，因为本人须要进行一项业余工作，平安，避免别进行毁坏，导致不平安的隐患，所以咱们开始了如何加锁之路。
## 数据安全 – 加锁
在 Java 中，咱们常见的锁有，分布式锁，乐观锁与乐观锁，偏心锁，自旋锁，以及 Synchronized 等同步锁机制，都是为了数据安全，然而每个锁的机制、利用范畴、应用原理都不一样。
这期呢咱们次要从数据 可见性 和平安 两个方面来讲讲怎么实现一个简略的线程平安的过程？
答案是：应用volatile
### 数据可见性
因为 volatile 是线程底层用同步机制的一个准则，它有三个个性
#### 可见性
若是某一个线程扭转了一个固定的变量，其余线程会立即通晓；
也就是 及时告诉
及时的告诉其余线程, 主物理内存中的值曾经被批改;
package com.atguigu;
import java.util.concurrent.TimeUnit;
class volatileTest1{
// 加 volatile 能够看见后果
volatile int number=0;// 成员变量默认为 0
public void addTo60(){
// 将 number 变成 60
this.number=60;
}
}
public class volatileDemo {
// 如何了解这个 volatile 的保障可见性：/*
* 可见性：保障在线程应用的过程中，将数据批改后，及时的告诉其余线程更新数据；*
* demo 的设计原理：（须要增加的是一个睡眠工夫 3 - 不然后果会出谬误）* 咱们运行 nto60 的办法 -- 看 main 线程是否能取得曾经变动了的数值 number
* 否则将循环上来
* */
public static void main(String[] args) {
//1. 资源类的初始化
volatileTest1 volatileTest1=new volatileTest1();
new Thread(()->{System.out.println(Thread.currentThread().getName()+":come in"+volatileTest1.number);
// 这里必须要睡 3 秒 -- 不然的后果就是 main 线程也会同步，因为线程的运行速度太快啦
try {
// 休眠 3 秒钟
TimeUnit.SECONDS.sleep(3);
} catch (InterruptedException e) {e.printStackTrace();
} finally { }
//2. 操作高内聚的办法 nTo60
volatileTest1.addTo60();
System.out.println(Thread.currentThread().getName()+":ture 后的"+volatileTest1.number);
},"web").start();
// 上述的 web 线程曾经将数据变成 60；// 测试 main 线程是否感知到；while (volatileTest1.number==0){// 就始终循环。什么都不会打印进去}
System.out.println(Thread.currentThread().getName() +":"+volatileTest1.number);
// 示意 main 线程也通晓了 number 的变动 --- 满足了 volatile 的可见性的需要
/*
*
* web:come in0
web:ture 后的 60
main:60
*
* */
}
}不保障原子性：
原子性：与 mysql 事务中的相似，不可分割，完整性，
也即是某个线程在工作时，两头不能够加塞和宰割，要么整体同时胜利，要么失败；
比方在计算机罕用的经典问题：
—-
a++ 是否反对原子性
思路：具体的展现 a ++ 的运行过程，直至 cpu 调用的指令
分为三步；
①读取，从主物理内存中的 a —-》拷贝到本地的线程的工作内存；
②加一：
③写回主内存同步数据
不保障原子性就是 – 可能会在线程操作的过程中会有数据抢占；
随时可能会被打断；
### 怎么解决 volatile 的不保障原子性状况：
①加 synchronized 的同步机制锁（太重啦）
留神：atomicInteger 的底层就是 CAS（比拟并替换）的；②juc 中的 atomic 包中的一个 atomicInteger 的类，办法是一个 atomicInteger.getAndIncrement(); // 每次加 1 - 保障原子性的加 1
上面是代码展现：
demo：
package com.atguigu;
import com.sun.org.apache.xpath.internal.operations.Variable;
import javax.lang.model.element.VariableElement;
import java.util.concurrent.atomic.AtomicInteger;
class VolatileTest2{
// 资源类
volatile int a; // 全局变量的默认为 0
public void addPlusPlus(){this.a++;}
// 解决的是 volatile 不保障原子性的 AtomicInteger
//AtomicInteger 是 java.util.concurrent.atomic 原子包写的类
AtomicInteger atomicInteger=new AtomicInteger();
public void addMyatomic(){atomicInteger.getAndIncrement(); // 每次加 1 - 保障原子性的加 1
/**
* Atomically increments by one the current value.
* 原子性减少 1
* @return the previous value
*/
/*public final int getAndIncrement() {return unsafe.getAndAddInt(this, valueOffset, 1);
}*/
}
}
public class VolatileNoAtomic {
//volatile 不保障原子性的小李子
public static void main(String[] args) {
//1. 创立资源类的对象
VolatileTest2 volatileTest2=new VolatileTest2();
//2. 创立线程 - 开始循环 -
for(int i=1;i<=30;i++) {new Thread(()->{for (int j = 0; j <100 ; j++) {volatileTest2.addPlusPlus();
volatileTest2.addMyatomic();}
},String.valueOf(i)).start();}
//3.main 线程是在 a ++ 之中有感知的,
System.out.println(Thread.currentThread().getName()+"addPluePlus"+":"+volatileTest2.a);
// 得出加过后的最初的值 atomiceInteger
System.out.println(Thread.currentThread().getName()+"atomicInteger"+":"+volatileTest2.atomicInteger);
/* mainaddPluePlus:2797
mainatomicInteger:3000
*/
// 底层就是 CAS 的；atomicInteger.getAndIncrement()}
}
禁止指令重排
禁止指令重排序（保障有序的执行），不会像 A ++ 那样去在指令转化给 CPU 的时候调换地位，
最终放弃平安，原子性的同步机制 volatile，可见性
个别在什么中央会用到 volatile（可见性）：面试的时候，
对于 volatile 的线程的细节，我整顿了一个图用来了解，
高清版：Volatile 要害的深刻解析：
## 总结
线程平安，分为同步数据的加锁，和数据可见的原子操作，也就是当同一时间只容许一个线程去改主线程上的公共数据，（而且这个数据是最新的）；对于数据可见性，和原子操作咱们通过 volatile 理解了，那下一期咱们来具体聊聊 加锁后的线程 是如何工作的。
我是卢卡，致力做一个不甘平庸的逆袭者，大家晚安了。
