Windows平台下多线程同步的锁机制实现咨询

Great question—syncing browser automation scripts across multiple instances on Windows can be tricky, but you’ve got some solid options here. Let’s break down your file lock idea first, then dive into more reliable alternatives tailored to your JS/Batch stack:

Short answer: Yes, it works—but it has caveats.

Windows provides atomic file system operations you can leverage for locking:

• Using mkdir: Directory creation is atomic on Windows—only one process can create a specific directory at a time. If the mkdir succeeds, you’ve got the lock; if it fails, another script is holding it.
• Exclusive file access: You can open a file in exclusive mode (via Batch/PowerShell), and other processes will be blocked from opening it until you release the handle.

Example Batch script for directory-based locking: #

@echo off
set "LOCK_DIR=C:\BrowserSyncLock"

:: Try to acquire lock by creating directory
mkdir "%LOCK_DIR%" 2>nul
if %errorlevel% equ 0 (
  echo Lock acquired, proceeding with save/upload...
  
  :: Insert your browser automation trigger here (e.g., calling JS script via automation tool)
  call your-browser-automation-script.js
  
  :: Release lock by deleting directory
  rmdir "%LOCK_DIR%"
) else (
  echo Waiting for lock...
  :: Loop until lock is available
  :WAIT_LOOP
  timeout /t 1 /nobreak >nul
  mkdir "%LOCK_DIR%" 2>nul
  if %errorlevel% neq 0 goto WAIT_LOOP
  
  :: Once lock is acquired
  echo Lock acquired after wait, proceeding...
  call your-browser-automation-script.js
  rmdir "%LOCK_DIR%"
)

Caveats to file locks: #

• Crash resilience: If a script crashes mid-operation, the lock directory/file will linger, blocking all subsequent scripts. You’ll need to add timeout logic or a cleanup step (e.g., checking if the lock is stale by looking for a process ID file).
• Browser JS limitations: Pure browser-side JS can’t directly create/delete files due to security sandbox restrictions—you’ll need to wrap this logic in Batch/PowerShell and trigger it from your JS automation tool (like Playwright/Puppeteer).

For more reliable cross-process sync, Windows-native primitives are a better bet:

1. Named Mutexes (System-level locks) #

Windows named mutexes are designed exactly for this scenario—they’re atomic, automatically released if a process crashes, and work across all processes on the system.

Example: Batch + PowerShell mutex wrapper #

You can call PowerShell from Batch to interact with .NET’s Mutex class:

@echo off
set "MUTEX_NAME=Global\BrowserSaveSyncMutex"

:: Acquire mutex (wait up to 10 seconds)
powershell -Command "$mutex = New-Object System.Threading.Mutex($false, '%MUTEX_NAME%'); $success = $mutex.WaitOne(10000); if (-not $success) { exit 1; }"
if %errorlevel% neq 0 (
  echo Timeout waiting for lock, exiting...
  exit 1
)

:: Perform synchronized browser operation
echo Performing save/upload in browser...
call your-browser-automation-step.js

:: Release mutex
powershell -Command "$mutex = [System.Threading.Mutex]::OpenExisting('%MUTEX_NAME%'); $mutex.ReleaseMutex();"

If you’re using Node.js-based automation (like Playwright), you can call this Batch script directly from your JS code via child_process.

2. Local Sync Server (for pure browser JS) #

If your scripts are running strictly in the browser sandbox (no Node.js/Batch access), spin up a tiny local Node.js server to handle synchronization. The server holds a single lock, and browser scripts request access via HTTP.

Example Node.js sync server: #

const http = require('http');
const { Mutex } = require('async-mutex'); // Install via npm install async-mutex

const syncMutex = new Mutex();
const server = http.createServer(async (req, res) => {
  res.setHeader('Access-Control-Allow-Origin', '*'); // Allow browser requests

  if (req.method === 'POST') {
    switch (req.url) {
      case '/acquire':
        const releaseLock = await syncMutex.acquire();
        // Auto-release after 30s to handle crashed scripts
        setTimeout(() => releaseLock(), 30000);
        res.writeHead(200);
        res.end('LOCK_GRANTED');
        break;
      case '/release':
        try {
          syncMutex.release();
          res.writeHead(200);
          res.end('LOCK_RELEASED');
        } catch (err) {
          res.writeHead(400);
          res.end('NO_LOCK_TO_RELEASE');
        }
        break;
      default:
        res.writeHead(404);
        res.end();
    }
  } else {
    res.writeHead(404);
    res.end();
  }
});

server.listen(3000, 'localhost', () => {
  console.log('Sync server running on http://localhost:3000');
});

Browser JS to use the server: #

async function acquireLock() {
  const response = await fetch('http://localhost:3000/acquire', { method: 'POST' });
  if (response.status !== 200) throw new Error('Failed to get lock');
}

async function releaseLock() {
  await fetch('http://localhost:3000/release', { method: 'POST' });
}

async function runSynchronizedSave() {
  try {
    await acquireLock();
    console.log('Lock acquired, triggering save dialog...');
    // Your code to trigger browser save/upload here
    await new Promise(resolve => setTimeout(resolve, 5000)); // Simulate operation time
  } finally {
    await releaseLock();
  }
}

runSynchronizedSave();

• Use named mutexes if you have access to Batch/PowerShell/Node.js—they’re the most reliable and low-maintenance option for Windows.
• Stick with file locks only for simple, low-stakes scenarios where you can add crash cleanup logic.
• Use the local sync server if you’re limited to pure browser-side JS.

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