Java多线程笔记[未更新完]

最近课上可摸鱼时间较多，因此并发开坑学习

本篇学习自Java多线程编程实战指南

目前进展：刚开坑，处于理解概念阶段

---

本篇学习自Java多线程编程实战指南

Q.进程和线程的区别

进程Process是程序运行的实例，在Java的范畴中，运行一个Java程序的实质是启动一个JVM进程，也就是一个运行的Java程序就是一个Java虚拟机进程（Java Web服务器是一个进程同时运行多个Java Web应用）

进程是程序向操作系统申请资源（内存空间、文件句柄等）的基本单位，而线程Thread是进程中可独立运行的最小单位，一个进程可以包含多个线程，同一个进程中的所有线程共享该进程的资源，

Q.extends Thread 和 Runnable的区别

1.面向对象来看，前者是继承实现，后者是组合实现，因此后者有更低的耦合程度

2.从对象共享来看，Runnable意味着多个线程可共享同一个Runnable实例

一种具有迷惑性的例子，在例子中两种非空构造的Thread构造都可以有一致的hashCode的原因是构造声明是Thread(Runnable)，而Thread的JDK声明是public class Thread implements Runnable，后两种例子都是体现Runnable的特性而非区分两者

class XjbThreadImpl implements Runnable {

    public void run() {
        System.out.println("Implements: "+this.hashCode());
    }
}

class XjbThreadExt extends Thread {

    public void run() {
        System.out.println("Extends: "+this.hashCode());
    }
}
//
public class Main {

   public static void main(String[] args) {
        for(int i = 0; i < 2; i++) {
            new Thread(new XjbThreadImpl()).start();
            new Thread(new XjbThreadExt()).start();
        }
        // 使用时请分别注释上下两部分
        Runnable tmpImpl = new XjbThreadImpl();
        Thread impl0 = new Thread(tmpImpl);
        Thread impl1 = new Thread(tmpImpl);
        Thread tmpExt = new XjbThreadExt();
        Thread ext0 = new Thread(tmpExt);
        Thread ext1 = new Thread(tmpExt);
        impl0.start();
        impl1.start(); //hashCode一致
        ext0.start();
        ext1.start(); //hashCode一致
   }
}

3.从创建成本来看，创建线程实例比Runnable成本更高，JVM需要为它分配调用栈空间、内核线程等资源

Java的线程分为守护线程（Daemon）和用户线程，前者用于执行重要性不高的任务，后者反之，且只有当所有用户进程结束后JVM才会正常停止（System.exit调用除外）

Thread的方法

.join() 等待相应进程结束/ yield()当前线程主动放弃处理器的占用

Q.线程的生命周期状态

NEW 已创建而为启动的线程，线程只有一次机会处于该状态

RUNNABLE 包括两个自状态READY和RUNNING，前者表示处于改状态的线程可以被Scheduler调度而处于RUNNING。后者表示正在运行（即run正在被处理器执行），可以使用yield()返回到READY。（活跃子状态）

BLOCKED 线程发起阻塞式IO或申请锁（被其他线程占有）时处于该状态，该状态不占用处理器资源。当完成阻塞式IO操作或获得锁时重新回到RUNNALE

WAITING 线程执行特定方法后处于等待其他线程执行另外特定操作的状态。比如Object.wait(),Thread.join(),LockSupport.park(Object)可以获得该状态，返回RUNNABLE的方法有Object.notify()/notifyAll(),LockSupport.unpark(Object)

TIMED_WAITING有时间限制的等待状态，如Thread.sleep(long),Object.wait(long)，超时自动返回RUNNABLE

TERMINATED 已经执行结束的进程处于该状态（只有一次），既Thread.run()调用结束、

Q.并发与并行的区别

并行Parallel多个线程在同一时刻处理任务

并发Concurrent单个线程交替的完成不同任务

（书里说的还是不太明确，下次查查别的资料）

竞态指计算的正确性依赖相对时间顺序或者线程的交错，容易产生脏读问题（读取到一个过世的数据、丢失更新）

竞态的模式：read-modify-write（比如a++）和check-then-act（比如对变量的if-else），注意这些都是对于共享变量而言的，局部变量（如形参）和synchronized不会造成竞态

PS.提一下a++的过程，1.read:将变量a的值从内存读到寄存器r中,2.将寄存器r的值+1,3.将寄存器r的内容写入变量a对应的内存空间

如果某线程在执行到第二步的时候变量a的值已经更新了，那它就是脏读（旧数据），接着到第三部覆盖到内存空间的操作就是丢失更新

解决竞态：上锁/局部变量 （Q.有没有更好的方法？

竞态不一定会造成错误结果，拿上面的模式来说，如果是交错执行read(Thread-0)-read(Thread-1)或者check(Thread-0)-check(Thread-1)，很显然结果依然正确

Synchronized使修饰的方法在任一时刻只能被一个线程执行

Q.什么是线程安全

如果一个类在单线程环境下额能够正常运行，并且在多线程环境下，使用方不必为其做任何改变的情况下也能运行正常，那就称其线程安全

线程安全表现在原子性、可见性和有序性

原子性：说白了就是“不可分割”，细分为两层含义

1.对于涉及共享变量的操作，在操作以外的线程看来是不可分割的，那就是原子操作（尽管对于正在执行的线程来说是分很多步骤，但在外界看来该操作要么尚未开始，要么已经结束）

2.访问同一组共享变量的非只读原子操作是不能被线程交错执行的

原子性只在多线程以及线程共享的变量以下讨论才有意义

实现原子性的两种Solutions：1.Lock软件实现锁 2.CAS硬件实现锁

Java语言规范中规定6种基础类型的变量和引用变量的写操作都是原子性的

（long/double除外,原因是32位的JVM对64位的写操作可能会分解成低32和高32处理，还是有冲突的可能，好消息是volatile下是确保原子性的）

PS.关于读写的原子性和volatile的关系

1.volatile只保证变量写操作的原子性，不保证两种竞态模式的原子性

2.Java针对任何变量的读操作均符合原子性

Q.你tm还记得哪8种基础类型吗

A.byte boolean short char int long float double

可见性：多线程环境下，一个线程对某个共享变量进行更新后，后续访问该变量的县城可能无法立刻读取该更新的结果（可能永远读取不了），读取不了则是不可见

问题产生的可能：JIT优化对多线程造成不利（书里提了个循环不变式外提的优化，水平太菜不敢评论）、共享变量分配到寄存器（两个线程运行在不同处理器上，一个处理器无法读取另一个处理器的寄存器）等

保证可见性:volatile

volatile作用之一是提示JIT编译器被修饰的变量可能被多个线程共享，阻止不恰当的优化

另一作用是读取volatile关键字修饰的变量会使相应的处理器执行刷新处理器缓存的动作（停留在写缓冲器是不可见的，要求被写入到高速缓存或主内存）

可见性只保证线程能读取到相对新值（更新后其他线程能得到更新后的值），不保证最新值（读取该变量的线程在读取使用时其它线程无法更新，该线程读取到的相对新值为最新值）

PS.单处理器也会存在可见性问题

虽然寄存器都在同一处理器中，但多线程是通过时间片 分配实现的，在上下文切换的过程中，一个线程对寄存器变量的修改会被线程上下文保存，另一线程无法得知该修改

有序性：（玄学

volatile的另一作用是禁止重排序，保证有序性

PS.我用不大准确的词语归纳一下

原子性：线程之间是否能任意穿插

可见性：线程执行中是否时刻得知更新

上下文切换：多个线程共享同一个处理器，不同线程被选中开始或继续执行实现并发，切入切出过程中需要保存和恢复相应进程的进度信息（执行到哪一条指令）称为上下文，一般包括通用寄存器和程序计数器的内容

在Java的角度来看，从RUNNABLE到非RUNNABLE状态的切换过程就是一个上下文切换（暂停or恢复）

自发性上下文切换可从线程的状态转移图（各种方法、锁、IO）得出

非自发性上下文切换由线程调度器引起，比如GC过程对JVM堆进行整理时要求停止所有应用线程

然而，上下文切换是需要开销的，因此并非线程越多越厉害，计算效率可能更加惨淡

一些活性故障的例子：

死锁：不解释

锁死：拿到锁的线程跑路了，资源永远不释放

活锁：线程处于RUNNABLE但执行的任务没有进展（带薪摸鱼）

饥饿：线程无法获得所需资源而无法执行任务

非公平调度优点：吞吐率大、减少上下文切换次数（公平调度会带来更多的暂停和唤醒）；缺点：申请资源的时间偏差大、可能导致饥饿，一般首选非公平调度

锁机制的思路：将多个线程对共享数据的并发访问转换为串行访问

JVM对锁的划分有内部锁（Synchronized实现）和显式锁（实现Lock接口的ReentrantLock类实现）

锁的作用是保障线程安全，体现在上面提到的三个方面

1.通过互斥实现原子性，对外在线程来说是不可分割的（因为无法获得锁）

2.锁的获得隐含刷新处理器缓存的动作，使得读线程在临界区前将写线程对共享变量的更新同步到该线程执行处理器的高速缓冲中（可见性+原子性保证了最新值）

3.写线程在临界区执行的操作在读线程所执行的临界区看起来是按源代码顺序执行的（原子性保证读线程无法区分具体顺序，还和可见性保证了最新值，因此感知上是按顺序执行的）

last update:19/03/26