作者： 清朝云

共计 1729 个字符，预计需要花费 5 分钟才能阅读完成。

volatile介绍

首先要知道的是并发编程的三个特性：可见性、有序性和原子性，其中 volatile 只能保证其中的可见性和有序性，并不能保证原子性。

1. 可见性

可见性指一个线程对共享变量的修改能够被其他线程立即看到的特性。

多线程条件下，线程0和线程1同时读取了 flag 变量，但线程1将 flag 变量修改后，不会立即刷回主存（常说的内存），而是保存在自己的缓存中（CPU 缓存）。那么此时线程0需要对 flag 变量进行修改时，还不知道 flag 变量已经改变了，所以此时这个变量是线程之间不可见的。

/>

但是如果使用了 volatile 关键字修饰的变量，线程修改后会立即刷入主内存。其他线程在访问这个 volatile 变量时，都会从主内存中重新读取它的最新值，从而保证数据的一致性。

1. 有序性

有序性指程序执行的顺序必须符合预期，不能出现乱序的情况。

例如有如下代码：

int a = 100;
int b = 10;
int a = a + 10;

但经过编译器编译后，为了提高执行效率，可能优化成顺序如下：

int a = 100;
int a = a + 10;
int b = 10;

这种情况下程序就不是严格按照代码编写的顺序执行的，在某些情况下可能会出现问题。

例如：

public class Example {
    private boolean ready = false;
    private int number;

    public void writer() {
        number = 42;  // 步骤1
        ready = true; // 步骤2
    }

    public void reader() {
        if (ready) { // 步骤3
            int localNumber = number; // 步骤4
            System.out.println("Number is: " + localNumber);
        }
    }
}

如果在多线程条件下，步骤1和步骤2的指令重排了，那么 reader 方法，有可能会读取到没有初始化的 number 值。

3. 原子性

原子性指一个操作是不可分割的、完整的，要么全部执行成功，要么全部不执行，不存在执行一半的情况。在多线程环境下，如果一个操作不是原子性的，那么可能会发生竞态条件（race condition）等问题，导致程序出现不可预期的错误。为了保证原子性，可以使用 synchronize d关键字或者使用 Atomic 类中提供的原子操作。

如下案例：当线程0修改变量后立即刷回主内存，但由于线程1已经读取并将变量用于运算了，只差保存到工作内存中，此时及时线程1中的变量失效，也不会影响线程1步骤的执行。所以即使线程0将变量修改为1，线程1同样还是修改为1，只是覆盖了而已。

/>

volatile和synchronized比较

特性	volatile	synchronized
可见性	保证	保证
原子性	不保证	保证
指令重排序	禁止	禁止
性能开销	较低	较高（涉及锁机制）
使用场景	轻量级状态标识、多线程间变量共享	需要原子性操作的临界区

需要注意的是 volatile 和 synchronize 禁止指令重排序的控制的颗粒度不同，synchronize 禁止的是它包含的代码块中的指令重排序，它并不能在指令层面禁止重排序。

这也是为什么双重检查锁单例模式需要 volatile 关键字的原因。由于对象的初始化分为三个阶段，开辟内存空间、内存空间初始化、将对象的地址赋值给引用。如果不使用 volatile，有可能开辟内存空间后直接将地址赋值给引用，那么其他线程判断对象不为空，直接使用则会出现问题。

public class Singleton {

    // 使用volatile关键字确保多线程环境下的可见性和禁止指令重排
    private static volatile Singleton instance;

    // 私有构造函数，防止外部通过new创建实例
    private Singleton() {
    }

    // 提供一个全局访问点
    public static Singleton getInstance() {
        // 第一次检查，避免不必要的锁定
        if (instance == null) {
            // 同步块，确保只有一个线程能执行以下代码
            synchronized (Singleton.class) {
                // 第二次检查，避免重复创建实例
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

共计 2918 个字符，预计需要花费 8 分钟才能阅读完成。

AbstractQueuedSynchronizer

今天在b站看了关于 AbstractQueuedSynchronizer 的合集，稍微了解了一下 AbstractQueuedSynchronizer 的工作原理，简单记录一下。

AbstractQueuedSynchronizer (AQS) 是 Java 中 java.util.concurrent 包的一部分，是一个基础框架类，用于实现锁和同步器（如 ReentrantLock、Semaphore、CountDownLatch 等）。

AQS 是一个抽象类，主要为实现同步器提供了以下关键功能：

1. 同步状态的管理：

   • AQS 使用一个 int 类型的变量（state）来表示同步状态。（该变量使用 volatile 修饰）
   • 提供了 getState、setState 和 compareAndSetState 方法，允许子类安全地修改同步状态。

2. 线程队列：

   • AQS 使用一个先进先出的等待队列来管理被阻塞的线程。
   • 当线程尝试获取同步资源失败时，会被加入这个等待队列。（需要注意的是，不是获取锁失败马上就加入阻塞队列，而是中间有很多次获取锁的机会）

3. 独占模式和共享模式：

   • 独占模式（Exclusive Mode）：一个线程独占资源，例如 ReentrantLock。
   • 共享模式（Shared Mode）：多个线程可以共享资源，例如 Semaphore 和 CountDownLatch。

4. 模板方法模式：

   AQS 定义了一些模板方法（如 tryAcquire、tryRelease、tryAcquireShared 和 tryReleaseShared），需要子类去实现它们以完成具体的同步逻辑。

   • boolean tryAcquire(int arg): 尝试以独占模式获取资源，由子类实现。
   • boolean tryRelease(int arg): 尝试以独占模式释放资源，由子类实现。
   • int tryAcquireShared(int arg): 尝试以共享模式获取资源，由子类实现。
   • boolean tryReleaseShared(int arg): 尝试以共享模式释放资源，由子类实现。
   • boolean isHeldExclusively(): 判断当前同步器是否被某线程独占。

关于为什么这些方法并非都是抽象方法，而是普通方法，是希望子类按需实现，而不是都需要把这些方法实现。

ReentrantLock加锁流程

下图是 ReentrantLock 加锁的流程图：

/>

LockSupport阻塞和唤醒

上图中线程阻塞和唤醒是通过 LockSupport 实现的。LockSupport.park() 和 LockSupport.unpark(Thread thread) 是 Java 中提供的低级线程阻塞和唤醒机制。它们是 java.util.concurrent.locks.LockSupport 类的一部分，用于实现线程的挂起和唤醒操作。

1. park():

   • 将当前线程阻塞（挂起），直到其他线程调用 unpark(Thread thread) 或线程被中断。
   • 是一个相对低级的阻塞操作，用于替代 Thread.suspend() 的不安全行为。
   • 它允许线程在等待某个条件满足时挂起，而不消耗 CPU 资源。

2. unpark(Thread thread):

   • 唤醒指定线程，使其从 park() 状态恢复。
   • 如果被唤醒的线程当前未被阻塞在 park()，调用 unpark() 会记录一个许可，下次调用 park() 时立即返回。

假设有一下代码，想要按顺序打印 ABC，但是由于线程执行是不固定的，所以每次执行会出现不同的结果。

public class LockSupportTest {

    public static void main(String[] args) {
        LockSupportTest lockSupportTest = new LockSupportTest();
        Thread t1 = new Thread(() -> lockSupportTest.printA());
        Thread t2 = new Thread(() -> lockSupportTest.printB());
        Thread t3 = new Thread(() -> lockSupportTest.printC());
        t1.start();
        t2.start();
        t3.start();
    }

    private void printA(){
        try {
            Thread.sleep(5);
            System.out.print("A");
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
    }

    private void printB(){
        try {
            Thread.sleep(5);
            System.out.print("B");
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
    }

    private void printC(){
        try {
            Thread.sleep(5);
            System.out.print("C");
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
    }
}

此时使用 LockSupport 改造一下代码即可稳定顺序打印 ABC：

public class LockSupportTest {

    public static void main(String[] args) {
        LockSupportTest lockSupportTest = new LockSupportTest();
        Thread t3 = new Thread(() -> lockSupportTest.printC());
        Thread t2 = new Thread(() -> lockSupportTest.printB(t3));
        Thread t1 = new Thread(() -> lockSupportTest.printA(t2));

        t1.start();
        t2.start();
        t3.start();
    }

    private void printA(Thread thread){
        try {
            Thread.sleep(5);
            System.out.print("A");
            LockSupport.unpark(thread);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
    }

    private void printB(Thread thread){
        try {
            Thread.sleep(5);
            LockSupport.park();
            System.out.print("B");
            LockSupport.unpark(thread);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
    }

    private void printC(){
        try {
            Thread.sleep(5);
            LockSupport.park();
            System.out.print("C");
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
    }
}

共计 500 个字符，预计需要花费 2 分钟才能阅读完成。

偶尔可能想要查看某个镜像的 dockerfile，但是 github 没可能没有对应的仓库，所以只能通过能拿到的镜像反推 dockerfile。

使用 whaler 可以做到这一点，使用方式如下：

docker run -t --rm -v /var/run/docker.sock:/var/run/docker.sock:ro pegleg/whaler <<具体镜像>>

以之前写过的腾讯云轻量服务器定时创建快照的 dockerfile 为例，原始内容为：

FROM python:3.9-alpine

ENV TZ Asia/Shanghai

ENV PYTHONUNBUFFERED=true

RUN pip install tencentcloud-sdk-python-lighthouse apscheduler pyyaml sqlalchemy

COPY /app /app

WORKDIR /app

CMD ["python3", "run.py"]

通过反推得到如下图输出：

/>

可以看见大部分指令都是能推出来的，至于文件可能就得自己再进一步推理一下，并且基础镜像也需要靠自己稍微推理一下，从 CMD ["python3"] 可以看出使用的是 python 作为基础镜像。
`

共计 619 个字符，预计需要花费 2 分钟才能阅读完成。

之前介绍过新手上路之Docker 搭建好用的 web 管理工具 Portainer – 最新中文汉化版，dpanel 也是同样的一款可以在 web 页面管理 docker 的工具，并且是国人开发的。

docker-compose 文件如下：

services:
  dpanel:
    image: dpanel/dpanel:lite
    container_name: dpanel
    restart: always
    ports:
      - 8080:8080
    environment:
      - APP_NAME=dpanel
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock
      - /home/docker/dpanel:/dpanel

部署后即是经典的初始化用户名和密码。

/>

首页是概览页面，可以看见我这 1h2g 的小机器运行了 36 个容器，简直不堪重负。并且可以直观的看见镜像所占用大小，就像 SpaceSniffer 那样。

/>

另外很好的一点是可以直接查看端口映射，和方便地跳转到存储卷。

/>

容器残留的存储卷往往占用很大的空间，可以在这里直观的看见哪些是未使用。此外，可以拷贝路径直接进入文件夹内，看看哪些存储卷是需要保留的。

/>

最常用的应该就是容器管理了，可以在这里方便的创建、编辑、删除和重启容器等，界面也是简洁好用。

/>

进入容器详情，可以看见还支持导出为镜像和备份存储等功能。

/>

还支持管理 docker-compose，不过需要将文件映射到容器内才行。

/>

同时，支持管理多个 docker 环境。

/>

共计 2500 个字符，预计需要花费 7 分钟才能阅读完成。

向 Spring 容器中注册组件是最常见的操作，不过组件注册的方式有很多种，可以选择合适的方式进行注册。

1. @ComponentScan注解

这种方式会将指定包下配置了 @Component、@Controller、@Service、@Repository 的组件注册到容器中。

另外 @ComponentScan 注册组件可以指定和排除某些类或者用注解标记的某些类。

例如：

// 这里的 @Configuration 注解其实也是一个 @Component
@Configuration
@ComponentScan(
        value = {"com.amjun.annotation.register.register_01"},
        excludeFilters = {
            @ComponentScan.Filter(type = FilterType.ASSIGNABLE_TYPE, classes= MyService.class)
        }
)
public class Config {}

这种方式一般用于将自己编写的代码进行注册，因为第三方的代码可能不包含这些注解。

2. @Bean注解

@Bean 注解是一个常见的注解，它等价于 xml 配置文件中的 标，大部分用于将第三方的类注册到 spring 容器中。

例如：

@Configuration
public class Config {

    @Lazy
    @Scope(ConfigurableBeanFactory.SCOPE_PROTOTYPE)
    @Bean
    public Person person(){
        return new Person("zs", 18);
    }
}

还可以可以通过 @Scope 配置注册到容器是单例还是多例，通过 @Lazy 控制是否懒加载创建。（spring 默认是直接初始化放入容器中，使用该注解后需要时再创建）

3. @Import注解

@Import 允许将一个或多个类注册到 Spring 容器中，这些类会被作为 Bean 进行管理。关于它的使用，有以下几种方式。

• 导入普通类

该普通类可以是什么都没有标注的类，也可以是自己或第三方标注了 @Configuration 的配置类。

@Configuration
@Import(Person.class)
public class Config {
}

或者：

@Configuration
@Import(TestImportConfig.class)
public class Config {
}

@Configuration
public class TestImportConfig {

    @Bean
    public Person person(){
        return new Person("zs", 18);
    }
}

• 使用 ImportSelector 动态选择类

ImportSelector 是一个接口，允许根据条件动态选择导入的类。

@Configuration
@Import(MyImportSelector.class)
public class Config_02 {
}

public class MyImportSelector implements ImportSelector {
    @Override
    public String[] selectImports(AnnotationMetadata importingClassMetadata) {
        return new String[]{"com.amjun.annotation.register.register_03.Person"};
    }
}

selectImports 方法返回的类名会被动态加载到应用上下文中，它的返回是一个数组，意味着可以批量注册。

• 使用 ImportBeanDefinitionRegistrar

ImportBeanDefinitionRegistrar 是一个接口，通过实现 registerBeanDefinitions 接口，拿到 BeanDefinitionRegistry 进行手动注册。

所有需要注册到 spring 容器中的组件，扫描后会组装成一个个 BeanDefinition，并注册到BeanDefinitionRegistry 中，再进行初始化。

@Configuration
@Import(MyImportBeanDefinitionRegistrar.class)
public class Config_03 {
}

public class MyImportBeanDefinitionRegistrar implements ImportBeanDefinitionRegistrar {

    @Override
    public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
        RootBeanDefinition beanDefinition = new RootBeanDefinition(Person.class);
        registry.registerBeanDefinition("person", beanDefinition);
    }
}

4. FactoryBean接口

FactoryBean 是 spring 提供的特殊接口，实现了 FactoryBean 接口的类，从 spring 容器中获取时，不是返回对象本身，而是 getObject() 方法返回的对象。这就提供了一种扩展的可能，可以在这个方法里定制创建复杂的逻辑。

@Configuration
public class Config {

    @Bean
    public PersonFactoryBean person(){
        return new PersonFactoryBean();
    }
}

public class PersonFactoryBean implements FactoryBean<Person> {

    @Override
    public Person getObject() throws Exception {
        return new Person("lisi", 100);
    }

    @Override
    public Class<?> getObjectType() {
        return Person.class;
    }
}