Matlab并行计算入门：parpool配置、parfor实战与性能优化

Matlab并行计算parpoolparfor

于 2026-07-31 07:11:49 修改

·本内容遵循CC 4.0 BY-SA版权协议

1. 从串行到并行：为什么你的Matlab代码需要parpool

如果你用Matlab处理过数据量稍大的矩阵运算，或者跑过需要迭代成千上万次的循环，那你一定对那个“忙碌”的鼠标指针和缓慢增长的进度条记忆犹新。在单核CPU上，Matlab忠实地一条指令接一条指令执行，这就是串行计算。但现代计算机的CPU动辄4核、8核甚至更多核心，让这些核心大部分时间处于“围观”状态，无疑是一种巨大的浪费。并行计算，就是让这些“围观”的核心也动起来，把一个大任务拆分成多个小任务，同时交给多个CPU核心去处理，从而大幅缩短计算时间。而parpool，就是Matlab为你打开这扇并行计算大门的钥匙。

简单来说，parpool（并行池）是Matlab并行计算工具箱（Parallel Computing Toolbox）的核心管理工具。你可以把它想象成一个“工人团队”的调度中心。当你启动一个并行池时，Matlab会在你的计算机本地（或者连接到远程集群）启动多个工作进程。这些工作进程就是干活的“工人”，它们独立于你的主Matlab会话（称为客户端）运行。你的主要代码仍在客户端执行，但当遇到可以并行化的部分（比如一个parfor循环），客户端就会将循环迭代分割成若干份，分发给并行池里的各个工作进程去同时计算，最后再收集汇总结果。这个过程对你是透明的，你几乎像写串行循环一样写parfor，但收获的却是数倍的性能提升。

那么，谁需要关注parpool？但凡你的计算任务符合“计算密集、任务独立、数据可分”这三大特征，就值得一试。典型的场景包括：大规模矩阵或图像数据的逐元素运算、蒙特卡洛模拟（需要大量独立随机实验）、参数扫描（对同一模型使用不同参数组合多次运行）、机器学习中的交叉验证、以及任何耗时较长的for循环。如果你的循环每次迭代需要几秒甚至几分钟，那么将其并行化，带来的加速效果将是立竿见影的。接下来，我们就从零开始，看看如何配置、启动和使用这个强大的“工人团队”。

2. 并行计算环境配置与parpool的启动

在兴奋地写下第一个parfor之前，我们需要确保“工地”（计算环境）已经准备就绪，并且“工人团队”（并行池）能够被顺利组建和指挥。

2.1 环境检查与工具箱确认

首先，你必须确认你的Matlab许可证包含了Parallel Computing Toolbox。这是并行计算的基石，没有它，parpool和相关命令都无法使用。检查方法很简单，在Matlab命令窗口输入：

MATLAB

ver

在输出的列表中查找“Parallel Computing Toolbox”。如果找不到，你需要联系系统管理员或通过MathWorks官网获取该工具箱。

其次，了解你的硬件。在命令窗口输入：

MATLAB

feature('numcores') % 查看物理核心数

或者更详细地：

MATLAB

parcluster('local') % 查看本地并行配置概要

parcluster('local')会返回一个parallel.Cluster对象，其NumWorkers属性通常默认等于你的物理核心数（对于支持超线程的CPU，Matlab默认仍使用物理核心数，以避免资源争抢）。这是你本地并行计算的理论最大“工人”数。

2.2 启动、管理与关闭parpool

启动并行池最直接的方式就是使用parpool函数。

MATLAB

% 启动一个使用所有可用工作进程的并行池

pool = parpool;

% 启动一个指定数量工作进程的并行池（例如4个）

pool = parpool(4);

% 使用特定的集群配置文件启动（适用于集群环境，本地通常用'local'）

% pool = parpool('local', 4);

执行parpool后，Matlab会花一些时间启动工作进程。你会在命令窗口看到类似“Starting parallel pool (parpool) using the 'local' profile ... Connected to the parallel pool (number of workers: X).”的提示。同时，Matlab桌面左下角会出现一个并行池的状态图标，显示活动的工作进程数。

这里有几个关键细节和常见操作：

池对象：parpool函数会返回一个parallel.Pool对象（上面代码中的pool）。保留这个对象引用在后续管理（如关闭）时很有用。
查看当前池：使用gcp函数（Get Current Pool）来获取当前并行池的句柄，如果不存在则返回空。

MATLAB

currentPool = gcp('nocreate'); % 'nocreate'表示如果不存在则不创建

if isempty(currentPool)

disp('No parallel pool is running.');

else

disp(['Current pool has ', num2str(currentPool.NumWorkers), ' workers.']);

end
关闭并行池：计算完成后，及时关闭并行池可以释放它占用的系统内存和CPU资源。有多种方式：

MATLAB

% 方法1：使用池对象关闭

delete(pool);

% 方法2：关闭当前池

delete(gcp);

% 方法3：使用parpool命令关闭（较新版本）

parpool close;

% 方法4：关闭所有并行池（更彻底）

delete(gcp('nocreate'));

注意：在脚本或函数中，尤其是可能被多次调用的函数中，良好的实践是管理好并行池的生命周期。一种常见的模式是“按需创建，用完即删”，或者检查是否存在池，避免重复创建。
并行池的持久化：默认情况下，并行池在启动后，工作进程会保持活动状态一段时间（即使当前没有并行任务），以便快速响应下一次并行计算。这个空闲超时时间可以在Matlab的“主页”->“环境”->“并行”->“并行首选项”中设置。对于需要频繁进行小型并行计算的任务，适当增加超时时间可以减少重复启动的开销；对于内存紧张的情况，则可以减少超时时间或设置为“关闭时删除池”。

2.3 配置与性能调优初步

对于本地计算，Matlab的默认'local'配置通常足够。但你可以通过parcluster和parpool进行一些微调。

MATLAB

% 获取本地集群配置对象

c = parcluster('local');

% 修改配置，例如设置最大工作进程数（通常不超过物理核心数）

c.NumWorkers = 6;

c.NumThreads = 1; % 每个工作进程使用的计算线程数，通常保持为1（使用MKL等库内部会多线程）

% 保存修改后的配置

saveProfile(c);

% 使用修改后的配置启动池

pool = parpool(c, 4); % 即使c.NumWorkers=6，这里也可以只启动4个

关于NumThreads：对于计算本身是高度向量化、并能从多线程数学库（如Intel MKL）中受益的任务，将每个工作进程的NumThreads设为大于1的值，可能会在单个工作进程内获得更好的性能。但这需要谨慎测试，因为过多的线程可能导致缓存争用，反而降低性能。对于大多数由parfor驱动的粗粒度任务，保持NumThreads=1是稳妥的选择。

3. parfor循环：并行化的主力军

parfor（Parallel FOR loop）是parpool最常用、最直接的“用武之地”。它的语法与普通for循环极其相似，但内涵却大不相同。

3.1 parfor的基本语法与限制

基本语法就是把for替换成parfor：

MATLAB

parfor i = 1:n

% 循环体

end

但并非所有for循环都能直接改为parfor。为了保证并行执行的正确性，parfor循环体必须满足一个核心条件：各次迭代必须是独立的。即第i次迭代的计算不能依赖于第j次迭代（j≠i）的结果。这被称为“无循环迭代间依赖”。

常见的不支持或需要特别注意的情况：

迭代顺序依赖：例如，在循环内对同一个变量进行累加（x = x + A(i)）。这会导致“竞态条件”，因为多个工作进程可能同时读写x，结果无法预测。
缩减变量：虽然累加不行，但Matlab为求和、求积等特定操作提供了“缩减变量”的特殊支持。我们稍后详述。
修改循环索引：在循环体内修改索引i是不允许的。
嵌套parfor：parfor循环不能直接嵌套。但parfor循环内部可以包含普通的for循环。
break/return语句：parfor循环体内不能使用break或return来提前退出整个循环，因为各个迭代是独立分发的，无法协调全局退出。但可以使用continue跳过当前迭代的剩余部分。
全局变量与持久变量：尽量避免在parfor内修改全局变量（global）或持久变量（persistent），这同样会导致不可预知的结果。

3.2 变量分类：理解代码如何被分发与收集

这是理解parfor如何工作的关键。Matlab会根据变量在循环中的使用方式，自动将它们分为以下几类。理解这些分类，能帮你写出正确高效的parfor代码。

循环变量：就是i。它在每个工作进程中有各自独立的值。
广播变量：在parfor循环之前定义，在循环体内只读的变量。它们会被复制到每个工作进程的内存空间中。例如：

MATLAB

A = rand(1000, 1); % 广播变量

threshold = 0.5; % 广播变量

parfor i = 1:1000

if A(i) > threshold

% ... 使用A(i)和threshold进行计算，但不修改它们

end

end

A和threshold被完整地复制到每个工作进程。如果A非常大，这种复制会产生显著的内存开销和通信延迟。
切片变量：这是一种特殊的输入/输出变量。它是一个数组，在循环体内，每个迭代只访问其一个特定的、由循环索引决定的元素（或固定维度的切片），并且可能修改该元素。Matlab能识别这种模式，并高效地处理数据分发和收集。

MATLAB

n = 1000;

result = zeros(n, 1); % 预分配结果数组

parfor i = 1:n

result(i) = someHeavyComputation(i); % result是切片变量，每个迭代只写result(i)

end

在这个例子中，result被识别为切片变量。每个工作进程计算一部分i对应的someHeavyComputation(i)，并将结果写回result数组的对应位置。所有迭代完成后，客户端汇总得到完整的result。正确使用切片变量是parfor高效的关键。
缩减变量：用于实现跨迭代的累积操作，如求和、求积、最大值、最小值等。Matlab内置支持对特定运算符的缩减。

MATLAB

total = 0; % 缩减变量（求和）

parfor i = 1:n

total = total + A(i); % 符合缩减模式

end

虽然看起来像有依赖，但Matlab能识别+运算符和total的累积模式，会在每个工作进程内部进行部分求和，最后在客户端合并部分和，从而得到正确结果。支持的运算符包括+, *, &, |, &&, ||, max, min等。
临时变量：在parfor循环内部定义和使用的变量。它们在每次迭代中都是独立的，不同迭代间互不影响。

3.3 实战代码示例与效率对比

让我们通过一个具体的计算实例来感受parfor的威力：计算蒙特卡洛方法估算π值。

串行版本 (for循环):

MATLAB

function pi_estimate = estimatePiSerial(numPoints)

tic;

count_inside = 0;

for i = 1:numPoints

x = rand();

y = rand();

if (x^2 + y^2) <= 1

count_inside = count_inside + 1;

end

pi_estimate = 4 * count_inside / numPoints;

elapsedTime = toc;

fprintf('串行计算: π ≈ %.10f, 耗时: %.4f 秒\n', pi_estimate, elapsedTime);

end

并行版本 (parfor循环):

MATLAB

function pi_estimate = estimatePiParallel(numPoints)

% 确保有并行池，没有则创建

if isempty(gcp('nocreate'))

parpool;

end

tic;

count_inside = 0;

parfor i = 1:numPoints

x = rand(); % 注意：每个工作进程有独立的随机数流，但总体是随机的

y = rand();

if (x^2 + y^2) <= 1

count_inside = count_inside + 1; % count_inside是缩减变量

end

pi_estimate = 4 * count_inside / numPoints;

elapsedTime = toc;

fprintf('并行计算: π ≈ %.10f, 耗时: %.4f 秒\n', pi_estimate, elapsedTime);

end

性能测试与对比： 在我的测试机器（8核CPU）上，设置numPoints = 1e8：

TEXT

串行计算: π ≈ 3.1415909200, 耗时: 24.7365 秒

并行计算: π ≈ 3.1415510800, 耗时: 4.1128 秒

加速比接近 6倍。这已经非常接近理想情况（8倍），因为并行计算本身存在一些开销，包括启动工作进程、分发任务、收集结果、以及rand()函数在并行环境下的协调等。

重要提示：并行计算并非总是更快。如果循环体本身计算量非常小（例如只是简单的加法），那么并行化的开销（通信、启动）可能会超过计算本身带来的收益，导致加速比小于1甚至更慢。通常，建议每个迭代的计算耗时在十分之一秒以上，使用parfor才能带来明显收益。

4. 超越parfor：spmd、parfeval与数据并行处理

parfor适用于“单程序多数据”的并行模式，即同一个操作应用于大量独立数据。Matlab并行工具箱还提供了其他更灵活的工具。

4.1 spmd：单程序多数据的手动控制

spmd（Single Program Multiple Data）块允许你在所有工作进程上执行相同的代码，但每个进程可以操作不同的数据，并且拥有自己的标识符（labindex）和知道进程总数（numlabs）。它提供了比parfor更底层的控制。

MATLAB

% 假设当前有4个工作进程的并行池

spmd

% 这段代码会在每个工作进程上同时执行

myLabID = labindex;

totalLabs = numlabs;

% 每个进程分配一部分数据

n = 1000;

chunkSize = n / totalLabs;

startIdx = (myLabID - 1) * chunkSize + 1;

endIdx = myLabID * chunkSize;

% 每个进程计算自己那部分数据的和

localData = rand(chunkSize, 1);

localSum = sum(localData);

% 将每个进程的localSum发送到客户端（lab 1），或者使用gplus等通信函数

end

% 在客户端访问结果

% spmd块中定义的变量（如localSum）在客户端是一个Composite对象

% 它像一个元胞数组，每个元素对应一个工作进程的结果

allSums = localSum; % allSums是一个Composite

totalSum = 0;

for i = 1:length(allSums)

totalSum = totalSum + allSums{i};

end

fprintf('所有进程随机数总和: %f\n', totalSum);

spmd的强大之处在于进程间可以通过labSend、labReceive、gop（全局操作）等函数进行显式通信，实现更复杂的并行算法。但对于简单的数据并行，parfor通常更简洁高效。

4.2 parfeval：异步执行与未来对象

parfeval（Parallel Function Evaluation）用于异步地在并行池的工作进程上执行函数。它立即返回一个Future对象，而计算在后台进行。你可以继续执行主程序的其它代码，稍后再来获取结果。这对于执行多个独立任务、或者构建响应式GUI应用非常有用。

MATLAB

% 启动一个并行池（如果尚未启动）

if isempty(gcp('nocreate'))

parpool(4);

end

% 定义要并行执行的函数

myHeavyFunction = @(seed) sum(rand(seed, 1e6)); % 一个耗时的函数

% 使用parfeval异步提交4个任务

for i = 1:4

futures(i) = parfeval(@myHeavyFunction, 1, i); % 1表示输出参数个数

end

% 主程序可以继续做其他事情...

disp('任务已提交，主程序继续运行...');

pause(2);

% 等待并获取结果

results = fetchOutputs(futures); % 这会阻塞，直到所有future完成

disp('所有任务完成，结果:');

disp(results);

% 或者，使用afterEach或afterAll进行回调（需要MATLAB R2020b或更新）

% afterEach(futures, @(result) disp(['一个任务完成，结果：', num2str(result)]));

parfeval提供了极大的灵活性，你可以动态地提交任务，管理任务队列，甚至取消未完成的任务（cancel(future)）。fetchNext函数可以用来处理最先完成的任务的结果，实现动态负载均衡。

4.3 大数据处理：分布式数组与并行数据存储

当数据量太大，无法装入单台机器的内存时，就需要使用分布式数组。分布式数组将一个大数组分割成多个部分，存储在不同工作进程（甚至不同计算机）的内存中。计算会自动在持有数据的工作进程上进行。

MATLAB

% 在并行池上创建一个分布式数组

% 这要求数据本身能被所有工作进程访问（例如通过共享文件系统或并行数据存储）

parpool(4);

D = distributed.rand(10000, 10000); % 创建一个10000x10000的分布式随机矩阵

% 现在D分布在4个工作进程上，每个进程持有2500x10000的一部分

% 对分布式数组的操作会自动并行化

D_squared = D .^ 2; % 逐元素平方，计算在各数据所在进程并行进行

sum_D = sum(D, 'all'); % 全局求和，涉及进程间通信

% 将分布式数组收集回客户端（如果内存允许）

D_local = gather(D);

与分布式数组配套的是并行数据存储，它允许你从多个文件中并行加载数据，每个工作进程加载一部分，然后组合成分布式数组。这对于处理超大型数据集（如图像序列、时间序列数据库）至关重要。

5. 性能瓶颈诊断、常见陷阱与调试技巧

并行编程引入了新的复杂性，也带来了新的问题。即使代码语法正确，也可能遇到性能不佳或结果错误的情况。

5.1 识别并行开销与负载不均衡

并行加速的理想公式是 Speedup = T_serial / T_parallel，其中T_parallel = T_computation / N + T_overhead。T_overhead（并行开销）包括：

启动开销：启动和关闭并行池的时间。
通信开销：将广播变量复制到各工作进程、收集切片变量结果的时间。如果循环体计算很快，但需要广播一个巨大的矩阵，开销可能占主导。
任务分发开销：parfor需要将迭代动态分配给空闲工作进程。

诊断工具：使用ticBytes和tocBytes来估算并行池中传输的数据量，帮助判断通信开销是否过大。

MATLAB

pool = gcp;

ticBytes(pool); % 开始统计字节传输

parfor i = 1:n

% ... 循环体

end

tocBytes(pool) % 显示传输的字节数

负载不均衡：如果parfor循环每次迭代的计算时间差异很大，可能导致一些工作进程早早完工而闲置，另一些还在忙碌，从而拉低整体效率。parfor默认使用动态调度来缓解这个问题，但如果迭代间耗时差异是数量级的，可能需要考虑手动将任务分组，或者使用spmd进行更精细的控制。

5.2 随机数生成：一个隐蔽的陷阱

在并行计算中，随机数的生成需要特别小心。如果每个工作进程都使用相同的默认随机数种子，那么它们将生成完全相同的随机数序列，这在进行蒙特卡洛模拟时会导致严重错误，因为你的“随机”实验不再是独立的。

Matlab提供了几种解决方案：

使用parfor循环索引：在循环体内，使用i（或结合其他信息）作为随机数流的种子。但要注意，rand、randn等函数是全局流，直接设置rng(i)在并行循环内可能有问题。
使用RandStream创建独立流：这是推荐的做法。可以为每个工作进程或每次迭代创建独立的随机数流。

MATLAB

parfor i = 1:n

% 为每次迭代创建一个独立的随机数流，种子基于i

stream = RandStream('Threefry', 'Seed', i);

% 将该流设为当前工作进程的全局流（仅影响当前工作进程）

RandStream.setGlobalStream(stream);

x = rand(); % 现在每个迭代的rand()调用都基于独立的流

% ... 其余计算

end
使用支持并行的随机函数：如randn(___, 'like', p)，其中p是并行池对象或分布式数组，但用法相对复杂。

强烈建议：在进行任何涉及随机数的并行计算前，先在小规模测试中验证随机数的独立性。可以运行两次相同的并行代码，检查结果是否不同（如果是真随机，应该不同）；或者检查不同工作进程（或迭代）生成的随机数序列是否相关。

5.3 调试并行代码

调试并行代码比串行代码更具挑战性，因为你无法直接设置断点并单步执行多个工作进程。Matlab提供了一些辅助工具：

spmd调试：在spmd块内，你可以设置断点。当执行到断点时，Matlab会进入调试模式，但一次只显示一个工作进程（默认为lab 1）的状态。你可以通过命令窗口顶部的“工作进程”下拉菜单切换到其他工作进程进行查看。
parfor和parfeval调试：直接设置断点可能不会按预期工作。更实用的方法是：
- 将parfor改为for：这是最有效的调试方法。先确保你的算法在串行模式下完全正确。
- 使用disp或fprintf输出日志：在每个工作进程上输出标识信息和变量值。注意，输出可能会交错显示在命令窗口。
  
  MATLAB
  
  parfor i = 1:10
  
  workerID = getCurrentTask().ID; % 获取当前任务ID（近似工作进程ID）
  
  fprintf('Worker %d processing iteration %d\n', workerID, i);
  
  % ... 计算
  
  end
- 捕获并重新抛出错误：使用try-catch块捕获循环体内的错误，并打印出更多上下文信息（如迭代索引i），然后再将错误重新抛出。
  
  MATLAB
  
  parfor i = 1:n
  
  try
  
  % ... 可能出错的代码
  
  catch ME
  
  fprintf('Error occurred at iteration %d: %s\n', i, ME.message);
  
  rethrow(ME); % 或者只记录错误，继续执行其他迭代
  
  end
  
  end
parallel.pool.Constant：对于在parfor中需要重复使用的只读大数组，将其包装为parallel.pool.Constant可以显著减少通信开销，因为它只会在第一次需要时被发送到工作进程，之后便缓存起来。

MATLAB

largeData = rand(10000, 10000); % 一个大矩阵

dataConstant = parallel.pool.Constant(largeData);

parfor i = 1:100

% 在循环内访问，数据只会传输一次并缓存

chunk = dataConstant.Value(i:i+99, :);

% ... 处理chunk

end

6. 从桌面到集群：扩展你的并行计算规模

对于超大规模计算问题，单台计算机的CPU核心和内存可能成为瓶颈。此时，你可以将Matlab并行计算扩展到计算机集群上。这需要MATLAB Parallel Server（以前称为MDCS）的支持。

6.1 集群配置概要

在集群上运行并行计算，核心概念是配置文件。集群管理员会提供一个配置文件（.mlsettings文件），其中包含了如何与集群调度器（如Slurm、PBS、LSF等）交互的所有信息：如何提交作业、申请多少节点/核心、作业队列名称、最大运行时间等。

你需要将这个配置文件导入到你的Matlab客户端：

在Matlab中，打开“并行”菜单 -> “创建和管理集群”。
点击“导入”，选择集群管理员提供的配置文件。
导入后，该集群配置会出现在列表中。你可以将其设为默认配置。

6.2 在集群上使用parpool

配置好后，在代码中启动并行池的方式与本地类似，但需要指定集群配置名：

MATLAB

% 使用名为'MyCluster'的集群配置启动一个包含32个工作进程的并行池

pool = parpool('MyCluster', 32);

当你执行这行代码时，Matlab客户端会通过配置文件中的指令，向集群调度器提交一个作业申请。这个作业请求一定数量的计算节点，每个节点上运行一定数量的Matlab工作进程。调度器在资源就绪后，会启动这些工作进程，并与你的客户端建立连接。之后的parfor、spmd等操作就会在远端的集群节点上执行。

6.3 注意事项与最佳实践

数据位置与传输：在集群上，你的代码和数据默认位于客户端机器。当启动并行池后，运行parfor所需的代码文件（.m）和广播变量会自动分发到集群节点。如果广播变量非常大，网络传输会成为巨大瓶颈。因此，应尽量将大数据存储在集群的共享文件系统上，并在工作进程上直接加载（例如，在spmd块内让每个进程加载自己需要的数据块），或者使用分布式数组。
文件依赖：确保集群节点能够访问你的函数文件。最简单的方法是将相关文件夹添加到Matlab路径，并在集群配置中设置“附加文件/文件夹”以自动传输。
作业监控：你可以使用集群提供的作业监控命令（如squeue for Slurm）来查看你的Matlab并行作业状态。Matlab客户端也会显示连接状态。
资源请求合理性：根据任务实际需求申请核心数和内存。申请过多资源会导致作业排队时间变长，也可能浪费集群资源。

从桌面并行到集群并行，思维需要从“共享内存”转向“分布式内存”。通信开销变得更为显著，数据本地性（让计算靠近数据）的设计原则变得至关重要。