多线程基础

并发编程基础：

线程状态（NEW、RUNNABLE、BLOCKED、WAITING、TIME_WAITING、TERMINATED）

NEW：初始状态，线程被构建，但是还没有调用 start 方法
RUNNABLED：运行状态，JAVA 线程把操作系统中的就绪和运行两种状态统一称为“运行中”
BLOCKED：阻塞状态，表示线程进入等待状态,也就是线程因为某种原因放弃了 CPU 使用权。该状态只有在遇到Synchronized的时候，且没有抢占到锁，才会进入。
- 同步阻塞：运行的线程在获取对象的同步锁时，若该同步锁被其他线程锁占用了，那么 jvm 会把当前的线程放入到锁池中
WAITING：等待，运行的线程执行 wait 方法，jvm 会把当前线程放入到等待队列;
运行的线程执行 Thread.sleep 或者 t.join 方法，或者发出了 I/O请求时，JVM 会把当前线程设置为等待状态，当 sleep 结束、join 线程终止、io 处理完毕则线程恢复;
TIME_WAITING：超时等待状态，超时以后自动返回
TERMINATED：终止状态，表示当前线程执行完毕

线程状态调用关系图：

跟踪线程：

打开终端或者命令提示符，键入“jps”，（JDK1.5 提供的一个显示当前所有 java进程 pid 的命令），可以获得相应进程的 pid
根据上一步骤获得的 pid，继续输入 jstack pid（jstack 是 java 虚拟机自带的一种堆栈跟踪工具。jstack 用于打印出给定的 java 进程 ID 或 core file 或远程调试服务的 Java 堆栈信息）

线程终止：

stop (暴力停止，已经被淘汰)
interrupt
- interrupt：更改中断标记，唤醒处于阻塞状态下的线程
- interrupted：返回中断标记，然后复位
- isinterrupted: 返回中断标记

public class InterruptDemo implements Runnable {
    @Override
    public void run() {
        while (!Thread.currentThread().isInterrupted()) {//获取中断标记，默认是false
            try {
                TimeUnit.SECONDS.sleep(10);
                System.out.println("正常执行");
            } catch (InterruptedException e) {
                //有一个默认操作，复位
                //复位 false
                Thread.currentThread().interrupt();//true
                e.printStackTrace();
             // System.out.println(Thread.interrupted()); //再次复位
            }
            System.out.println("线程循环");
        }
        System.out.println("结束");
    }

    public static void main(String[] args) {
        Thread thread = new Thread(new InterruptDemo01());
        thread.start();
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        thread.interrupt();
    }
}

线程复位：

Thread.interrupted();
抛出异常InterruptedException
在InterruptedException 抛出之前，JVM 会先把线程的中断标识位清除，然后才会抛出 InterruptedException，这个时候如果调用 isInterrupted 方法，将会返回 false
volatile方法

public class VolatileDemo {
    private volatile static boolean stop=false;
        public static void main(String[] args) throws InterruptedException {
            Thread thread=new Thread(()->{
                int i=0;
                while(!stop){
                i++;
            }
        });
        thread.start();
        System.out.println("begin start thread");
        Thread.sleep(1000);
        stop=true;
    }
}

线程安全性问题

cpu高速缓存

L1 Cache，一级缓存，本地 core 的缓存，分成 32K 的数据缓存 L1d 和 32k 指令缓存 L1i，访问 L1 需要 3cycles，耗时大约 1ns；
L2 Cache，二级缓存，本地 core 的缓存，被设计为 L1 缓存与共享的 L3 缓存之间的缓冲，大小为 256K，访问 L2 需要 12cycles，耗时大约 3ns；
L3 Cache，三级缓存，在同插槽的所有 core 共享 L3 缓存，分为多个 2M 的段，访问 L3 需要 38cycles，耗时大约 12ns；

缓存一致性

缓存没有更新，所以仍然是之前的值，就会导致数据不一致的问题

总线锁
缓存锁

缓存一致性（MESI 协议）

M(Modified) 修改缓存，当前 CPU 缓存已经被修改，表示已经和内存中的数据不一致了
I(Invalid) 失效缓存，说明 CPU 的缓存已经不能使用了
E(Exclusive) 独占缓存，当前 cpu 的缓存和内存中数据保持一直，而且其他处理器没有缓存该数据
S(Shared) 共享缓存，数据和内存中数据一致，并且该数据存在多个cpu缓存中

cpu的优化执行

指令重排

内存模型

限制处理器优化
使用内存屏障

JMM模型：内存模型可以理解为在特定的操作协议下，对特定的内存或者高速缓存进行读写访问的过程抽象描述，不同架构下的物理机拥有不一样的内存模型，Java虚拟机是一个实现了跨平台的虚拟系统，因此它也有自己的内存模型，即Java内存模型（Java Memory Model, JMM）。

在 JMM 抽象模型中，JMM定义了线程和主内存之间的抽象关系：线程之间的共享变量存储在主内存（main memory）中，每个线程都有一个私有的本地内存（local memory），本地内存中存储了该线程以读/写共享变量的副本。本地内存是JMM的一个抽象概念，并不真实存在。本地内存它涵盖了缓存，写缓冲区，寄存器以及其他的硬件和编译器优化之后的一个数据存放位置

JMM模型目的是保证并发编程场景中的原子性、可见性和有序性

posted @ 2019-10-29 21:17 snail灬阅读(111) 评论(0) 编辑收藏举报

刷新页面返回顶部

snail