基础知识点总结9

1.异常的体系，分类?异常如何处理？处理过程中要注意什么？

Java异常处理的五个关键字：try（捕获可能发生的异常）、catch（处理异常）、finally（无论如何都要运行的代码，例如资源的关闭）、throw（抛出异常）、throws（声明异常）
处理过程中要注意的点：
（1）运行时异常被抛出可以不处理。即不捕获也不声明抛出。
（2）如果父类的方法抛出了多个异常,子类覆盖(重写)父类方法时,只能抛出相同的异常或者是他的子集。
（3）父类方法没有抛出异常，子类覆盖父类该方法时也不可抛出异常。此时子类产生该异常，只能捕获处理，不能声明抛出
（4）当多异常分别处理时，捕获处理，前边的类不能是后边类的父类
（5）在try/catch后可以追加finally代码块，其中的代码一定会被执行，通常用于资源回收。
多个异常使用捕获又该如何处理呢？
（1）多个异常分别处理。
（2）多个异常一次捕获，多次处理。
（3）多个异常一次捕获一次处理。
一般我们是使用一次捕获多次处理方式

2.自定义异常类相关的知识

自定义的异常类要继承与相应的异常类，例如自定义一个运行时期的异常类:自定义类 并继承于java.lang.RuntimeException。

3.多线程相关的知识

3.1并行与并发
并行：指两个或多个事件在同一时刻发生（同时执行）。
并发：指两个或多个事件在同一个时间段内发生(交替执行)。
3.2线程与进程
进程：是指一个内存中运行的应用程序，每个进程都有一个独立的内存空间，一个应用程序可以同时运行多个进程
线程：是进程中的一个执行单元，负责当前进程中程序的执行，一个进程中至少有一个线程。一个进程中是可以有多个线程的，这个应用程序也可以称之为多线程程序。
进程与线程的区别
进程：有独立的内存空间，进程中的数据存放空间（堆空间和栈空间）是独立的，至少有一个线程。
线程：堆空间是共享的，栈空间是独立的，线程消耗的资源比进程小的多。
分时调度：轮流使用cpu的使用权
抢占式调度：优先级高的线程使用 CPU先使用

Thread类
线程开启我们需要用到了java.lang.Thread类，API中该类中定义了有关线程的一些方法，具体如下：
构造方法：
• public Thread():分配一个新的线程对象。
• public Thread(String name):分配一个指定名字的新的线程对象。
• public Thread(Runnable target):分配一个带有指定目标新的线程对象。
• public Thread(Runnable target,String name):分配一个带有指定目标新的线程对象并指定名字。
常用方法：
• public String getName():获取当前线程名称。
• public void start():导致此线程开始执行; Java虚拟机调用此线程的run方法。
• public void run():此线程要执行的任务在此处定义代码。
• public static void sleep(long millis):使当前正在执行的线程以指定的毫秒数暂停（暂时停止执行）。
• public static Thread currentThread():返回对当前正在执行的线程对象的引用。

创建线程的两种方式：
（1）继承方式 定义Thread类的子类，并重写该类的run()方法，extends Thread
（2）实现方式 采用java.lang.Runnable也是非常常见的一种，我们只需要重写run方法即可。

实现Runnable接口比继承Thread类所具有的优势：
（1）适合多个相同的程序代码的线程去共享同一个资源。
（2）可以避免java中的单继承的局限性。
（3）增加程序的健壮性，实现解耦操作，代码可以被多个线程共享，代码和线程独立。
（4）线程池只能放入实现Runable或Callable类线程，不能直接放入继承Thread的类。

使用线程的内匿名内部类方式，可以方便的实现每个线程执行不同的线程任务操作。

4.什么是线程安全和线程同步

线程安全：如果有多个线程在同时运行，而这些线程可能会同时（同一字数）运行这段代码。程序每次运行结果和单线程运行的结果是一样的，而且其他的变量的值也和预期的是一样的，就是线程安全的。
线程同步：是为了解决线程安全问题，当我们使用多个线程访问同一资源的时候，且多个线程中对资源有写的操作，就容易出现线程安全问题。
同步机制(synchronized)来解决线程安全问题，实现线程同步。
synchronized关键字可以用于方法中的某个区块中，表示只对这个区块的资源实行互斥访问。

相关知识参考链接：https://blog.csdn.net/csdnnews/article/details/82321777
Lock锁：java.util.concurrent.locks.Lock机制提供了比synchronized代码块和synchronized方法更广泛的锁定操作,同步代码块/同步方法具有的功能Lock都有,除此之外更强大
Lock锁也称同步锁，加锁与释放锁方法化了，如下：
• public void lock():加同步锁。
• public void unlock():释放同步锁。
锁具有互斥与可见性

5.volatile关键字的作用以及volatile与synchronized区别

Volatile关键字保证不同线程对共享变量操作的可见性，也就是说一个线程修改了volatile修饰的变量，当修改写回主内存时，另外一个线程立即看到最新的值。
但是并不能保证对数据操作的原子性
volatile与synchronized区别:
• volatile只能修饰成员变量和静态变量，而synchronized可以修饰方法，以及代码块。
• volatile保证数据的可见性，但是不保证原子性(多线程进行写操作，不保证线程安全);而synchronized是一种排他（互斥）的机制
• synchronized解决高并发可见性问题是清空工作内存,而volatile是失效其他线程对此变量副本

相关知识参考链接：https://blog.csdn.net/tianjindong0804/article/details/105134458?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522161580488716780255244877%2522%252C%2522scm%2522%253A%252220140713.130102334…%2522%257D&request_id=161580488716780255244877&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2_alltop_click~default-1-105134458.first_rank_v2_pc_rank_v29&utm_term=volatile%E5%85%B3%E9%94%AE%E5%AD%97%E7%9A%84%E4%BD%9C%E7%94%A8

6.原子性

定义： 即一个操作或者多个操作 要么全部执行并且执行的过程不会被任何因素打断，要么就都不执行。
原子性是拒绝多线程操作的，不论是多核还是单核，具有原子性的量，同一时刻只能有一个线程来对它进行操作。简而言之，在整个操作过程中不会被线程调度器中断的操作，都可认为是原子性。
java.util.concurrent.atomic包(简称Atomic包)整个包都具有原子性。

CAS，Compare and Swap即比较并替换，CAS有三个操作数：内存值V、旧的预期值A、要修改的值B，当且仅当预期值A和内存值V相同时，将内存值修改为B并返回true，如果不相同则证明内存值在并发的情况下被其它线程修改过了，则不作任何修改，返回false，等待下次再修改。

7. synchronized 与lock、ReentrantLock、ThreadLocal和volatile的区别

synchronized 与lock的区别：
i lock是一个接口，而synchronized是java的一个关键字
ii synchronized异常会释放锁，lock异常不会释放，所以一般try catch包起来，finally中写入unlock，避免死锁。
iii Lock可以提高多个线程进行读操作的效率
iv synchronized关键字，可以放代码块，实例方法，静态方法，类上
v lock一般使用ReentrantLock类做为锁，配合lock()和unlock()方法。在finally块中写unlock()以防死锁。
vi jdk1.6之前synchronized低效。jdk1.6之后synchronized高效。
synchronized 与ReentrantLock的区别：
i synchronized依赖JVM实现，ReentrantLock是JDK实现的。synchronized是内置锁，只要在代码开始的地方加synchronized，代码结束会自动释放。Lock必须手动加锁，手动释放锁。
ii ReenTrantLock比synchronized增加了一些高级功能。synchronized代码量少，自动化，但扩展性低，不够灵活；ReentrantLock扩展性好，灵活，但代码量相对多。
iii 两者都是可重入锁。都是互斥锁。
iv synchronized是非公平锁，ReentrantLock可以指定是公平锁还是非公平锁。
synchronized 与ThreadLocal的区别：
i 都是为了解决多线程中相同变量的访问冲突问题。
ii Synchronized同步机制，提供一份变量，让不同的线程排队访问。
iii ThreadLocal关键字，为每一个线程都提供了一份变量，因此可以同时访问而互不影响。
iv ThreadLocal比直接使用synchronized同步机制解决线程安全问题更简单，更方便，且结果程序拥有更高的并发性。
synchronized 与volatile区别：
i volatile是一个类型修饰符（type specifier）。
ii volatile，它能够使变量在值发生改变时能尽快地让其他线程知道。
iii 关键字volatile是线程同步的轻量级实现，所以volatile性能肯定比synchronized要好，并且只能修改变量，而synchronized可以修饰方法，以及代码块。
iv 多线程访问volatile不会发生阻塞，而synchronized会出现阻塞
v volatile能保证数据的可见性，但不能保证原子性；而synchronized可以保证原子性，也可以间接保证可见性，因为它会将私有内存和公共内存中的数据做同步
vi 关键字volatile解决的下变量在多线程之间的可见性；而synchronized解决的是多线程之间资源同步问题（这里和上面的总结有出入只是切入点不同哦！！）

相关知识参考链接：https://blog.csdn.net/qq_38545713/article/details/104780407?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522161580964616780269836731%2522%252C%2522scm%2522%253A%252220140713.130102334.pc%255Fall.%2522%257D&request_id=161580964616780269836731&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2_allfirst_rank_v2~rank_v29-1-104780407.first_rank_v2_pc_rank_v29&utm_term=+synchronized+%E4%B8%8Elock%E3%80%81ReentrantLock%E3%80%81ThreadLocal%E5%92%8Cvolatile%E7%9A%84%E5%8C%BA%E5%88%AB

以上总结的参考链接如有侵权，联系删除！