JavaEE______多线程3

一. 线程安全问题

概念: 程序在多线程的执行环境下，线程的执行结果不符合预期
线程不安全因素：

1）抢占式执行（狼多肉少–CPU少线程多）

2）多个线程同时修改了同一个变量

3）操作是非原子性操作

例·：temp-- 是非原子性操作

1. 查询temp当前值
2. temp-1 操作
3. 刷新temp最新值

4）内存可见性问题**

Java内存模型（JMM) ：Java虚拟机规范中定义了Java内存模型
目的是屏蔽掉各种硬件和操作系统的内存访问差异，以实现让Java程序在各种平台下都能达到一致的并发效果。

a. 线程之间的共享变量存在 主内存 （Main Memory）
b. 每一个线程都有自己的“工作内存”（Working Memory）
c. 当线程要读取一个共享变量的时候，会先把变量从主内存拷贝到工作内存，再从工作内存读取数据
d. 当线程要修改一个共享变量的时候，也会先修改工作内存中的副本，再同步回主内存
由于每个线程有自己的工作内存，这些工作内存中的内容相当于一个共享变量的“副本”，此时修改线程1的工作内存中的值，线程2的工作内存不一定会及时变化

import java.time.LocalDateTime;

public class ThreadDemo14 {
    private static boolean flag = true;

    public static void main(String[] args) {

        //创建子线程1
        Thread t1 = new Thread(()->{
            System.out.println("线程1开始执行" + LocalDateTime.now());
            while (flag){

            }
            System.out.println("线程1：执行结束！" + LocalDateTime.now());
        });
        t1.start();

        Thread t2 = new Thread(()->{
            //休眠1s
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("线程2：修改flag=false" + LocalDateTime.now());
            flag = false;

        });
        t2.start();
    }
}

线程1一直子在执行，它并没有感知到全局变量flag的变化，这是内存可见性问题（因为线程2早已经把全局变量修改成另外一个值了）

5）指令重排序

JVM在运行期间对代码（指令）进行重排序

二. volatile 解决内存可见性问题和指令重排序问题

volatile 可以解决内存可见性和指令重排序的问题，
代码在写入 volatile 修饰的变量的时候：
（1）改变线程工作内存中 volatile变量副本的值。
（2）将改变后的副本的值从工作内存刷新到主内存。
代码在读取 volatile 修饰的变量的时候：
（1）从主内存中读取 volatile 变量的最新值到线程的工作内存中。
（2）从工作内存中读取 volatile变量的副本。

2. volatile 缺点

volatile 并不能解决原子性问题，它只能解决内存可见性问题和指令重排序问题
结论：volatile 并不能完全解决线程安全问题。

三. 锁（synchronized 和 lock）！！！

使用锁是Java中解决线程安全问题最主要的手段

3.1 内置锁synchronized

3.1.1 基本使用：

（1）修饰静态方法

（2）修饰普通方法

（3）修饰代码块
a) this(非静态方法）
b) xxx.class
c) 自定义锁对象

注意事项：

1. synchronixed 时，一定要注意，对于同一个业务的多个线程加锁对象，一定要是同一个对象（加同一把锁）
2. synchronized修饰代码块，代码块在静态方法中时，不能使用 this 对象。
   

/*
* 修饰代码块
*/
public class ThreadSynchorized3 {
    private static int number = 0;
    static class Counter {

        //循环次数
        private static int MAX_COUNT = 100000;

        //自定义锁对象(属性名可自定义
        private Object mylock= new Object();


        //++方法
        public void incr() {
            for (int i = 0; i < MAX_COUNT; i++) {
                synchronized (mylock) {
                    number++;
                }
            }
        }

        //--
        public void decr() {
            for (int i = 0; i < MAX_COUNT; i++) {
                synchronized (mylock) {
                    number--;
                }
            }
        }
    }
    public static void main(String[] args) throws InterruptedException {
        ThreadSynchronized2.Counter counter = new ThreadSynchronized2.Counter();
        Thread t1 = new Thread(()->{
            counter.incr();
        });
        t1.start();

        Thread t2 = new Thread(()->{
            counter.decr();
        });
        t2.start();

        //等待线程执行完成
        t1.join();
        t2.join();
        System.out.println("最终的结果： " + number);
    }
}

3.1.2 synchronized 特性

a. 互斥

synchronized 会起到互斥效果，某个线程执行到某个对象的synchronized 中时，其他线程如果也执行到同一个对象 synchronized 就会阻塞等待。
（1）进入synchronized 修饰的代码块 相当于 加锁
（2）退出 synchronized 修饰的代码块 相当于 解锁

进入方法内部加锁,方法执行完毕解锁
synchronized 用的锁是存在Java对象里头的

注意：

1. 上一个线程解锁之后，下一个线程并不是立即就能获取到锁，而是要靠操作系统来”唤醒“，这也就是操作系统线程调度的一部分工作。
2. 假设有 A、B、C三个线程，线程A先获取到锁，然后B尝试获取锁，然后C再尝试获取锁，此时B和C都在阻塞队列中排队等待，但是当A释放锁之后，虽然B比C先来的，但是B不一定就能获取到锁，而是和C重新竞争，并不遵守先来后到的规则，因为synchronized是非公平锁。

b.刷新内存

可以解决内存可见性问题
synchronized 的工作过程：

1. 获得互斥锁
2. 从主内存拷贝变量的最新副本到工作内存
3. 执行代码
4. 将更改后的共享变量的值刷新到主内存
5. 释放互斥锁

c. 可重入

synchronized同步块对同一条线程来说是可重入的，不会出现自己把自己锁死的问题。

public class ThreadSynchronized4 {
    public static void main(String[] args) {
        synchronized (ThreadSynchronized4.class){
            System.out.println("当前主线程已经得到了锁");
            synchronized (ThreadSynchronized4.class){
                System.out.println("当前主线程再次得到了锁");
            }
        }
    }
}

3.1.3 synchronized 底层实现和运行原理

想了解synchronized 是如何运行的？就要先搞清楚synchronized是如何实现的？
synchronized 同步锁是通过JVM内置的Monitor 监视器实现的，而监视器又是依赖操作系统的互斥锁Mutex 实现的。
监视器：监视器是一个概念或者而说是一个机制，它用来保障在任何时候，只有一个线程能够执行指定区域的代码。

3.2 可重入锁 Lock(ReentrantLock)