周末总得学点什么吧

JAVA

每个对象都会有一个监视器monitor联系。
监视器如果占用时，对象会被锁住，当多线程时，其他线程无法访问，需等释放。如: synchronized 的使用
其简单的实现原理就是，引用数，如果0时，线程可以进入monitor，如果是1+，那么除了当前访问的线程外，其他无法访问(无权限)。

举例:
我们常用的懒汉式为什么是线程不安全的。

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

class ExpenObject{
    ExpenObject(){
        System.out.println(this);
    }
}
public class LazyModeV1 {
    private ExpenObject instance = null;
    private LazyModeV1() {}
    public ExpenObject getInstance() {
        if (instance == null) {
            // 只在第一次的时候执行
            instance = new ExpenObject();
        }
        return instance;
    }
    public static void main(String[] args) {
        final ExecutorService executorService = Executors.newCachedThreadPool();
        final LazyModeV1 lazyModeV1 = new LazyModeV1();
        for(int i=0;i<10;i++){
            executorService.execute(lazyModeV1::getInstance);
        }
    }
}

可以发现懒汉式创建的地址不一样。因为在同一时刻，内存读取可能都是null,没有加锁，所以导致多次创建。
解决这种问题有很多种，比如：

1. 饿汉式

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

class ExpenObject{
    ExpenObject(){
        System.out.println(this);
    }
}
public class LazyModeV1 {
    private ExpenObject instance = new ExpenObject();
    private LazyModeV1() {}
    public synchronized ExpenObject getInstance() {
        return instance;
    }
    public static void main(String[] args) {
        final ExecutorService executorService = Executors.newCachedThreadPool();
        final LazyModeV1 lazyModeV1 = new LazyModeV1();
        for(int i=0;i<10;i++){
            executorService.execute(lazyModeV1::getInstance);
        }
    }
}

看情况使用，因为类加载后，就会创建对象浪费内存。

2. 加锁synchronize (不推荐)

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

class ExpenObject{
    ExpenObject(){
        System.out.println(this);
    }
}
public class LazyModeV1 {
    private ExpenObject instance = null;
    private LazyModeV1() {}
    public synchronized ExpenObject getInstance() {
        if (instance == null) {
            // 只在第一次的时候执行
            instance = new ExpenObject();
        }
        return instance;
    }
    public static void main(String[] args) {
        final ExecutorService executorService = Executors.newCachedThreadPool();
        final LazyModeV1 lazyModeV1 = new LazyModeV1();
        for(int i=0;i<10;i++){
            executorService.execute(lazyModeV1::getInstance);
        }
    }
}

为啥不推荐呢，因为虽然synchronized 开发方便，但是加锁每次都会影响效率

3. 双重判断检验锁
   如果不加volatile关键字 “private volatile ExpenObject instance = null;”
   在某些Java内存模型实现中，如果没有适当的volatile关键字或其他同步机制，instance的可见性可能无法保证。这意味着一个线程可能看到一个未初始化的instance，即使另一个线程已经初始化了它。(使用版本:Java 5及以后的版本)

private volatile ExpenObject instance = null;
    private LazyModeV1() {}
    public ExpenObject getInstance() {
        if (instance == null) {
            synchronized (this){
                if (instance == null) {
                    instance = new ExpenObject();
                }
            }
        }
        return instance;
    }

4. 静态内部类单例

public class Singleton {  
    private Singleton() {}    //private 外部类就不能通过new Singleton()来创建这个类的实例
  
    private static class SingletonHolder {  
        private static final Singleton INSTANCE = new Singleton();  
    }  
  
    public static Singleton getInstance() {  
        return SingletonHolder.INSTANCE;  
    }  
}

这种通过静态内部类实现单例模式的方式是线程安全的，因为JVM保证了类的加载是线程安全的。同时，它也是延迟初始化的，因为SingletonHolder类只会在第一次调用getInstance()方法时才会被加载和初始化。

volatile关键词解释

• 可见性：
  在多线程环境中，一个线程对一个变量的修改，对于其他线程来说可能是不可见的，这是因为每个线程都有自己的工作内存和主内存。线程对变量的所有操作（读取、赋值等）都必须在自己的工作内存中进行，然后再刷新到主内存。
  当一个变量被声明为 volatile 时，它告诉 JVM：这个变量是共享变量，对它的读写操作都应该在主内存中进行，而不是工作内存。因此，当一个线程修改了一个 volatile 变量的值，其他线程会立即看到这个修改。
• 禁止指令重排序优化：
  为了提高程序的执行效率，编译器和处理器可能会对指令进行重排序。但在多线程环境中，这种重排序可能会导致数据不一致的问题。
  当一个变量被声明为 volatile 时，编译器和处理器会知道这个变量是共享的，并且它的值可能会被其他线程改变，因此不会对这个变量的读写指令进行重排序。
• 应用场景：
  volatile 主要用于修饰那些可能会被多个线程同时访问和修改的共享变量，确保这些变量的可见性和一致性。
  需要注意的是，虽然 volatile 可以确保可见性和禁止指令重排序，但它并不能保证原子性。也就是说，对于复合操作（如先读后写、先比较后修改等），volatile 无法确保这些操作的原子性。在这种情况下，通常需要使用其他同步机制（如 synchronized 或 java.util.concurrent 包中的原子类）来确保操作的原子性。