本文主要是介绍周末总得学点什么吧，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！
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,没有加锁，所以导致多次创建。
解决这种问题有很多种，比如：
- 饿汉式
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);}}
}
看情况使用，因为类加载后，就会创建对象浪费内存。
- 加锁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 开发方便，但是加锁每次都会影响效率
- 双重判断检验锁
如果不加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;}
- 静态内部类单例
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 包中的原子类）来确保操作的原子性。
这篇关于周末总得学点什么吧的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！
