如何在AnyLogic中优雅实现高频率日志记录？

针对你遇到的数据库死锁、CSV重复打开问题，这里提供几个更简洁高效的解决方案，适配不同场景需求：

方案1：同步BufferedWriter单文件写入 #

直接复用单个文件流，通过同步锁避免并发写入冲突，无需手动维护缓存列表：

1. 在Main agent中初始化全局BufferedWriter：

private BufferedWriter logWriter;

// 模型启动时初始化文件流
public void onStartup() {
    try {
        // 以追加模式打开文件，避免覆盖原有日志
        logWriter = new BufferedWriter(new FileWriter("activity_log.csv", true));
        // 首次创建文件时写入表头
        File logFile = new File("activity_log.csv");
        if (logFile.length() == 0) {
            logWriter.write("时间戳,活动名称,主体ID");
            logWriter.newLine();
        }
    } catch (IOException e) {
        e.printStackTrace();
    }
}

2. 封装同步写日志方法：

// 加synchronized确保同一时间仅一个线程写入
public synchronized void writeActivityLog(String timestamp, String activityName, String agentId) {
    if (logWriter == null) return;
    try {
        logWriter.write(String.format("%s,%s,%s", timestamp, activityName, agentId));
        logWriter.newLine();
        logWriter.flush(); // 可选：实时刷新，或每N条批量刷新提升性能
    } catch (IOException e) {
        e.printStackTrace();
    }
}

3. 模型关闭时关闭文件流：

public void onShutdown() {
    if (logWriter != null) {
        try {
            logWriter.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

优点：代码简洁，无需额外缓存结构，直接解决并发写入问题；仅打开一次文件，避免重复打开错误。
适用场景：日志量中等，对性能要求不是极致的场景。

方案2：阻塞队列异步批量写入 #

用线程安全的阻塞队列缓存日志，后台单线程异步写入，彻底解耦日志记录与模型运行逻辑：

1. 在Main agent中初始化队列与线程池：

private BlockingQueue<String> logQueue;
private ExecutorService logExecutor;

public void onStartup() {
    // 设定队列容量，防止日志积压导致内存溢出
    logQueue = new ArrayBlockingQueue<>(1000);
    // 单线程池确保写入顺序
    logExecutor = Executors.newSingleThreadExecutor();

    // 启动后台写入线程
    logExecutor.submit(() -> {
        try (BufferedWriter writer = new BufferedWriter(new FileWriter("activity_log.csv", true))) {
            File logFile = new File("activity_log.csv");
            if (logFile.length() == 0) {
                writer.write("时间戳,活动名称,主体ID");
                writer.newLine();
            }
            // 持续监听队列，有数据则写入
            while (!Thread.currentThread().isInterrupted()) {
                String logEntry = logQueue.take();
                writer.write(logEntry);
                writer.newLine();
                writer.flush();
            }
        } catch (IOException | InterruptedException e) {
            e.printStackTrace();
        }
    });
}

2. 日志记录方法（非阻塞）：

public void writeActivityLog(String timestamp, String activityName, String agentId) {
    try {
        logQueue.put(String.format("%s,%s,%s", timestamp, activityName, agentId));
    } catch (InterruptedException e) {
        Thread.currentThread().interrupt();
        e.printStackTrace();
    }
}

3. 模型关闭时优雅终止线程：

public void onShutdown() {
    logExecutor.shutdown();
    try {
        // 等待5秒让剩余日志写入，超时则强制终止
        if (!logExecutor.awaitTermination(5, TimeUnit.SECONDS)) {
            logExecutor.shutdownNow();
        }
    } catch (InterruptedException e) {
        logExecutor.shutdownNow();
    }
}

优点：日志记录不阻塞模型运行，适合高并发、大日志量场景；线程安全无需手动同步。
适用场景：模型内有大量并发活动需要记录，对性能敏感的场景。

方案3：数据库批量插入优化（若需回到数据库存储） #

如果必须用数据库记录，通过批量插入减少事务次数，降低死锁概率：

1. 维护缓存列表，达到批量阈值时一次性插入：

private List<ActivityLog> dbLogBuffer = new ArrayList<>();
// 设定批量插入阈值，可根据实际调整
private static final int BATCH_SIZE = 50;

public void recordDbLog(ActivityLog entry) {
    dbLogBuffer.add(entry);
    if (dbLogBuffer.size() >= BATCH_SIZE) {
        batchInsert();
    }
}

private void batchInsert() {
    try {
        transactionManager.beginTransaction();
        for (ActivityLog log : dbLogBuffer) {
            entityManager.persist(log);
        }
        transactionManager.commitTransaction();
        dbLogBuffer.clear();
    } catch (Exception e) {
        transactionManager.rollbackTransaction();
        e.printStackTrace();
    }
}

2. 模型关闭时插入剩余缓存：

public void onShutdown() {
    if (!dbLogBuffer.isEmpty()) {
        batchInsert();
    }
}

优点：减少数据库事务次数，降低锁竞争，避免死锁；比单条插入效率更高。
适用场景：需要将日志存入数据库进行后续分析的场景。

方案4：优化现有LinkedList缓存方案 #

如果想继续用现有思路，可优化线程安全性：

• 将普通LinkedList替换为线程安全的Collections.synchronizedList(new LinkedList<>())
• 写入时先复制缓存列表再清空，避免并发修改异常：

// 循环事件中的写入逻辑
List<LogEntry> tempEntries = new ArrayList<>(logList);
logList.clear();
// 遍历tempEntries写入CSV

内容的提问来源于stack exchange，提问作者mczandrea