Electron.js 跨进程通信：在渲染进程中调用主进程的多线程函数

// main.js

const { app, BrowserWindow, ipcMain } = require('electron');
const { spawn, Worker, Thread } = require('threads');
const path = require('path');

// 假设这是你的多线程任务函数
// 它会创建一个工作线程来处理数据，例如文件发送或复杂计算
const sendFile = async (text) => {
    try {
        // 使用 threads.js 创建一个工作线程
        // './src/service/sender.js' 是实际执行多线程逻辑的文件
        const sendWorker = await spawn(new Worker(path.join(__dirname, 'src/service/sender.js')));
        // 调用工作线程的函数并传递数据
        const response = await sendWorker(text);
        console.log('Worker responded:', response);
        // 终止工作线程以释放资源
        await Thread.terminate(sendWorker);
        return response; // 返回工作线程的结果
    } catch (error) {
        console.error('Error in sendFile worker:', error);
        throw error;
    }
};

// 设置 IPC 监听器，等待渲染进程发送 'msg' 消息
ipcMain.on('msg', async (event, data) => {
    console.log('Received message from renderer:', data);
    try {
        // 调用主进程中的多线程函数
        const result = await sendFile(data);
        // 可以选择将结果返回给渲染进程
        event.reply('msg-reply', `Task completed: ${result}`);
    } catch (error) {
        event.reply('msg-reply', `Task failed: ${error.message}`);
    }
});

// 其他 Electron 主进程初始化代码...
app.whenReady().then(() => {
    const mainWindow = new BrowserWindow({
        width: 800,
        height: 600,
        webPreferences: {
            nodeIntegration: false, // 推荐禁用 nodeIntegration
            contextIsolation: true, // 推荐启用 contextIsolation
            preload: path.join(__dirname, 'preload.js') // 预加载脚本
        }
    });

    mainWindow.loadFile('index.html');
});

app.on('window-all-closed', () => {
    if (process.platform !== 'darwin') {
        app.quit();
    }
});

app.on('activate', () => {
    if (BrowserWindow.getAllWindows().length === 0) {
        createWindow();
    }
});

// preload.js

const { contextBridge, ipcRenderer } = require('electron');

contextBridge.exposeInMainWorld('electronAPI', {
    sendMessageToMain: (message) => ipcRenderer.send('msg', message),
    onMainReply: (callback) => ipcRenderer.on('msg-reply', (event, arg) => callback(arg))
});

// renderer.js (在你的 HTML 页面中引用)

document.addEventListener('DOMContentLoaded', () => {
    const sendButton = document.getElementById('send-data-button');
    const dataInput = document.getElementById('data-input');
    const responseDiv = document.getElementById('response');

    if (sendButton && dataInput && responseDiv) {
        sendButton.addEventListener('click', () => {
            const dataToSend = dataInput.value || 'Hello from render process!';
            console.log('Sending data to main:', dataToSend);
            // 通过预加载脚本暴露的 API 发送消息到主进程
            window.electronAPI.sendMessageToMain(dataToSend);
            responseDiv.textContent = 'Sending...';
        });

        // 监听来自主进程的回复
        window.electronAPI.onMainReply((response) => {
            console.log('Received reply from main:', response);
            responseDiv.textContent = `Main process reply: ${response}`;
        });
    }
});

// src/service/sender.js

const { expose } = require('threads/worker');

expose(async (text) => {
    console.log(`Worker received: ${text}`);
    // 模拟一个耗时操作
    await new Promise(resolve => setTimeout(resolve, 2000));
    const result = `Processed "${text}" in worker thread.`;
    console.log(`Worker sending back: ${result}`);
    return result;
});

{
  "name": "electron-multithread-demo",
  "version": "1.0.0",
  "description": "Demonstrates multithreading in Electron via IPC",
  "main": "main.js",
  "scripts": {
    "start": "electron ."
  },
  "dependencies": {
    "electron": "^24.3.1",
    "threads": "^1.7.0"
  }
}