Java多线程和锁–笔记

线程的状态及其相互转换
1. 初始(NEW)：新创建了一个线程对象，但还没有调用start()方法。
2. 运行(RUNNABLE):处于可运行状态的线程正在JVM中执行，但它可能正在等待来自操作系统的其他资源，例如处理器。
3. 阻塞(BLOCKED)：线程阻塞于synchronized锁，等待获取synchronized锁的状态。
4. 等待(WAITING)：Object.wait()、join()、 LockSupport.park(),进入该状态的线程需要等待其他线程做出一些特定动作（通知或中断）。
5. 超时等待(TIME_WAITING)：Object.wait(long)、Thread.join()、LockSupport.parkNanos()、LockSupport.parkUntil，该状态不同于WAITING，它可以在指定的时间内自行返回。
6. 终止(TERMINATED)：表示该线程已经执行完毕。
创建线程的方式
1. 继承Thread，并重写父类的run方法
2. 实现Runable接口，并实现run方法
3. 使用匿名内部类、Lambda表达式、线程池

实际开发中，选第2种：java只允许单继承

线程安全性问题

什么是线程安全性？
1. 当多个线程访问某个类,不管运行时环境采用何种调度方式或者这些线程如何交替执行,并且在主调代码中不需要任何额外的同步或协同,这个类都能表现出正确的行为,那么就称这个类为线程安全的。
什么是线程不安全？
1. 多线程并发访问时，得不到正确的结果。

深入理解synchronized

内置锁
1. 每个java对象都可以用做一个实现同步的锁，这些锁称为内置锁。线程进入同步代码块或方法的时候会自动获得该锁，在退出同步代码块或方法时会释放该锁。获得内置锁的唯一途径就是进入这个锁的保护的同步代码块或方法。
互斥锁
1. 内置锁是一个互斥锁，这就是意味着最多只有一个线程能够获得该锁，当线程A尝试去获得线程B持有的内置锁时，线程A必须等待或者阻塞，直到线程B释放这个锁，如果B线程不释放这个锁，那么A线程将永远等待下去。
修饰普通方法：锁住对象的实例
修饰静态方法：锁住整个类
修饰代码块：锁住一个对象 synchronized (lock) 即synchronized后面括号里的内容

volatile关键字及其使用场景

作用
1. 能且仅能修饰变量
2. 禁止指令重排序
3. 保证该变量的可见性，volatile关键字仅仅保证可见性，并不保证原子性（synchronized 保证原子性）
  1. A、B两个线程同时读取volatile关键字修饰的对象，A读取之后，修改了变量的值，修改后的值，对B线程来说，是可见

使用场景

作为线程开关

单例，修饰对象实例，禁止指令重排序

单例代码, (饿汉式–本身线程安全。懒汉式–最简单的写法是非线程安全的，使用volatile关键字修饰，禁止指令重排序就可以保证线程安全 )

/**
 * 懒汉式, 线程安全的
 */
public class LazySingleton {

    private static volatile LazySingleton lazySingleton = null;

    private LazySingleton() {
    }
    
    public static LazySingleton getInstance() {
        //判断实例是否为空，为空则实例化
        if (null == lazySingleton) {
            synchronized (LazySingleton.class) {
                if (null == lazySingleton) {
                    lazySingleton = new LazySingleton();
                }
            }
        }
        //否则直接返回
        return lazySingleton;
    }
}

如何避免线程安全性问题

线程安全性问题成因
1. 多线程环境
2. 多个线程操作同一共享资源
3. 对该共享资源进行了非原子性操作
如何避免线程安全性问题？（打破成因中三点任意一点）
1. 多线程环境–将多线程改单线程（必要的代码，加锁访问）
2. 多个线程操作同一共享资源–不共享资源（ThreadLocal、不共享、操作无状态化、不可变）
3. 对该共享资源进行了非原子性操作– 将非原子性操作改成原子性操作（加锁、使用JDK自带的原子性操作的类、JUC提供的相应的并发工具类）

锁的分类
1. 自旋锁：线程状态及上下文切换消耗系统资源，当访问共享资源的时间短，频繁上下文切换不值得。jvm实现，使线程在没获得锁的时候，不被挂起，转而执行空循环，循环几次之后，如果还没能获得锁，则被挂起
2. 阻塞锁：阻塞锁改变了线程的运行状态，让线程进入阻塞状态进行等待，当获得相应的信号（唤醒或者时间）时，才可以进入线程的准备就绪状态，转为就绪状态的所有线程，通过竞争，进入运行状态
3. 重入锁：支持线程再次进入的锁,就跟我们有房间钥匙，可以多次进入房间类似
4. 读写锁：（ReentrantReadWriteLock）两把锁，读锁跟写锁，写写互斥、读写互斥、读读共享
5. 互斥锁：上厕所，进门之后就把门关了，不让其他人进来
6. 悲观锁：总是假设最坏的情况，每次去拿数据的时候都认为别人会修改，所以每次在拿数据的时候都会上锁，这样别人想拿这个数据就会阻塞直到它拿到锁
7. 乐观锁：每次去拿数据的时候都认为别人不会修改，所以不会上锁，但是在更新的时候会判断一下在此期间别人有没有去更新这个数据，可以使用版本号等机制。
8. 公平锁：（ReentrantLock）大家都老老实实排队，对大家而言都很公平
9. 非公平锁：（ReentrantLock）一部分人排着队，但是新来的可能插队（会出现的问题？可能导致后面排队等待的线程等不到相应的cpu资源，从而引起线程饥饿。什么是线程饥饿？饥饿线程_q739639550的博客-CSDN博客_线程饥饿）
10. 偏向锁：偏向锁使用了一种等到竞争出现才释放锁的机制，所以当其他线程尝试竞争偏向锁时，持有偏向锁的线程才会释放锁
11. 独占锁：独占锁模式下，每次只能有一个线程能持有锁
12. 共享锁：允许多个线程同时获取锁，并发访问共享资源
13. 降级锁：读写锁中的特性，写线程获取写入锁后可以获取读取锁，然后释放写入锁，这样就从写入锁变成了读取锁，从而实现锁降级的特性。