重拾Java之路-异常与多线程简述

异常处理

Java 异常包含两种类型：
一种为 Error，描述Java程序运行时系统的内部错误，通常为虚拟机异常： StackOverflowError，OutOfMemoryError，NoClassDefFoundError等。
一种为 exception，包含了 RuntimeException 和其他异常（受查异常：IOException）。

受查异常在编译阶段就会进行检测，使用 throws关键字或 try-catch-finally 语句块来进行处理。
Exp：（https://zhuanlan.zhihu.com/p/99346090）
java.lang.NullPointerException 空指针异常；出现原因：调用了未经初始化的对象或者是不存在的对象。
java.lang.ClassNotFoundException 指定的类找不到；出现原因：类的名称和路径加载错误；通常都是程序试图通过字符串来加载某个类时可能引发异常。
java.lang.NumberFormatException 字符串转换为数字异常；出现原因：字符型数据中包含非数字型字符。
java.lang.IndexOutOfBoundsException 数组角标越界异常，常见于操作数组对象时发生。
java.lang.IllegalArgumentException 方法传递参数错误。
java.lang.ClassCastException 数据类型转换异常。
SQLException SQL 异常，常见于操作数据库时的 SQL 语句错误。

在Java7后，通过实现 AutoCloseable接口， 来取代放到finally语句块中的资源释放操作，变成自动释放。（类似于Python中的with语句） try-with-resource

throw 与 throws 的区别？
throw：用于方法体内，表示抛出异常，异常已经发生，抛出的为一个异常实例。
throws：用于方法声明后，表示由方法调用者来处理异常，可能会出现异常，表现的是一种可能性。

异常与多线程：
异常无法跨线程传播回main方法中，因此需要在本地处理（try-catch-finally）。

日志

（https://zhuanlan.zhihu.com/p/64353891）
日志的定义：介绍一个过程和经历的详细记录。

日志的作用：

1. 日志能查看程序当前的运行状态。
2. 日志能查看程序历史运行轨迹。
3. 排查系统问题。
4. 优化系统性能。
5. 用于安全审计。

日志工具：
接口级别： java common logging（JCL）， SLF4J。
实现级别：log4j，simplelog，LogBack（4j改良版本），log4j2（4j升级版，提供了LogBack可用改进）。

建议 SLF4J+LogBack。

日志的级别（level）：
ALL：打开所有日志记录，级别最低。
Trace：追踪，根据程序推进情况进行输出（非常多）。
Debug：指出细粒度信息事件，打印运行信息。（常用）
Info：消息在粗粒度级别上突出强调应用的运行过程，打印运行的重要信息。（常用）
Warn：输出警告以及warn级别以下的日志。（常用）
Error：输出错误信息日志。（常用）
Fatal：输出每个严重的错误事件将会导致应用程序的退出的日志。
OFF：关闭所有日志记录。

多线程编程简述

线程：线程是一个进程中的执行任务（控制单元），是CPU任务调度和执行的基本单位。
进程：进程是一个内存中运行的程序，是操作系统系统资源分配的基本单位。

多个线程共享进程的堆和方法区资源，每个线程有自己的程序计数器和运行栈（虚拟机栈和本地方法栈），切换开销比进程要小很多。
一个线程奔溃，则整个进程都会崩溃，因此多线程没有多进程稳定。

程序计数器私有为了线程切换后能恢复到正确位置。
虚拟机栈：每个方法（字节码）在执行的时候会创建一个栈来存储局部变量表、常量池引用等信息，伴随着直到方法完成。
本地方法栈：类似于虚拟机栈，只不过服务对象为 虚拟机使用到的Native方法。

两个栈私有是为了保证线程中的局部变量不被其它线程访问。

中断

可以调用一个线程的 interrupt() 方法来中断线程，但是如果线程处于阻塞、限期等待或无限期等待时，使用中断方法就会出现 InterruptException异常。

使用该方法时，会设置线程的中断标记，此时可以在线程方法中使用 interrupted() 方法来判断线程是否处于中断状态。

互斥同步

Java有两种锁机制来实现互斥访问，分别为JVM实现的synchronized，以及JDK实现的ReentrantLock。

synchronized

该关键字只作用与同一个对象。
当同步一个类时，该类所产生的不同对象也是同步的。

public class SynchronizedExample {

    // 同步代码块
    public void func1(){
        synchronized (this){
            for(int i=0;i<10;i++)
                System.out.println(i + " ");
        }
    }

    // 同步类
    public void func2(){
        synchronized (SynchronizedExample.class){
            for(int i=0;i<10;i++)
                System.out.println(i + " ");
        }
    }

    public static void main(String[] args) {
        SynchronizedExample test = new SynchronizedExample();
        ExecutorService executorService = Executors.newCachedThreadPool();

        // 正确调用
        executorService.execute(() -> test.func1());
        executorService.execute(() -> test.func1());

        SynchronizedExample testNew = new SynchronizedExample();

        // 由于为不同对象，因此同步关键字失效
        executorService.execute(() -> test.func1());
        executorService.execute(() -> testNew.func1());

        // 由于同步了该类，因此该类不同的实例对象依然同步
        executorService.execute(() -> test.func2());
        executorService.execute(() -> testNew.func2());


    }
}

ReentrantLock

类似于synchronized关键字的同步，只是在实现上有些区别，感觉还没有关键字同步清爽。

private Lock lock = new ReentrantLock();

    public void func(){
        lock.lock();
        try{
            for(int i=0;i<10;i++)
                System.out.println(i + " ");
        }finally {
            lock.unlock();
        }
    }

两者的比较：

1. synchronized（前者）由 JVM实现，ReentrantLock（后者）由JDK实现。
2. 前者不可中断（只能设置标志），后者可中断。
3. 前者是非公平锁（多线程等同一个锁时，按照申请锁的时间来获得）；后者默认非公平，但是也可以为公平锁。
4. 后者可以同时绑定多个 Condition对象。

wait() 和sleep() 区别

wait() 是 Object 的方法，而 sleep() 是Thread的静态方法。
sleep() 不会释放锁。

线程的状态类型

1. 新建：创建后未启动
2. 可运行：正在Java虚拟机中运行。在操作系统层面，可能为运行状态(可以被运行，但是可能没有被操作系统调度)
3. 阻塞：请求 monitor lock时发现已被其它线程占用，因此进入阻塞态。需要等待占用线程执行完成并释放锁以后才能转为运行态。（被动式）
4. 无限期/有限期等待：相对于阻塞，等待是通过函数主动进入的，等待其它线程给出退出方法。
   睡眠和挂起是描述线程的行为；
   等待和阻塞是描述线程的状态。
5. 死亡：正常结束与因为异常结束

J.U.C 组件

CountDownLatch
用于控制一个或者多个线程等待多个线程（通常用于主线程等待子线程完成再退出） 使用 await等待计数器为0才能继续向下进行。

CyclicBarrier（循环屏障）
控制多个线程相互等待，不同于CountDownLatch，该计数器可以使用 reset方法来重置计数。

Java内存模型

线程只能操作工作内存（高速缓存/寄存器）中的变量，而不同线程之间的变量传递需要主内存来完成。

内存模型的三大特性：

1. 原子性：一个或多个操作，要么全部执行且在执行过程中不会被任何因素打断，要么全部不执行。
2. 可见性：当一个线程修改了共享变量的值，其它线程能够立即得知这个修改。
3. 有序性：在本线程内观察，所有的操作的都是有序的。（Java内存模型中，允许编译器和处理器对指令进行重排序，这可能会对多线程并发执行的正确性有影响）

Volatile

Volatile可以看成是轻量级的Synchronized，保证的是共享变量的可见性。注意：不能保证操作的原子性。

被Volatile关键字修饰的语义：

1. 保证了不同线程对这个变量操作时的可见性。
2. 禁止进行指令重排序。（对单一线程无影响，对多线程会产生影响）

非阻塞同步

互斥同步属于悲观的并发策略，其最主要的问题就是线程阻塞和唤醒带来的性能问题，因此这种同步也被称为阻塞同步。
基于重图检测的并发策略则是乐观的，即先进行操作，如果出现问题则采取补偿措施，这种被称为非阻塞同步；需要使用硬件来完成。

线程本地存储（Thread local Storage）

简单定义：为每个使用该变量的线程都存储一个本地变量副本。（使得线程互不相干）

link
每个线程都维护一个map，而这个map的key就是当前threadLocal变量，而值则是我们需要set的那个变量的value，之后每次线程在get取值的时候都是从自己的变量中取值，既然是从自己的变量中取值，那么当然也就不存在线程安全的问题了。ThreadLocal只是充当一个key的角色，然后顺带给每个线程提供一个初始值。

比较

采用synchronized进行同步控制，效率略低，使得并发同步进行（串行）。因此，该方式占用内存小，但是速度较慢。
使用ThreadLocal线程本地存储，为每个使用该变量的线程都存储一个本地变量副本，使得各线程的操作互不相干。因此该方式所占内存较大，但是速度快。

锁优化（JVM对synchronized的优化）

自旋锁：while+CAS；
锁销除：编译器将不可能出现共享变量竞争的锁进行消除；
重量级锁：将除了拥有锁的线程以外的线程都阻塞；
轻量级锁：其它线程介入时，启用自旋锁；
偏向锁：第一次进行CAS，后续针对同一线程不再进行同步；