AIWROK软件多线程thread1.runJsFile例子

QQ896757558

T = time.nowStamp();

// 正确启动两个线程（线程名必须不同！）
var thread1 = new thread(); // 线程对象1
var thread2 = new thread(); // 线程对象2
thread1.runJsFile('线程1.js', 'worker1'); // 线程名用"worker1"
thread2.runJsFile('线程2.js', 'worker2'); // 线程名用"worker2"

// 监控循环（10秒后停止线程1）
while (true) {
printl("正常运行");
sleep.millisecond(1000);

if (time.nowStamp() - T > 10000) {
thread1.stop(); // 停止线程1（通过对象实例）
break; // 退出监控循环
}
}

这段代码的主要功能是启动两个独立的JavaScript线程，并监控它们的运行状态。10秒后，代码会停止其中一个线程。下面是对代码的详细解释：

1. T = time.nowStamp();：获取当前的时间戳，并将其赋值给变量T。这个时间戳用于后续计算程序已经运行的时间。
2. 创建两个线程对象：var thread1 = new thread(); 和 var thread2 = new thread();。这里创建了两个线程实例，分别命名为thread1和thread2。
3. 启动线程：

• thread1.runJsFile('线程1.js', 'worker1');：启动thread1，并运行名为线程1.js的JavaScript文件。同时，为这个线程指定一个名字worker1。
• thread2.runJsFile('线程2.js', 'worker2');：启动thread2，并运行名为线程2.js的JavaScript文件。同时，为这个线程指定一个名字worker2。

4. 进入一个无限循环while (true)，在此循环中：

• printl("正常运行");：打印字符串"正常运行"到控制台，用于检查程序是否在正常运行。
• sleep.millisecond(1000);：让当前线程休眠1000毫秒（即1秒），暂停执行后续代码以避免短时间内频繁打印，提高程序的可读性。
• if (time.nowStamp() - T > 10000)：计算当前时间与T所记录的时间之间的差值，判断是否已经过去了10000毫秒（即10秒）。如果是，则执行thread1.stop();，即停止thread1线程。
• break;：退出无限循环，结束监控。

// ======================
// 兼容版线程控制示例
// ======================

// 初始化
var T = time.nowStamp(); // 记录系统启动的时间戳
var MAX_WORKERS = 4; // 定义最大工作线程数为4
var TASK_QUEUE = []; // 任务队列，用于存储待执行的任务
var isRunning = true; // 系统运行标志，当为true时，系统持续运行

// 1. 定义工作任务
function createTask(taskId) {
return {
id: taskId, // 任务ID
status: "pending", // 任务状态，初始为"pending"（待执行）
startTime: 0, // 任务开始时间，初始为0
endTime: 0 // 任务结束时间，初始为0
};
}

// 2. 工作线程执行函数
function workerFunction(workerId) {
while (isRunning) { // 当系统正在运行时，工作线程持续寻找任务
var task = TASK_QUEUE.find(t => t.status === "pending");
if (task) { // 找到待执行的任务
task.status = "running"; // 将任务状态更改为"running"（正在执行）
task.startTime = time.nowStamp(); // 记录任务开始时间
printl(`[${workerId}] 开始执行任务 ${task.id}`); // 打印工作线程开始执行任务的信息
try {
// 直接执行截图脚本
load("截图.js"); // 加载并执行"截图.js"脚本，用于执行具体的任务逻辑
task.status = "completed"; // 任务执行成功后，将状态更改为"completed"（已完成）
printl(`[${workerId}] 任务 ${task.id} 完成`); // 打印工作线程完成任务的信息
} catch (e) {
task.status = "failed"; // 如果任务执行过程中发生错误，将状态更改为"failed"（失败）
printl(`[${workerId}] 任务 ${task.id} 失败: ${e}`); // 打印工作线程任务失败的信息及错误原因
} finally {
task.endTime = time.nowStamp(); // 无论任务成功或失败，记录任务结束时间
}
}
sleep.millisecond(100); // 如果没有待执行的任务，工作线程休眠100毫秒后再次检查
}
}

// 3. 初始化线程池
function initThreadPool() {
for (var i = 0; i < MAX_WORKERS; i++) { // 根据MAX_WORKERS的数量创建相应数量的工作线程
var worker = new thread(); // 创建一个新线程
worker.runJsFile("截图.js", "worker-" + (i + 1)); // 让新线程运行"截图.js"脚本，传入线程ID作为参数
}
printl(`已创建 ${MAX_WORKERS} 个工作线程`); // 打印已创建的工作线程数量信息
}

// 4. 状态监控
function monitor() {
while (isRunning) { // 当系统正在运行时，持续监控任务进度
var completed = TASK_QUEUE.filter(t => t.status === "completed").length; // 统计已完成的任务数量
printl(`任务进度: ${completed}/${TASK_QUEUE.length}`); // 打印当前任务进度信息

if (time.nowStamp() - T > 10000) { // 如果系统运行时间超过10秒
isRunning = false; // 将系统运行标志设为false，停止系统运行
printl("监控结束"); // 打印监控结束的信息
break; // 退出循环
}
sleep.millisecond(2000); // 监控线程每2秒检查一次任务进度
}
}

// ======================
// 主程序执行
// ======================

// 添加任务
for (var i = 1; i <= 10; i++) { // 添加10个任务到任务队列
TASK_QUEUE.push(createTask("task-" + i)); // 调用createTask函数创建任务，并将其添加到TASK_QUEUE中
}

// 启动系统
initThreadPool(); // 初始化线程池，启动工作线程

// 启动监控线程
var monitorThread = new thread(); // 创建一个新的线程，用于监控
monitorThread.runJsFile("截图.js", "monitor"); // 让监控线程运行"截图.js"脚本，传入"monitor"作为参数

// 主线程执行监控
monitor(); // 主线程也运行监控函数，监控任务进度

printl("系统运行结束"); // 打印系统运行结束的信息

1. 以下是代码的详细说明：
2. 初始化

• var T = time.nowStamp();：记录系统启动的时间戳。
• var MAX_WORKERS = 4;：定义最大工作线程数为4。
• var TASK_QUEUE = [];：任务队列，用于存储待执行的任务。
• var isRunning = true;：系统运行标志，当为true时，系统持续运行。

3. 定义工作任务

• function createTask(taskId)：定义一个函数来创建任务对象。

• id: taskId：任务ID。
• status: "pending"：任务状态，初始为"pending"（待执行）。
• startTime: 0：任务开始时间，初始为0。
• endTime: 0：任务结束时间，初始为0。

4. 工作线程执行函数

• function workerFunction(workerId)：定义一个工作线程的执行函数。

• while (isRunning)：当系统正在运行时，工作线程持续寻找任务。
• var task = TASK_QUEUE.find(t => t.status === "pending");：从任务队列中找到状态为"pending"的任务。
• if (task)：如果找到待执行的任务。

• task.status = "running";：将任务状态更改为"running"（正在执行）。
• task.startTime = time.nowStamp();：记录任务开始时间。
• printl([{task.id});：打印工作线程开始执行任务的信息。
• try：尝试执行任务。

• load("截图.js");：加载并执行"截图.js"脚本，用于执行具体的任务逻辑。
• task.status = "completed";：任务执行成功后，将状态更改为"completed"（已完成）。
• printl([{task.id} 完成);：打印工作线程完成任务的信息。

• catch (e)：如果任务执行过程中发生错误。

• task.status = "failed";：将任务状态更改为"failed"（失败）。
• printl([{task.id} 失败: ${e});：打印工作线程任务失败的信息及错误原因。

• finally：无论任务成功或失败。

• task.endTime = time.nowStamp();：记录任务结束时间。

• sleep.millisecond(100);：如果没有待执行的任务，工作线程休眠100毫秒后再次检查。

5. 初始化线程池

• function initThreadPool()：定义一个函数来初始化线程池。

• for (var i = 0; i < MAX_WORKERS; i++)：根据MAX_WORKERS的数量创建相应数量的工作线程。

• var worker = new thread();：创建一个新线程。
• worker.runJsFile("截图.js", "worker-" + (i + 1));：让新线程运行"截图.js"脚本，传入线程ID作为参数。

• printl(已创建 ${MAX_WORKERS} 个工作线程);：打印已创建的工作线程数量信息。

6. 状态监控

• function monitor()：定义一个状态监控函数。

• while (isRunning)：当系统正在运行时，持续监控任务进度。

• var completed = TASK_QUEUE.filter(t => t.status === "completed").length;：统计已完成的任务数量。
• printl(任务进度: {TASK_QUEUE.length});：打印当前任务进度信息。
• if (time.nowStamp() - T > 10000)：如果系统运行时间超过10秒。

• isRunning = false;：将系统运行标志设为false，停止系统运行。
• printl("监控结束");：打印监控结束的信息。
• break;：退出循环。

• sleep.millisecond(2000);：监控线程每2秒检查一次任务进度。

7. 主程序执行

• 添加任务：使用for循环添加10个任务到任务队列。
• 启动系统：调用initThreadPool()函数初始化线程池，启动工作线程。
• 启动监控线程：创建一个新的线程用于监控，并运行"截图.js"脚本，传入"monitor"作为参数。
• 主线程执行监控：调用monitor()函数进行监控。