ddatsh

Java 的 volatile 和 sychronized 底层实现

Wed, 03 Sep 2025 00:00:00 +0800

flowchart TB

    %% ================= Java代码层 =================
    subgraph Java代码
        Lock --> AQS
        AQS --> synchronized
        AQS --> volatile
        AQS --> UnsafeCAS[Unsafe.compareAndSwap]
    end

    %% ================= Java字节码 =================
    subgraph Java字节码
        ACC_SYNCHRONIZED
        ACC_VOLATILE
    end
    synchronized --> ACC_SYNCHRONIZED
    volatile --> ACC_VOLATILE
    UnsafeCAS --> cmpxchg3

    %% ================= JVM 层 =================
    subgraph JVM
        monitorenter_exit[monitorenter / monitorexit]
    end
    ACC_SYNCHRONIZED --> monitorenter_exit

    %% ================= JVM代码 =================
    subgraph JVM代码
        ObjectMonitor
        stroeload["stroeload()"]
    end
    monitorenter_exit --> ObjectMonitor
    ACC_VOLATILE --> stroeload

    %% ================= C++ =================
    subgraph C++
        Mutex
    end

    %% ================= 操作系统 =================
    subgraph 操作系统
        cmpxchg1[cmpxchg]
        cmpxchg2[cmpxchg]
        cmpxchg3[cmpxchg]
        cmpxchg4[cmpxchg]
    end
    ObjectMonitor --> cmpxchg1
    stroeload --> cmpxchg2
  
    Mutex --> cmpxchg4

    %% ================= 汇编 =================
    subgraph 汇编
        lock1[lock指令]
        lock2[lock指令]
        lock3[lock指令]
        lock4[lock指令]
    end
    cmpxchg1 --> lock1
    cmpxchg2 --> lock2
    cmpxchg3 --> lock3
    cmpxchg4 --> lock4

    %% ================= 硬件 =================
    subgraph 硬件
        MESI1[MESI协议: 广播和失效]
        MESI2[MESI协议: 广播和失效]
        MESI3[MESI协议: 广播和失效]
        MESI4[MESI协议: 广播和失效]
    end
    lock1 --> MESI1
    lock2 --> MESI2
    lock3 --> MESI3
    lock4 --> MESI4

sychronized

字节码层面

public class Main {

    public synchronized void syncMethod() {

        System.out.println("syncMethod");
    }

    public  void syncBlock() {
        synchronized (this) {
            System.out.println("syncBlock");
        }
    }

    public static void main(String[] args) {

    }

}

使用 javap -verbose <class文件>可以查看到字节码信息

redis listpack ziplist 性能测试

Fri, 22 Aug 2025 00:00:00 +0800

listpack ziplist 性能测试

/* 测试数据生成 */
 typedef struct {
    char **s;
    uint32_t *len;
    size_t n;
} items_t;

static void items_init(items_t *it, size_t n, uint32_t minL, uint32_t maxL, unsigned seed) {
    it->n = n;
    it->s = (char**)zmalloc(n * sizeof(char*));
    it->len = (uint32_t*)zmalloc(n * sizeof(uint32_t));
    assert(it->s && it->len);
    srand(seed);

    for (size_t i = 0; i < n; i++) {
        uint32_t L;
        if (rand() % 8 == 0) {
            L = minL + (rand() % (maxL * 4));
        } else {
            L = minL + (rand() % maxL);
        }
        if (L == 0) L = 1;
        it->len[i] = L;
        it->s[i] = (char*)zmalloc(L + 1);
        assert(it->s[i]);

        for (uint32_t j = 0; j < L; j++) {
            it->s[i][j] = (char)('a' + (int)((i + j) % 26));
        }
        it->s[i][L] = '\0';
    }
}

static void items_free(items_t *it) {
    if (!it || !it->s) return;
    for (size_t i = 0; i < it->n; i++) zfree(it->s[i]);
    zfree(it->s);
    zfree(it->len);
    it->s = NULL; it->len = NULL; it->n = 0;
}

/* 性能基准测试 */
static void benchmark_operations(size_t n, uint32_t minL, uint32_t maxL, unsigned seed) {
    printf("=== Performance benchmark (n=%zu, minL=%u, maxL=%u) ===\n", n, minL, maxL);

    items_t it;
    items_init(&it, n, minL, maxL, seed);

    printf("--- Listpack Performance ---\n");

    /* 创建 listpack */
    unsigned char *lp = lpNew(0);
    assert(lp != NULL);

    /* 添加元素 */
    for (size_t i = 0; i < it.n; i++) {
        unsigned char *new_lp = lpAppend(lp, (unsigned char*)it.s[i], it.len[i]);
        if (new_lp == NULL) {
            printf("Failed to append to listpack\n");
            lpFree(lp);
            items_free(&it);
            return;
        }
        lp = new_lp;
    }

    printf("Listpack size: %zu bytes, elements: %lu\n", lpBytes(lp), lpLength(lp));

    /* 正向遍历性能 */
    long long start = ustime();
    unsigned char *p = lpFirst(lp);
    size_t count = 0;
    while (p) {
        int64_t vlen;
        unsigned char intbuf[LP_INTBUF_SIZE];
        unsigned char *vstr = lpGet(p, &vlen, intbuf);
        if (vstr) {
            count++;
        }
        p = lpNext(lp, p);
    }
    long long forward_time = ustime() - start;

    printf("Forward traversal: %lld us, count: %zu\n", forward_time, count);

    /* 反向遍历性能 */
    start = ustime();
    p = lpLast(lp);
    count = 0;
    while (p) {
        int64_t vlen;
        unsigned char intbuf[LP_INTBUF_SIZE];
        unsigned char *vstr = lpGet(p, &vlen, intbuf);
        if (vstr) {
            count++;
        }
        p = lpPrev(lp, p);
    }
    long long reverse_time = ustime() - start;

    printf("Reverse traversal: %lld us, count: %zu\n", reverse_time, count);

    /* 随机访问性能 */
    start = ustime();
    for (size_t i = 0; i < it.n; i += 100) {
        if (i < it.n) {
            p = lpSeek(lp, i);
            if (p) {
                int64_t vlen;
                unsigned char intbuf[LP_INTBUF_SIZE];
                lpGet(p, &vlen, intbuf);
            }
        }
    }
    long long random_time = ustime() - start;

    printf("Random access: %lld us\n", random_time);

    lpFree(lp);

    printf("--- Ziplist Performance ---\n");

    /* 创建 ziplist */
    unsigned char *zl = ziplistNew();
    assert(zl != NULL);

    /* 添加元素 */
    for (size_t i = 0; i < it.n; i++) {
        zl = ziplistPush(zl, (unsigned char*)it.s[i], it.len[i], ZIPLIST_TAIL);
        if (zl == NULL) {
            printf("Failed to push to ziplist\n");
            zfree(zl);
            items_free(&it);
            return;
        }
    }

    printf("Ziplist size: %zu bytes, elements: %u\n", ziplistBlobLen(zl), ziplistLen(zl));

    /* 正向遍历性能 */
    start = ustime();
    p = ziplistIndex(zl, 0);
    count = 0;
    while (p) {
        unsigned char *vstr;
        unsigned int vlen;
        long long vlong;

        if (ziplistGet(p, &vstr, &vlen, &vlong)) {
            count++;
        }
        p = ziplistNext(zl, p);
    }
    long long zl_forward_time = ustime() - start;

    printf("Forward traversal: %lld us, count: %zu\n", zl_forward_time, count);

    /* 反向遍历性能 */
    start = ustime();
    p = ziplistIndex(zl, -1);
    count = 0;
    while (p) {
        unsigned char *vstr;
        unsigned int vlen;
        long long vlong;

        if (ziplistGet(p, &vstr, &vlen, &vlong)) {
            count++;
        }
        p = ziplistPrev(zl, p);
    }
    long long zl_reverse_time = ustime() - start;

    printf("Reverse traversal: %lld us, count: %zu\n", zl_reverse_time, count);

    /* 随机访问性能 */
    start = ustime();
    for (size_t i = 0; i < it.n; i += 100) {
        if (i < it.n) {
            p = ziplistIndex(zl, i);
            if (p) {
                unsigned char *vstr;
                unsigned int vlen;
                long long vlong;
                ziplistGet(p, &vstr, &vlen, &vlong);
            }
        }
    }
    long long zl_random_time = ustime() - start;

    printf("Random access: %lld us\n", zl_random_time);

    zfree(zl);

    /* 性能对比 */
    printf("--- Performance Comparison ---\n");
    printf("Forward: listpack=%.1fx faster\n", (double)zl_forward_time / forward_time);
    printf("Reverse: listpack=%.1fx faster\n", (double)zl_reverse_time / reverse_time);
    printf("Random: listpack=%.1fx faster\n", (double)zl_random_time / random_time);

    items_free(&it);
}

/* 内存使用对比 */
static void memory_usage_comparison(void) {
    printf("=== Memory usage comparison ===\n");

    items_t it;
    items_init(&it, 10000, 1, 64, 2028);

    /* Listpack 内存使用 */
    unsigned char *lp = lpNew(0);
    for (size_t i = 0; i < it.n; i++) {
        lp = lpAppend(lp, (unsigned char*)it.s[i], it.len[i]);
    }
    size_t lp_size = lpBytes(lp);
    unsigned long lp_elements = lpLength(lp);

    /* Ziplist 内存使用 */
    unsigned char *zl = ziplistNew();
    for (size_t i = 0; i < it.n; i++) {
        zl = ziplistPush(zl, (unsigned char*)it.s[i], it.len[i], ZIPLIST_TAIL);
    }
    size_t zl_size = ziplistBlobLen(zl);
    unsigned int zl_elements = ziplistLen(zl);

    printf("Listpack: %zu bytes, %lu elements, %.2f bytes/element\n",
           lp_size, lp_elements, (double)lp_size / lp_elements);
    printf("Ziplist:  %zu bytes, %u elements, %.2f bytes/element\n",
           zl_size, zl_elements, (double)zl_size / zl_elements);
    printf("Compression ratio: listpack=%.1f%%, ziplist=%.1f%%\n",
           100.0 * lp_size / (it.n * 32), 100.0 * zl_size / (it.n * 32));

    lpFree(lp);
    zfree(zl);
    items_free(&it);
}
 
int main(void) {

    printf("Redis listpack vs ziplist performance comparison test\n");
    printf("==================================================\n");

    /* 基准测试 */
    benchmark_operations(10000, 1, 32, 2024);

    /* 压力测试 */
    printf("=== Stress test: many small items ===\n");
    benchmark_operations(50000, 1, 8, 2025);

    printf("=== Stress test: mixed size items ===\n");
    benchmark_operations(20000, 1, 128, 2026);

    printf("=== Stress test: large items ===\n");
    benchmark_operations(10000, 64, 512, 2027);

    /* 内存使用对比 */
    memory_usage_comparison();

    printf("=== Test completed ===\n");
    return 0;
}

解读报告 
Redis listpack vs ziplist performance comparison test
==================================================
=== Performance benchmark (n=10000, minL=1, maxL=32) ===
--- Listpack Performance ---
Listpack size: 244081 bytes, elements: 10000
Forward traversal: 152 us, count: 10000
Reverse traversal: 147 us, count: 10000
Random access: 3131 us
--- Ziplist Performance ---
Ziplist size: 244051 bytes, elements: 10000
Forward traversal: 204 us, count: 10000
Reverse traversal: 160 us, count: 10000
Random access: 3695 us
--- Performance Comparison ---
Forward: listpack=1.3x faster
Reverse: listpack=1.1x faster
Random: listpack=1.2x faster
=== Stress test: many small items ===
=== Performance benchmark (n=50000, minL=1, maxL=8) ===
--- Listpack Performance ---
Listpack size: 396282 bytes, elements: 50000
Forward traversal: 694 us, count: 50000
Reverse traversal: 701 us, count: 50000
Random access: 81403 us
--- Ziplist Performance ---
Ziplist size: 396286 bytes, elements: 50000
Forward traversal: 981 us, count: 50000
Reverse traversal: 744 us, count: 50000
Random access: 86004 us
--- Performance Comparison ---
Forward: listpack=1.4x faster
Reverse: listpack=1.1x faster
Random: listpack=1.1x faster
=== Stress test: mixed size items ===
=== Performance benchmark (n=20000, minL=1, maxL=128) ===
--- Listpack Performance ---
Listpack size: 1818474 bytes, elements: 20000
Forward traversal: 443 us, count: 20000
Reverse traversal: 418 us, count: 20000
Random access: 18969 us
--- Ziplist Performance ---
Ziplist size: 1821221 bytes, elements: 20000
Forward traversal: 511 us, count: 20000
Reverse traversal: 387 us, count: 20000
Random access: 22066 us
--- Performance Comparison ---
Forward: listpack=1.2x faster
Reverse: listpack=0.9x faster
Random: listpack=1.2x faster
=== Stress test: large items ===
=== Performance benchmark (n=10000, minL=64, maxL=512) ===
--- Listpack Performance ---
Listpack size: 4211033 bytes, elements: 10000
Forward traversal: 294 us, count: 10000
Reverse traversal: 203 us, count: 10000
Random access: 4543 us
--- Ziplist Performance ---
Ziplist size: 4229211 bytes, elements: 10000
Forward traversal: 273 us, count: 10000
Reverse traversal: 194 us, count: 10000
Random access: 5431 us
--- Performance Comparison ---
Forward: listpack=0.9x faster
Reverse: listpack=1.0x faster
Random: listpack=1.2x faster
=== Memory usage comparison ===
Listpack: 463294 bytes, 10000 elements, 46.33 bytes/element
Ziplist:  462803 bytes, 10000 elements, 46.28 bytes/element
Compression ratio: listpack=144.8%, ziplist=144.6%
=== Test completed ===

Listpack 在大多数场景下都优于 Ziplist，但优势并不像预期那样显著

Redis Transparent Huge Pages (THP) 问题深度解析

Thu, 07 Aug 2025 00:00:00 +0800

引言

在 Redis 的生产环境中，Transparent Huge Pages (THP) 是一个经常被忽视但影响重大的性能问题

THP 是 Linux 内核的一个特性，它允许系统自动将小页面合并为大页面以提高性能

GCC _FORTIFY_SOURCE

Mon, 04 Aug 2025 00:00:00 +0800

`_FORTIFY_SOURCE` 的发展历程

_FORTIFY_SOURCE 是 GCC 和 glibc 提供的一个 编译时+运行时的安全增强机制，主要用于 检测常见的缓冲区溢出和其他内存相关的安全漏洞

起源

最早出现在 glibc 2.3.4 (2004年)，是 Red Hat 工程师开发的安全增强功能。最初的设计目标是：

redis fast_float

Sun, 03 Aug 2025 00:00:00 +0800

背景：为什么 Redis 需要更快的浮点解析？

Redis 的开发中，高性能一直是核心追求之一。特别是在处理用户输入的浮点数字符串时，传统的标准库解析函数 strtod() 成为性能瓶颈。于是，Redis 引入了 Daniel Lemire 等人开发的 fast_float 库，以实现更快的浮点数解析

linux开机后访问的文件列表

Mon, 21 Jul 2025 00:00:00 +0800

想知道开机后到底访问了哪些文件

AI出来的答案基本都是auditd、inotifywait、fatrace 等，不好用

还是直接从 atime入手最方便

查看当前挂载参数

mount | grep -E "^/dev/"

/dev/sda2 on / type ext4 (rw,relatime,seclabel)

加 strictatime

vi /etc/fstab

from

grub 启动

Sat, 19 Jul 2025 00:00:00 +0800

可以被GRUB启动的简单内核

1. 准备开发环境

apt install build-essential nasm grub-pc-bin xorriso

2. 项目结构

myos/
├── boot/
│   ├── boot.asm    # 汇编启动代码
│   └── grub.cfg    # GRUB配置文件
├── kernel/
│   └── main.c      # 主内核代码
├── linker.ld
└── Makefile        # 构建脚本

3. 引导代码 (boot/boot.asm)

boot.asm

; boot.asm - 多引导头定义
section .multiboot
align 4

; 多引导头定义
multiboot_header:
    dd 0x1BADB002              ; 魔数
    dd 0x00                    ; 标志
    dd -(0x1BADB002 + 0x00)    ; 校验和

global start
extern kernel_main             ; 声明在C代码中定义的主函数

section .text
start:
    ; 设置栈指针
    mov esp, stack_top
    
    ; 调用C内核
    call kernel_main
    
    ; 如果内核返回，进入无限循环
    cli
    hlt

section .bss
align 16
stack_bottom:
    resb 16384 ; 16KB栈空间
stack_top:

4. 内核 (kernel/main.c)

main.c

// VGA文本模式缓冲区地址
volatile unsigned short *vga_buffer = (unsigned short *)0xB8000;
const int VGA_COLS = 80;
const int VGA_ROWS = 25;

// 清屏函数
void clear_screen() {
    for (int i = 0; i < VGA_COLS * VGA_ROWS; i++) {
        vga_buffer[i] = (unsigned short)0x0F00 | ' ';
    }
}

// 打印字符串函数
void print_string(const char *str, int row, int col) {
    int index = row * VGA_COLS + col;
    for (int i = 0; str[i] != '\0'; i++) {
        vga_buffer[index++] = (unsigned short)0x0F00 | str[i];
    }
}

// 内核主函数
void kernel_main() {
    clear_screen();
    print_string("Hello from MyOS Kernel!", 12, 30);
    
    // 无限循环
    while (1);
}

5. GRUB配置文件 (boot/grub.cfg)

set timeout=0
set default=0

menuentry "MyOS" {
    clear
    multiboot /boot/myos.bin
    boot
}

6. Maklefile

# 目标名称
KERNEL := myos.bin
ISO := myos.iso

# 工具链
ASM := nasm
CC := gcc
LD := ld
GRUB_MKRESCUE := grub-mkrescue

# 编译选项
ASMFLAGS := -f elf32
CFLAGS := -m32 -ffreestanding -nostdlib -Wall -Wextra -c
LDFLAGS := -m elf_i386 -T linker.ld -nostdlib

# 源文件
BOOT_SRC := boot/boot.asm
KERNEL_SRC := kernel/main.c
OBJS := boot/boot.o kernel/main.o

all: $(ISO)

$(ISO): $(KERNEL)
	mkdir -p isodir/boot/grub
	cp $(KERNEL) isodir/boot/$(KERNEL)
	cp boot/grub.cfg isodir/boot/grub
	$(GRUB_MKRESCUE) -o $(ISO) isodir
	rm -rf isodir

$(KERNEL): $(OBJS)
	$(LD) $(LDFLAGS) -o $(KERNEL) $(OBJS)

boot/boot.o: $(BOOT_SRC)
	$(ASM) $(ASMFLAGS) -o $@ $<

kernel/main.o: $(KERNEL_SRC)
	$(CC) $(CFLAGS) -o $@ $<

clean:
	rm -f $(OBJS) $(KERNEL) $(ISO)

run: $(ISO)
	qemu-system-x86_64 -cdrom $(ISO)

.PHONY: all clean run

7. 链接器脚本 (linker.ld)

ENTRY(start)

SECTIONS {
    . = 1M;

    .text : ALIGN(4K) {
        *(.multiboot)
        *(.text)
    }

    .rodata : ALIGN(4K) {
        *(.rodata)
    }

    .data : ALIGN(4K) {
        *(.data)
    }

    .bss : ALIGN(4K) {
        *(COMMON)
        *(.bss)
        *(.stack)
    }
}

工作原理

引导过程：
- GRUB加载内核时，会查找多引导头
- 找到后，GRUB将控制权交给我们的汇编启动代码
- 汇编代码设置栈并调用C内核
内核功能：
- 清屏并在屏幕中央显示"Hello from MyOS Kernel!"
- 使用VGA文本模式缓冲区直接写入显存

x86 引导扇区、显存编程与中断初探

Thu, 17 Jul 2025 00:00:00 +0800

实模式下的“Hello World”

boot.asm

[org 0x7C00]
[bits 16]

start:
    ; 设置80x25文本模式
    mov ah, 0x00
    mov al, 0x03
    int 0x10

    ; 在屏幕上输出字符
    mov ah, 0x0E
    mov al, 'X'
    int 0x10

    ;  低功耗循环
    sti           ; 允许中断
idle_loop:
    hlt           ; 暂停 CPU
    jmp idle_loop ; 中断后恢复
    
;-----------------------------
; MBR签名填充
;-----------------------------
times 510-($-$$) db 0  ; 填充剩余空间(510 - 已用空间)
dw 0xAA55	          ; MBR有效签名(55h AAh)

nasm -f bin boot.asm -o boot.bin
qemu-system-i386 -drive format=raw,file=boot.bin

boot、实模式、BIOS 与 INT 中断

Wed, 16 Jul 2025 00:00:00 +0800

boot：计算机如何“自我启动”

计算机的启动过程看似简单，实则复杂精妙，涉及从硬件到软件的一系列控制权移交

✅ 基本释义

单词	词性	中文含义
boot	名词（n.）	靴子，长筒靴

💡 小知识：为什么“boot”也表示启动？

x86的演变与核心设计哲学