// ErrorSentinelTracer.java - 包含所有核心错误"句式"
import java.io.*;
import java.util.concurrent.*;
import java.util.concurrent.locks.*;

public class ErrorSentinelTracer {

    // ====== 核心句式S1：空指针异常 ======
    // 哨兵值：0xCAFEBABE（用于追踪null指针来源）
    private static final Object SENTINEL_NULL_TARGET = null;

    public void triggerNullPointer() {
        String sentinelValue = "SENTINEL_NULL_PTR_0xCAFEBABE";
        System.out.println("Attempting to access: " + SENTINEL_NULL_TARGET.toString());
        // 这里会触发NullPointerException，但通过哨兵值可以追踪到来源
    }

    // ====== 核心句式S2：资源泄漏 ======
    // 哨兵值：0xDEADBEEF（用于追踪资源未释放）
    private static final Map<Integer, String> LEAK_MAP = new ConcurrentHashMap<>();

    public void triggerResourceLeak() {
        int leakId = 0xDEADBEEF;  // 哨兵值：标识泄漏的资源
        LEAK_MAP.put(leakId, "LEAK_SENTINEL_RESOURCE");
        // 故意不释放，模拟资源泄漏
        System.out.println("Resource allocated: LEAK_SENTINEL_0xDEADBEEF");
    }

    // ====== 核心句式S3：并发异常（死锁） ======
    // 哨兵值：0xBAB1CAFE（用于追踪死锁锁序）
    private final Object lock1 = new Object();
    private final Object lock2 = new Object();

    public void triggerDeadlock() {
        Thread t1 = new Thread(() -> {
            synchronized (lock1) {
                System.out.println("Thread-1: Acquired LOCK_SENTINEL_0xBAB1CAFE_1");
                try { Thread.sleep(100); } catch (InterruptedException e) {}
                synchronized (lock2) {
                    System.out.println("Thread-1: Acquired LOCK_SENTINEL_0xBAB1CAFE_2");
                }
            }
        });

        Thread t2 = new Thread(() -> {
            synchronized (lock2) {
                System.out.println("Thread-2: Acquired LOCK_SENTINEL_0xBAB1CAFE_2");
                try { Thread.sleep(100); } catch (InterruptedException e) {}
                synchronized (lock1) {
                    System.out.println("Thread-2: Acquired LOCK_SENTINEL_0xBAB1CAFE_1");
                }
            }
        });

        t1.start();
        t2.start();
        // 这里会触发死锁
    }

    // ====== 核心句式S4：超时异常 ======
    // 哨兵值：0xFEEDFACE（用于追踪超时）
    public void triggerTimeout() throws Exception {
        ExecutorService executor = Executors.newSingleThreadExecutor();
        Future<String> future = executor.submit(() -> {
            Thread.sleep(5000);  // 故意超时
            return "TIMEOUT_SENTINEL_0xFEEDFACE";
        });

        try {
            future.get(1, TimeUnit.SECONDS);  // 1秒超时
        } catch (TimeoutException e) {
            System.out.println("TIMEOUT detected: TIMEOUT_SENTINEL_0xFEEDFACE");
            throw e;
        }
    }

    // ====== 核心句式S5：文件IO异常 ======
    // 哨兵值：0xFADEBABE（用于追踪文件路径）
    public void triggerIOException() throws IOException {
        String sentinelPath = "/tmp/SENTINEL_FILE_0xFADEBABE.txt";
        FileInputStream fis = new FileInputStream(sentinelPath);
        // 这里会触发FileNotFoundException
    }

    // ====== 核心句式S6：数组越界 ======
    // 哨兵值：0xFEEDFACE（用于追踪数组索引）
    public void triggerArrayIndexOutOfBounds() {
        int[] sentinelArray = new int[10];
        int sentinelIndex = 0xFEEDFACE % 100;  // 故意越界
        sentinelArray[sentinelIndex] = 1;
        // 这里会触发ArrayIndexOutOfBoundsException
    }

    // Main方法：实验入口
    public static void main(String[] args) {
        ErrorSentinelTracer tracer = new ErrorSentinelTracer();

        // 测试各个句式
        try {
            System.out.println("\n=== Testing S1: NullPointer ===");
            tracer.triggerNullPointer();
        } catch (Exception e) {
            System.out.println("Caught: " + e.getClass().getName());
        }

        try {
            System.out.println("\n=== Testing S2: Resource Leak ===");
            tracer.triggerResourceLeak();
        } catch (Exception e) {
            System.out.println("Caught: " + e.getClass().getName());
        }

        try {
            System.out.println("\n=== Testing S3: Deadlock ===");
            tracer.triggerDeadlock();
        } catch (Exception e) {
            System.out.println("Caught: " + e.getClass().getName());
        }

        try {
            System.out.println("\n=== Testing S4: Timeout ===");
            tracer.triggerTimeout();
        } catch (Exception e) {
            System.out.println("Caught: " + e.getClass().getName());
        }
    }
}

public class NPETracer {
    private static final String SENTINEL_NULL = null;

    public void triggerNPE() {
        // 哨兵值：用于追踪NPE来源
        System.out.println("Accessing: SENTINEL_NULL_PTR_0xCAFEBABE");
        SENTINEL_NULL.toString();  // 触发NPE
    }

    public static void main(String[] args) {
        new NPETracer().triggerNPE();
    }
}

# 1. 编译
javac NPETracer.java

# 2. 运行（会触发NPE）
java NPETracer

# 3. 查看堆栈信息
# 输出会包含：
# Exception in thread "main" java.lang.NullPointerException
#     at NPETracer.triggerNPE(NPETracer.java:5)
#     at NPETracer.main(NPETracer.java:10)

# 搜索哨兵值
grep "SENTINEL_NULL_PTR" app.log

# 查看完整上下文
grep -A 10 -B 5 "SENTINEL_NULL_PTR" app.log

try {
    obj.toString();
} catch (NullPointerException e) {
    // 记录哨兵值
    logger.error("NPE detected: SENTINEL_NULL_PTR_0xCAFEBABE", e);
}

# 运行后检查退出码
java NPETracer
echo $?  # 输出：1

public class MemoryLeakTracer {
    // 哨兵值：标识泄漏的资源
    private static final Map<Integer, byte[]> LEAK_MAP = new ConcurrentHashMap<>();

    public void allocateResource() {
        int leakId = 0xDEADBEEF;  // 哨兵值
        LEAK_MAP.put(leakId, new byte[1024 * 1024]);  // 1MB
        System.out.println("Allocated: LEAK_SENTINEL_0xDEADBEEF (1MB)");
        // 故意不释放，模拟内存泄漏
    }

    public static void main(String[] args) throws Exception {
        MemoryLeakTracer tracer = new MemoryLeakTracer();
        while (true) {
            tracer.allocateResource();
            Thread.sleep(100);  // 快速分配，触发OOM
        }
    }
}

# 1. 编译运行
javac MemoryLeakTracer.java
java -Xmx64m -XX:+HeapDumpOnOutOfMemoryError MemoryLeakTracer

# 2. 观察内存增长
jps -l | grep MemoryLeakTracer
jmap -heap <pid>  # 持续观察堆内存使用

# 3. 当OOM时，会生成heap dump
# 文件名：java_pid<pid>.hprof

# 分析heap dump，查找哨兵值
jhat -J-Xmx2g java_pid<pid>.hprof

# 在浏览器中搜索：0xDEADBEEF
# 可以找到泄漏的对象和GC根

# 查看GC日志
jstat -gc <pid> 1000 10

# 观察GC频率逐渐增加

public class DeadlockTracer {
    // 哨兵值：标识锁对象
    private final Object lock1 = new Object();
    private final Object lock2 = new Object();

    public void triggerDeadlock() {
        Thread t1 = new Thread(() -> {
            synchronized (lock1) {
                System.out.println("Thread-1: LOCK_SENTINEL_0xBAB1CAFE_1 acquired");
                try { Thread.sleep(100); } catch (InterruptedException e) {}
                synchronized (lock2) {
                    System.out.println("Thread-1: LOCK_SENTINEL_0xBAB1CAFE_2 acquired");
                }
            }
        });

        Thread t2 = new Thread(() -> {
            synchronized (lock2) {
                System.out.println("Thread-2: LOCK_SENTINEL_0xBAB1CAFE_2 acquired");
                try { Thread.sleep(100); } catch (InterruptedException e) {}
                synchronized (lock1) {
                    System.out.println("Thread-2: LOCK_SENTINEL_0xBAB1CAFE_1 acquired");
                }
            }
        });

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

    public static void main(String[] args) throws Exception {
        new DeadlockTracer().triggerDeadlock();
        Thread.sleep(5000);  // 等待死锁发生
    }
}

# 1. 编译运行
javac DeadlockTracer.java
java DeadlockTracer &

# 2. 获取PID
jps -l | grep DeadlockTracer

# 3. 检测死锁
jstack <pid>

# 输出会包含：
# Found one Java-level deadlock:
# "Thread-1":
#   waiting to lock Monitor of 0x... (Object@0x...)
#   which is held by "Thread-2"
# "Thread-2":
#   waiting to lock Monitor of 0x... (Object@0x...)
#   which is held by "Thread-1"

// 统一锁顺序：先lock1，后lock2
synchronized (lock1) {
    synchronized (lock2) {
        // 临界区
    }
}

# 查看线程状态
jstack <pid> | grep -A 10 "Thread-1"

# 输出：
# java.lang.Thread.State: BLOCKED
#     at DeadlockTracer.lambda$triggerDeadlock$0(DeadlockTracer.java:10)
#     - waiting to lock <0x...> (a java.lang.Object)

// 1. 在关键位置埋入哨兵值
logger.info("Processing: SENTINEL_ID_0xCAFEBABE");
try {
    // 业务逻辑
} catch (Exception e) {
    logger.error("Failed at SENTINEL_ID_0xCAFEBABE", e);
}

// 2. 使用结构化日志
logger.error("Error processing {}", sentinelId, e);

// 3. 链路追踪
MDC.put("traceId", "SENTINEL_TRACE_" + UUID.randomUUID());

// 1. 不要吞掉异常
try {
    riskyOperation();
} catch (Exception e) {
    // ❌ 什么都不做，异常丢失
}

// 2. 不要用通用哨兵值
String id = "ERROR";  // ❌ 太常见，无法搜索
String id = "SENTINEL_ERR_0xCAFEBABE";  // ✅ 独特

// 3. 不要忽略堆栈信息
logger.error("Error: " + e.getMessage());  // ❌ 只有消息，无堆栈
logger.error("Error", e);  // ✅ 完整堆栈

# Java应用
jps -l                          # 列出Java进程
jstack <pid>                    # 查看线程堆栈（含死锁检测）
jmap -heap <pid>                # 查看堆内存
jmap -histo:live <pid>          # 查看存活对象
jstat -gc <pid> 1000 10         # 查看GC统计
jinfo <pid>                     # 查看JVM参数

# 日志搜索
grep "SENTINEL_0xCAFEBABE" app.log              # 搜索哨兵值
grep -A 10 -B 5 "ERROR" app.log                 # 查看上下文
tail -f app.log | grep --line-buffered "ERROR"  # 实时监控

# 系统层
dmesg | grep -i error                           # 内核日志
journalctl -u myservice -e                      # systemd日志
gdb core <pid>                                  # 分析core dump

# 网络问题
netstat -tulnp                                   # 查看监听端口
ss -tulnp                                       # 更快的netstat
tcpdump -i any port 8080 -w capture.pcap        # 抓包