三、并发安全

线程间的共享

一、synchronized 内置锁

Java语言的关键字
作用：多个线程在同一时刻只能有一个线程进入这个方法或者代码块中。可以保证线程对于变量或者属性的原子性和可见性、排他性。
用处：作用于代码块或者方法上，进行修饰
synchronized关键字本质上是把对象做了一把锁，在代码块中需要对当前对象进行加锁，在方法上加锁缺省是对这个类的当前实例加锁，所以synchronized加的锁不是在方法上也不是在代码块上，本质上是在类的当前实例上。

加锁
synchronized关键字锁的是对象，锁的对象不同，线程就可以并行地执行

二、对象锁

首先先来运行两段代码

代码1

package com.tinner.thread;

/**
 * @Author Tinner
 * @create 2019/9/20 17:33
 */
public class DiffObj {
    private static class Obj1 implements Runnable{

        private DiffObj diffObj;

        public Obj1(DiffObj diffObj) {
            this.diffObj = diffObj;
        }

        @Override
        public void run() {
            System.out.println("TestObj1 is running ...." + diffObj);
            diffObj.instance();
        }
    }

    private static class Obj2 implements Runnable{

        private DiffObj diffObj;

        public Obj2(DiffObj diffObj) {
            this.diffObj = diffObj;
        }

        @Override
        public void run() {
            System.out.println("TestObj2 is running ...." + diffObj);
            diffObj.instance2();
        }
    }

    private synchronized void instance(){
        try {
            Thread.sleep(3000);
            System.out.println("synInstance1 is going..." + this.toString());
            Thread.sleep(3000);
            System.out.println("synInstance1 ended + " + this.toString());
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

    }

    private synchronized void instance2(){
        try {
            Thread.sleep(3000);
            System.out.println("synInstance2 is going..." + this.toString());
            Thread.sleep(3000);
            System.out.println("synInstance2 ended + " + this.toString());
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) throws InterruptedException {
        DiffObj instance1 = new DiffObj();
        Thread t3 = new Thread(new Obj2(instance1));
        DiffObj instance2 = new DiffObj();
        Thread t4 = new Thread(new Obj1(instance1));
        //Thread t4 = new Thread(new Obj1(instance2));
        t3.start();
        t4.start();
        Thread.sleep(1000);
    }
}

运行结果1

同一实例

代码2

修改main方法

public static void main(String[] args) throws InterruptedException {
        DiffObj instance1 = new DiffObj();
        Thread t3 = new Thread(new Obj2(instance1));
        DiffObj instance2 = new DiffObj();
        //Thread t4 = new Thread(new Obj1(instance1));
        Thread t4 = new Thread(new Obj1(instance2));
        t3.start();
        t4.start();
        Thread.sleep(1000);
    }

运行结果2

不同实例

总结

比较两个运行结果，可以发现第一个方式是第一个线程执行完毕之后才执行第二个线程；第二个方式基本上是两个线程同时开始同时结束的。锁的实例不一样，也是可以并行的，只有两个线程锁的对象的实例是相同的时候，才能达到synchronized 那种效果。

三、类锁

将synchronized关键字加在一个类的static方法上的时候，才算是一个类锁。
类锁和对象锁之间还是可以相互的并行执行的。

代码

/**
 *类说明：演示实例锁和类锁是不同的，两者可以并行
 */
public class InstanceAndClass {
    
    private static class SynClass extends Thread{
        @Override
        public void run() {
            System.out.println("TestClass is running...");
            synClass();
        }
    }

    private static class ObjSyn implements Runnable{
        private InstanceAndClass SynClassAndInstance;

        public ObjSyn(InstanceAndClass SynClassAndInstance) {
            this.SynClassAndInstance = SynClassAndInstance;
        }

        @Override
        public void run() {
            System.out.println("TestInstance is running..."+SynClassAndInstance);
            SynClassAndInstance.instance();
        }
    }

    //实例方法
    private synchronized void instance(){
        SleepTools.second(1);
        System.out.println("synInstance is going..."+this.toString());
        SleepTools.second(1);
        System.out.println("synInstance ended "+this.toString());
    }

    //静态方法
    private static synchronized void synClass(){
        SleepTools.second(1);
        System.out.println("synClass going...");
        SleepTools.second(1);
        System.out.println("synClass end");
    }

    public static void main(String[] args) {
        InstanceAndClass synClassAndInstance = new InstanceAndClass();
        Thread t1 = new SynClass();
        Thread t2 = new Thread(new ObjSyn(synClassAndInstance));
        t2.start();
        SleepTools.second(1);
        t1.start();
    }
}

运行结果

类锁

可以发现，这两个进程是可以并行执行的。

注意:

synchronized关键字只能锁对象，但是在类锁中，synchronized关键字明明用到了static方面，那么它锁的是这个class对象。当我们需要创建一个对象的实例的时候，虚拟机会进行一个类加载的过程，每一个类在虚拟机里面都有一个唯一的class对象。synchronized本质上锁的是每个类所独有的class对象。
那么就可以知道，instance方法锁的是实例对象，synClass方法锁的是类的对象，本质上他们锁的也是两个完全不同的对象，所以可以并行执行。

结论

从严格意义上来讲，类锁只是一个概念上的东西，并不是真实存在的。本质上锁的是类的class对象。而且类锁和对象锁之间也是互不干扰的。

四、volatile关键字，最轻量的同步机制

保证了变量的可见性。但是并没有提供变量的原子性，不能够保证复杂计算的时候数据的正确性。

代码1

/**
 * 类说明：演示Volatile的提供的可见性
 */
public class VolatileCase {
    private static boolean ready;
    private static int number;

    //
    private static class PrintThread extends Thread{
        @Override
        public void run() {
            System.out.println("PrintThread is running.......");
            while(!ready);//无限循环
            System.out.println("number = "+number);
        }
    }

    public static void main(String[] args) {
        new PrintThread().start();
        SleepTools.second(1);
        number = 51;
        ready = true;
        SleepTools.second(5);
        System.out.println("main is ended!");
    }
}

运行这段代码，可以看到内存飙升，程序根本停不下来，原因就是主方法中修改了ready变量的值之后，在线程中检测不到ready的变化，所以程序会一直运行下去

稍作修改

当我们给ready变量加一个volatile关键字之后

private static volatile boolean ready;

可以看到系统正常运行了，正常停止

volatile关键字作用

题外话

当我们不加volatile关键字，而是在无限循环中去加入一条打印语句的时候，看代码：

public class VolatileCase {
    private static boolean ready;
    private static int number;

    //
    private static class PrintThread extends Thread{
        @Override
        public void run() {
            System.out.println("PrintThread is running.......");
            while(!ready){
                //无限循环
                System.out.println("jinping");

            }
            System.out.println("number = "+number);
        }
    }

    public static void main(String[] args) {
        new PrintThread().start();
        SleepTools.second(1);
        number = 51;
        ready = true;
        SleepTools.second(5);
        System.out.println("main is ended!");
    }
}

运行结果

i题外话运行结果
可以看到程序正常的停止了。
为什么会出现这种现象呢？我并没有加volatile关键字啊
我们仅仅在无限循环中加了一个普通的打印语句，这个打印语句中牵涉到了synchronized关键字的内存语义。
image.png
说起来就要扯到JMM的内存模型中去了，synchronized关键字在内存语义上面强制要求把共享变量刷回到主内存，以及强制将使用的这个变量读到当前工作的内存上去。

最常见的适用场景：一个线程写，多个线程读

五、什么是线程安全？怎么才能做到线程安全？

什么是线程安全
如果说有多个线程访问同一个类的实例的时候，不管运行环境如何，我们的类的实例都能表现出正确的预期结果及行为，这就是线程安全。
实现线程安全的方式
其实本质上线程安全就是解决“修改--共享变量”的问题

• 栈封闭（线程封闭）
  栈封闭就是让变量或者实例变得不可共享。在我们运行任何一个线程的时候，JDK都会为每一个线程分配一个栈，栈和程序计数器是每一个线程所独有的，其他线程看不到。堆和方法区是线程之间共享的。既然栈是每个线程所独有的，那么将栈封闭，里面的变量就不会被共享。比如：局部变量。
  实际开发过程中，多使用局部变量，少使用全局变量。
• 无状态的类
  Java语言中，没有成员变量的类，就是无状态的类，只有方法。那么这种类就是线程安全的。
• 让类不可变
  让这个类的所有的属性加final关键字。但是如果这个类中的成员变量中是个对象的话，这个属性还是不安全的。因为虽然final关键字修饰了实体类，但是它修饰的只是这个实体类的引用（修饰了之后引用不可变）。但是不代表这个类在堆上的实例的内容不可变。
  不可变类
  还有一种只提供读的方法，不提供写的方法，外面写不动。

/**
 * 类不可变--事实不可变
 */
public class ImmutableClassToo {
    private final List<Integer> list = Arrays.asList(1,2,3);

    public boolean isContain(int i){
        return list.contains(i);
    }
}

• volatile
  如果只是简单的set和get方法，可以使用该关键字。但是如果是++等操作，不适用。
• 加锁和CAS
• 安全的发布
  写下代码自己体会

/**
 * 不安全的发布
 */
public class UnsafePublish {
    private List<Integer> list = new ArrayList<>(3);
    
    public UnsafePublish() {
        list.add(1);
        list.add(2);
        list.add(3);
    }
    
    public List getList() {
        return list;
    }

    public static void main(String[] args) {
        UnsafePublish unSafePublish = new UnsafePublish();
        List<Integer> list = unSafePublish.getList();
        System.out.println(list);
        list.add(4);
        System.out.println(list);
        System.out.println(unSafePublish.getList());
    }
}

/**
 * 安全的发布
 */
public class SafePublishToo {
    private List<Object> list
            = Collections.synchronizedList(new ArrayList<>(3));

    public SafePublishToo() {
        list.add(1);
        list.add(2);
        list.add(3);
    }

    public List getList() {
        return list;
    }

    public static void main(String[] args) {
        SafePublishToo safePublishToo = new SafePublishToo();
        List<Integer> list = safePublishToo.getList();
        System.out.println(list);
        list.add(4);
        System.out.println(list);
        System.out.println(safePublishToo.getList());
    }
}

Collections.synchronizedList()包装好的线程安全的。
自己封装

/**
 * 仿Collections对容器的包装，将内部成员对象进行线程安全包装
 */
public class SoftPublicUser {
    private final UserVo user;

    public UserVo getUser() {
        return user;
    }

    public SoftPublicUser(UserVo user) {
        this.user = new SynUser(user);
    }

    private static class SynUser extends UserVo{
        private final UserVo userVo;

        private final Object lock = new Object();

        public SynUser(UserVo userVo){
            this.userVo = userVo;
        }

        public int getAge() {
            synchronized (lock){
                return userVo.getAge();
            }
        }

        public void setAge(int age) {
            synchronized (lock){
                userVo.setAge(age);
            }
        }
    }
}

• ThreadLocal（线程封闭）