Java多线程（四）线程安全以及同步

线程安全

线程安全性的定义：

当多个线程访问某一个类时， 这个类始终能表示出正确的行为， 那么就称这个类是线程安全的。

竞态条件：当多个线程同时访问同一个资源，其中的一个或者多个线程对这个资源进行了写操作，对资源的访问顺序敏感，就称存在竞态条件。多个线程同时读同一个资源不会产生竞态条件。
临界区：导致竞态条件发生的代码区称作临界区。在临界区中使用适当的同步就可以避免竞态条件。
基本上所有的并发模式在解决线程安全问题时，都采用“序列化访问临界资源”的方案，即在同一时刻，只能有一个线程访问临界资源，也称作同步互斥访问。
通常来说，是在访问临界资源的代码前面加上一个锁，当访问完临界资源后释放锁，让其他线程继续访问。

其产生的原因可以归结如下：
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 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 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 arrayList;

    public int HP = 100;

    public Son(ArrayList 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;