科技部空间

import concurrent.futures
import subprocess
import signal
import time

# 定义要执行的命令列表
commands = [
    ["ros2", "bag", "record"],
    ["other_command_1"],
    ["other_command_2"]
]

def execute_command(command):
    # 启动进程
    process = subprocess.Popen(command, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
    
    try:
        # 等待一段时间（例如 10 秒）
        time.sleep(10)
    except KeyboardInterrupt:
        # 如果收到 KeyboardInterrupt（Ctrl+C），发送中断信号
        process.send_signal(signal.SIGINT)
        print(f"收到中断信号，正在终止进程 {command}...")

    # 等待进程结束
    process.wait()

    # 获取进程的标准输出和标准错误
    stdout, stderr = process.communicate()

    # 输出结果
    print(f"进程 {command} 标准输出：", stdout)
    print(f"进程 {command} 标准错误：", stderr)

# 使用 ThreadPoolExecutor 启动并发任务
with concurrent.futures.ThreadPoolExecutor() as executor:
    # 提交每个命令作为一个任务
    futures = [executor.submit(execute_command, command) for command in commands]

    try:
        # 等待任意一个任务完成
        completed, _ = concurrent.futures.wait(futures, return_when=concurrent.futures.FIRST_COMPLETED)

        # 在特定任务完成后，关闭 executor（类似于Ctrl+C的效果）
        if any(future in completed for future in futures):
            print("特定任务完成，正在关闭 executor...")
            executor.shutdown(wait=False)
    except KeyboardInterrupt:
        # 如果收到 KeyboardInterrupt（Ctrl+C），取消所有未完成的任务
        for future in futures:
            future.cancel()

# 你可以添加额外的清理逻辑，根据需要等待任务的完成等
 

import concurrent.futures
import subprocess
import signal
import time

# 定义要执行的命令列表
commands = [
    ["ros2", "bag", "record"],
    ["other_command_1"],
    ["other_command_2"]
]

def execute_command(command):
    # 启动进程
    process = subprocess.Popen(command, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
    
    try:
        # 等待一段时间（例如 10 秒）
        time.sleep(10)
    except KeyboardInterrupt:
        # 如果收到 KeyboardInterrupt（Ctrl+C），发送中断信号
        process.send_signal(signal.SIGINT)
        print(f"收到中断信号，正在终止进程 {command}...")

    # 等待进程结束
    process.wait()

    # 获取进程的标准输出和标准错误
    stdout, stderr = process.communicate()

    # 输出结果
    print(f"进程 {command} 标准输出：", stdout)
    print(f"进程 {command} 标准错误：", stderr)

# 使用 ProcessPoolExecutor 启动并发任务
with concurrent.futures.ProcessPoolExecutor() as executor:
    # 提交每个命令作为一个任务
    futures = [executor.submit(execute_command, command) for command in commands]

    try:
        # 等待任意一个任务完成
        completed, _ = concurrent.futures.wait(futures, return_when=concurrent.futures.FIRST_COMPLETED)

        # 取消所有尚未完成的任务
        for future in futures:
            if future not in completed:
                future.cancel()
                print(f"任务 {future} 已取消")
    except KeyboardInterrupt:
        # 如果收到 KeyboardInterrupt（Ctrl+C），取消所有未完成的任务
        for future in futures:
            future.cancel()

# 你可以添加额外的清理逻辑，根据需要等待任务的完成等
 

import concurrent.futures
import subprocess
import signal
import time

# 定义要执行的命令列表
commands = [
    ["ros2", "bag", "record"],
    ["other_command_1"],
    ["other_command_2"]
]

def execute_command(command):
    # 启动进程
    process = subprocess.Popen(command, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
    
    try:
        # 等待一段时间（例如 10 秒）
        time.sleep(10)
    except KeyboardInterrupt:
        # 如果收到 KeyboardInterrupt（Ctrl+C），发送中断信号
        process.send_signal(signal.SIGINT)
        print(f"收到中断信号，正在终止进程 {command}...")

    # 等待进程结束
    process.wait()

    # 获取进程的标准输出和标准错误
    stdout, stderr = process.communicate()

    # 输出结果
    print(f"进程 {command} 标准输出：", stdout)
    print(f"进程 {command} 标准错误：", stderr)

# 使用 ThreadPoolExecutor 启动并发任务
with concurrent.futures.ThreadPoolExecutor() as executor:
    # 提交每个命令作为一个任务
    futures = [executor.submit(execute_command, command) for command in commands]

    try:
        # 等待所有任务完成
        concurrent.futures.wait(futures, timeout=concurrent.futures.ALL_COMPLETED)
    except KeyboardInterrupt:
        # 如果收到 KeyboardInterrupt（Ctrl+C），取消所有未完成的任务
        for future in futures:
            future.cancel()

# 你可以添加额外的清理逻辑，根据需要等待任务的完成等
 

import subprocess
import signal
import time

# 定义要执行的命令列表
commands = [
    ["ros2", "bag", "record"],
    ["other_command_1"],
    ["other_command_2"]
]

# 启动进程
processes = [subprocess.Popen(command, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True) for command in commands]

try:
    # 等待一段时间（例如 10 秒）
    time.sleep(10)
except KeyboardInterrupt:
    # 如果收到 KeyboardInterrupt（Ctrl+C），发送中断信号给所有进程
    for process in processes:
        process.send_signal(signal.SIGINT)
    print("收到中断信号，正在终止进程...")

# 等待所有进程结束
for process in processes:
    process.wait()

# 获取所有进程的标准输出和标准错误
outputs = [process.communicate() for process in processes]

# 输出结果
for i, (stdout, stderr) in enumerate(outputs):
    print(f"进程 {i + 1} 标准输出：", stdout)
    print(f"进程 {i + 1} 标准错误：", stderr)
 

import subprocess
import time
import signal

# 要执行的命令和参数
ros2_command = ["ros2", "bag", "record"]

# 使用 Popen 启动进程
process = subprocess.Popen(ros2_command, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)

try:
    # 等待一段时间（例如 10 秒）
    time.sleep(10)
except KeyboardInterrupt:
    # 如果收到 KeyboardInterrupt（Ctrl+C），发送中断信号
    process.send_signal(signal.SIGINT)
    print("收到中断信号，正在终止进程...")

# 等待进程结束
process.wait()

# 获取进程的标准输出和标准错误
stdout, stderr = process.communicate()

# 输出结果
print("标准输出：", stdout)
print("标准错误：", stderr)