线程安全
线程安全性的定义：
当多个线程访问某一个类时， 这个类始终能表示出正确的行为， 那么就称这个类是线程安全的。
竞态条件：当多个线程同时访问同一个资源，其中的一个或者多个线程对这个资源进行了写操作，对资源的访问顺序敏感，就称存在竞态条件。多个线程同时读同一个资源不会产生竞态条件。
临界区：导致竞态条件发生的代码区称作临界区。在临界区中使用适当的同步就可以避免竞态条件。
基本上所有的并发模式在解决线程安全问题时，都采用“序列化访问临界资源”的方案，即在同一时刻，只能有一个线程访问临界资源，也称作同步互斥访问。
通常来说，是在访问临界资源的代码前面加上一个锁，当访问完临界资源后释放锁，让其他线程继续访问。
其产生的原因可以归结如下：
1.共享数据： 只有共享的数据才会产生带来安全性问题。 如果是方法内部声明的变量， 其是在虚拟机栈中， 为每个线程独享， 不存在安全性问题。
2.多个线程对共享数据进行同时操作。多线程对同一共享数据进行同时性的操作，此时共享数据就会影响到彼此。
示例
爸爸妈妈打儿子，儿子血量为100，爸爸打一下掉3滴血，妈妈打掉2滴血，打到血量为0为止。
首先定义Person抽象类，继承Thread类并定义Calltoback接口用于中断线程，定义Hitting方法用于扣血。
public abstract class Person extends Thread {
public abstract void Hitting();
@Override
public void run() {
super.run();
}
// 在需要回调数据的地方（两个子类需要），声明一个接口
public static interface Calltoback {
void dead();
}
// 2.创建接口对象
public Calltoback calltoback;
}
Calltoback 接口实现类
/**
* 回调接口
*/
public class StopHitting implements Person.Calltoback {
Person person;
public StopHitting(Person person) {
this.person = person;
}
@Override
public void dead() {
person.interrupt();
}
}
Main主类，实现儿子，父母类，以及击打掉血方法。
public class Main {
public static void main(String[] args) {
ArrayList<String> arrayList = new ArrayList<>();
Son son = new Son(arrayList);
Father father = new Father(son, arrayList);
Monther monther = new Monther(son, arrayList);
StopHitting stopHittingFather = new StopHitting(father);//判断结束终止线程
StopHitting stopHittingMonther = new StopHitting(monther);//判断结束终止线程
father.calltoback = stopHittingFather;
monther.calltoback = stopHittingMonther;
father.start();
monther.start();
}
public static void println(ArrayList<String> arrayList) {
for (String s : arrayList) {
System.out.println(s);
}
}
}
class Father extends Person {
Son son;
ArrayList arrayList;
public Father() {
}
public Father(Son son, ArrayList arrayList) {
this.son = son;
this.arrayList = arrayList;
Thread.currentThread().setName("爸爸");
}
@Override
public void Hitting() {
son.ReduceHP(3);
// System.out.println("爸爸打的，还剩" + son.HP)
}
@Override
public void run() {
super.run();
this.setName("爸爸");
while (!isInterrupted()) {
if (son.HP <= 0 && calltoback != null) {
calltoback.dead();//结束线程
Main.println(arrayList);
}else {
Hitting();
}
}
}
}
class Monther extends Person {
Son son;
ArrayList arrayList;
public Monther() {
}
public Monther(Son son, ArrayList arrayList) {
this.son = son;
this.arrayList = arrayList;
Thread.currentThread().setName("妈妈");
}
@Override
public void Hitting() {
son.ReduceHP(2);
}
@Override
public void run() {
super.run();
this.setName("妈妈");
while (!isInterrupted()) {
if (son.HP <= 0 && calltoback != null) {
calltoback.dead();//结束线程
// Main.println(arrayList);
}else {
Hitting();
}
}
}
}
class Son {
ArrayList<String> arrayList;
public int HP = 100;
public Son(ArrayList<String> arrayList) {
this.arrayList = arrayList;
}
public void ReduceHP(int hp) {
try {
sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
this.HP -= hp;
arrayList.add(Thread.currentThread().getName() + "打的，还剩" + HP);
}
}
打印出结果会出现重复值，即爸爸妈妈打了后血量一样的情况，出现这种情况是因为儿子血量没有同步造成的，原理就涉及到Java内存模型(JMM)，不做展开。
造成这个错误的本质原因：
（1）可见性，工作内存的最新值不知道什么时候会写回主内存
（2）有序性，线程之间必须是有序的访问共享变量，我们用“视界”这个概念来描述一下这个过程，以B线程的视角看，当他看到A线程运算好之后，把值写回之内存之后，马上去读取最新的值来做运算。A线程也应该是看到B运算完之后，马上去读取，在做运算，这样就得到了正确的结果。
解决方案：
对掉血方法加synchronized 修饰符
由 synchronized 修饰的代码块以原子方式（一组语句组成一个不可分割的单元）执行。 任何执行同步代码块的线程， 都看不到其他线程正在执行的由同一个锁保护的同步代码块。
synchronized 的使用有如下三种方式：
- 普通同步方法，锁是当前实例对象(this);
- 静态同步方法，锁是当前类的 Class 对象;
- 同步代码块，锁是括号里面的对象。
public synchronized void ReduceHP(int hp)
对HP变量加volatile关键字
加上volatile关键字，就保证了可见性。
volatile是java中较轻量的同步原语，用volatile声明的变量保证了该变量的可见性， 使用volatile声明的变量被其他线程更改时，该变量会立即被写入内存，同时 CPU会锁住总线，将缓存同步指令传递到其他处理器，其他处理器会从主内存中获取该变量的最新值更新到自己的缓存中。
public volatile int HP = 100;
