科学计算中如何用parallel::mclapply实现无限循环？

首先明确：无法直接用lapply或parallel::mclapply实现真正的无限循环——这类函数的执行逻辑是基于输入向量的长度分配任务，输入向量在调用时就固定了，不存在“在循环内修改传入向量”的未公开方法，子进程是fork出来的独立内存空间，没法反向修改主进程的变量。

不过可以通过以下两种思路实现你的需求，既利用多核优势，又避免超大向量的内存占用：

方案1：分块迭代+多核并行 #

每次生成一小块任务分配给各个核心，并行处理后检查结果，没找到反例就继续生成下一块，直到目标达成。这种方式内存占用可控，适合样本独立的判断逻辑。

library(parallel)

# 定义单个核心的任务：处理n个样本，返回第一个符合条件的反例（无则返回NULL）
check_counterexample <- function(n) {
  x <- runif(n)
  # 替换成你的实际反例判断逻辑，这里用x>1做示范（实际永远找不到）
  hit_idx <- which(x > 1)
  if (length(hit_idx) > 0) return(x[hit_idx[1]])
  return(NULL)
}

# 配置参数
chunk_size <- 1000  # 每个核心每次处理的样本量
num_cores <- detectCores() - 1  # 留1个核心给系统进程

# 分块并行循环
repeat {
  # 给每个核心分配一个chunk_size的任务
  results <- mclapply(rep(chunk_size, num_cores), check_counterexample, mc.cores = num_cores)
  
  # 检查所有核心的结果
  found <- Filter(Negate(is.null), results)
  if (length(found) > 0) {
    cat("找到反例：", found[[1]], "\n")
    break
  }
  
  # 可选：打印进度，避免无反馈
  cat("当前批次未找到反例，继续迭代...\n")
}

方案2：独立核无限循环+主进程监听 #

让每个核心单独跑自己的无限循环，主进程定期检查是否有核心找到反例，一旦找到就终止所有子进程。这种方式更贴近你原本的repeat无限循环逻辑，效率更高。

library(parallel)

# 单个核心的无限循环任务
worker_loop <- function() {
  repeat {
    x <- runif(1)
    # 替换成你的实际反例判断逻辑
    if (x > 1) return(x)
  }
}

# 启动多核任务
num_cores <- detectCores() - 1
jobs <- lapply(1:num_cores, function(i) mcparallel(worker_loop()))

# 主进程监听结果
repeat {
  # 每秒检查一次是否有核心完成任务（不阻塞）
  results <- mccollect(jobs, wait = FALSE, timeout = 1)
  completed_idx <- which(sapply(results, Negate(is.null)))
  
  if (length(completed_idx) > 0) {
    counterexample <- results[[completed_idx[1]]]
    cat("找到反例：", counterexample, "\n")
    # 清理剩余的子进程
    mccollect(jobs[setdiff(1:num_cores, completed_idx)], wait = TRUE)
    break
  }
}

注意事项 #

• 上述方案基于fork机制，仅适用于Linux/macOS；Windows系统需改用parallel::parLapply配合集群，逻辑类似但需要先创建集群对象。
• 如果你的反例判断需要共享状态（比如累计已检查样本数），需用共享内存（如bigmemory包）或文件同步，每个核心的内存空间是独立的，无法直接共享变量。
• 可根据实际计算成本调整chunk_size或监听间隔，平衡内存占用和计算效率。

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