diff --git a/jsowell-pile/src/main/java/com/jsowell/pile/jcpp/service/impl/JcppPileSyncServiceImpl.java b/jsowell-pile/src/main/java/com/jsowell/pile/jcpp/service/impl/JcppPileSyncServiceImpl.java
index 645a6340b..22323978c 100644
--- a/jsowell-pile/src/main/java/com/jsowell/pile/jcpp/service/impl/JcppPileSyncServiceImpl.java
+++ b/jsowell-pile/src/main/java/com/jsowell/pile/jcpp/service/impl/JcppPileSyncServiceImpl.java
@@ -103,23 +103,31 @@ public class JcppPileSyncServiceImpl implements IJcppPileSyncService {
                 List<PileBasicInfo> batchPiles = pileBatches.get(i);
                 int batchNo = i + 1;
 
+                long batchStartTime = System.currentTimeMillis();
                 log.info("开始处理第 {}/{} 批充电桩，本批数量: {}", batchNo, totalBatches, batchPiles.size());
 
                 try {
                     // 5.1 转换充电桩数据
+                    long convertStartTime = System.currentTimeMillis();
                     List<JcppPileSyncDTO> pileDTOs = convertPilesToDTO(batchPiles);
+                    long convertTime = System.currentTimeMillis() - convertStartTime;
+                    log.debug("第 {} 批：充电桩数据转换耗时 {} ms", batchNo, convertTime);
 
                     // 5.2 先同步充电桩（充电枪依赖充电桩，必须先同步充电桩）
                     log.info("第 {} 批：开始同步充电桩...", batchNo);
+                    long pileSyncStartTime = System.currentTimeMillis();
                     List<JcppSyncResult> batchPileResults = syncPilesToJcpp(pileDTOs);
+                    long pileSyncTime = System.currentTimeMillis() - pileSyncStartTime;
                     allPileResults.addAll(batchPileResults);
 
                     // 统计充电桩同步结果
                     long batchPileSuccess = batchPileResults.stream().filter(JcppSyncResult::isSuccess).count();
                     long batchPileFailed = batchPiles.size() - batchPileSuccess;
-                    log.info("第 {} 批：充电桩同步完成 {}/{} (成功/总数)", batchNo, batchPileSuccess, batchPiles.size());
+                    log.info("第 {} 批：充电桩同步完成 {}/{} (成功/总数)，耗时 {} ms",
+                            batchNo, batchPileSuccess, batchPiles.size(), pileSyncTime);
 
                     // 5.3 查找本批充电桩对应的充电枪（只同步充电桩成功的枪）
+                    long gunFilterStartTime = System.currentTimeMillis();
                     List<String> successPileSns = batchPileResults.stream()
                             .filter(JcppSyncResult::isSuccess)
                             .map(JcppSyncResult::getCode)
@@ -128,32 +136,44 @@ public class JcppPileSyncServiceImpl implements IJcppPileSyncService {
                     List<PileConnectorInfo> batchGuns = gunList.stream()
                             .filter(gun -> successPileSns.contains(gun.getPileSn()))
                             .collect(java.util.stream.Collectors.toList());
+                    long gunFilterTime = System.currentTimeMillis() - gunFilterStartTime;
 
-                    log.info("第 {} 批：找到 {} 个充电枪（对应 {} 个成功的充电桩）", batchNo, batchGuns.size(), successPileSns.size());
+                    log.info("第 {} 批：找到 {} 个充电枪（对应 {} 个成功的充电桩），筛选耗时 {} ms",
+                            batchNo, batchGuns.size(), successPileSns.size(), gunFilterTime);
 
                     // 5.4 同步充电枪（只同步充电桩成功的枪）
                     List<JcppSyncResult> batchGunResults = new ArrayList<>();
                     if (!batchGuns.isEmpty()) {
+                        long gunConvertStartTime = System.currentTimeMillis();
                         List<JcppGunSyncDTO> gunDTOs = convertGunsToDTO(batchGuns);
+                        long gunConvertTime = System.currentTimeMillis() - gunConvertStartTime;
+                        log.debug("第 {} 批：充电枪数据转换耗时 {} ms", batchNo, gunConvertTime);
+
                         log.info("第 {} 批：开始同步充电枪...", batchNo);
+                        long gunSyncStartTime = System.currentTimeMillis();
                         batchGunResults = syncGunsToJcpp(gunDTOs);
+                        long gunSyncTime = System.currentTimeMillis() - gunSyncStartTime;
                         allGunResults.addAll(batchGunResults);
 
                         long batchGunSuccess = batchGunResults.stream().filter(JcppSyncResult::isSuccess).count();
-                        log.info("第 {} 批：充电枪同步完成 {}/{} (成功/总数)", batchNo, batchGunSuccess, batchGuns.size());
+                        log.info("第 {} 批：充电枪同步完成 {}/{} (成功/总数)，耗时 {} ms",
+                                batchNo, batchGunSuccess, batchGuns.size(), gunSyncTime);
                     } else {
                         log.warn("第 {} 批：没有需要同步的充电枪（充电桩全部失败）", batchNo);
                     }
 
-                    // 5.5 统计本批总体结果
+                    // 5.5 统计本批总体结果和耗时
                     long batchGunSuccess = batchGunResults.stream().filter(JcppSyncResult::isSuccess).count();
-                    log.info("第 {}/{} 批同步完成: 充电桩 {}/{}, 充电枪 {}/{}",
+                    long batchTotalTime = System.currentTimeMillis() - batchStartTime;
+                    log.info("第 {}/{} 批同步完成: 充电桩 {}/{}, 充电枪 {}/{}, 总耗时 {} ms",
                             batchNo, totalBatches,
                             batchPileSuccess, batchPiles.size(),
-                            batchGunSuccess, batchGuns.size());
+                            batchGunSuccess, batchGuns.size(),
+                            batchTotalTime);
 
                 } catch (Exception e) {
-                    log.error("第 {} 批同步失败", batchNo, e);
+                    long batchTotalTime = System.currentTimeMillis() - batchStartTime;
+                    log.error("第 {} 批同步失败，耗时 {} ms", batchNo, batchTotalTime, e);
                     // 记录失败，但继续处理下一批
                     for (PileBasicInfo pile : batchPiles) {
                         allPileResults.add(JcppSyncResult.fail(pile.getSn(), "批次同步异常: " + e.getMessage()));