Linux与Mac平台是否存在类似Android的getprop/setprop命令用于修改已编译应用属性？

Great question! Linux and macOS don't have a direct equivalent to Android's getprop/setprop—that system is tied to Android's init daemon and property service, which isn't present in desktop Unix-like systems. But besides environment variables (which work great on both platforms), there are several other ways to tweak compiled app behavior without recompiling, tailored to different use cases. Let's break them down with your thread-count example in mind:

1. Configuration Files #

Many apps rely on local config files (JSON, INI, plain text, etc.) to store runtime-adjustable settings. You can modify the file before launching the app, and the program reads it on startup.

Example for your thread count scenario: #

C++ code to read a JSON config file (using a lightweight library like nlohmann/json):

#include <fstream>
#include <nlohmann/json.hpp>
#include <iostream>

using json = nlohmann::json;

int main() {
    json config;
    try {
        std::ifstream config_file("config.json");
        config_file >> config;
    } catch (const std::exception& e) {
        std::cerr << "Failed to read config: " << e.what() << "\n";
        return 1;
    }

    int number_of_threads = config.value("number_of_threads", 2); // Default to 2 if missing
    std::cout << "NUMBER_OF_THREADS=" << number_of_threads << "\n";
    return 0;
}

Terminal steps:

# Create initial config
echo '{"number_of_threads": 4}' > config.json
# Run the app
./test
# Modify config for next run
echo '{"number_of_threads": 10}' > config.json
./test

2. Command-Line Arguments #

Pass values directly when launching the app—this is perfect for one-off adjustments without persisting settings.

Example: #

C++ code with manual argument parsing:

#include <iostream>
#include <string>
#include <cstdlib>

int main(int argc, char* argv[]) {
    int number_of_threads = 2; // Default

    for (int i = 1; i < argc; ++i) {
        std::string arg = argv[i];
        if (arg.substr(0, 10) == "--threads=") {
            char* endptr;
            long val = strtol(arg.substr(10).c_str(), &endptr, 10);
            if (*endptr == '\0' && val > 0) {
                number_of_threads = static_cast<int>(val);
            }
        }
    }

    std::cout << "NUMBER_OF_THREADS=" << number_of_threads << "\n";
    return 0;
}

Terminal steps:

./test --threads=4
./test --threads=10

3. Dynamic Runtime Adjustment (Temporary Files/Pipes) #

If you need to tweak settings while the app is running (not just on startup), you can have the program periodically check a temporary file or pipe for updates.

Example: #

C++ code that checks a temp file every 5 seconds:

#include <iostream>
#include <fstream>
#include <chrono>
#include <thread>
#include <cstdlib>

int read_thread_count(const std::string& path) {
    std::ifstream file(path);
    if (!file) return 2; // Default

    std::string line;
    std::getline(file, line);
    char* endptr;
    long val = strtol(line.c_str(), &endptr, 10);
    return (*endptr == '\0' && val > 0) ? static_cast<int>(val) : 2;
}

int main() {
    const std::string temp_file = "/tmp/thread_count";
    // Initialize temp file if it doesn't exist
    std::ofstream init_file(temp_file);
    init_file << "4\n";
    init_file.close();

    while (true) {
        int threads = read_thread_count(temp_file);
        std::cout << "Current thread count: " << threads << "\n";
        std::this_thread::sleep_for(std::chrono::seconds(5));
    }

    return 0;
}

Terminal steps:

# Run the app in one terminal
./test
# In another terminal, update the value
echo "10" > /tmp/thread_count
# Watch the app pick up the new value after 5 seconds

4. macOS-Specific: User Defaults (plist) #

macOS has a built-in system for storing app preferences via property lists (plists). You can use the defaults command to modify these, and your app can read them using Apple's frameworks.

Example: #

Objective-C++ code to read user defaults:

#include <iostream>
#import <Foundation/Foundation.h>

int main() {
    @autoreleasepool {
        NSUserDefaults* defaults = [NSUserDefaults standardUserDefaults];
        int number_of_threads = [defaults integerForKey:@"NumberOfThreads"];
        // Use default if not set
        if (number_of_threads == 0) number_of_threads = 2;
        std::cout << "NUMBER_OF_THREADS=" << number_of_threads << "\n";
    }
    return 0;
}

Terminal steps:

# Set the preference
defaults write com.yourcompany.test NumberOfThreads 4
# Run the app
./test
# Update the preference
defaults write com.yourcompany.test NumberOfThreads 10
./test

5. Linux-Specific: Proc Filesystem (procfs) #

For system-level apps, you can create a custom entry in /proc to expose and modify settings. This requires root privileges but offers deep integration with the system.

Example (simplified): #

C++ code to read a custom proc entry:

#include <iostream>
#include <fstream>
#include <cstdlib>

int main() {
    std::ifstream proc_file("/proc/myapp/thread_count");
    if (!proc_file) {
        std::cerr << "Failed to read proc entry\n";
        return 1;
    }

    std::string line;
    std::getline(proc_file, line);
    int number_of_threads = strtol(line.c_str(), nullptr, 10);
    std::cout << "NUMBER_OF_THREADS=" << number_of_threads << "\n";
    return 0;
}

Terminal steps (with root access):

# Create the proc entry (via a kernel module or userspace tool)
echo "4" > /proc/myapp/thread_count
# Run the app
sudo ./test
# Update the value
echo "10" > /proc/myapp/thread_count
sudo ./test

Which Should You Choose? #

• Environment variables: Best for temporary, session-specific tweaks (like your original example).
• Command-line arguments: Ideal for one-off runs where you want to pass settings directly.
• Configuration files: Great for persistent settings that you want to reuse across runs.
• Temporary files/pipes: Perfect if you need to adjust settings while the app is running.
• macOS User Defaults: Integrates with the system's preference framework for macOS apps.
• Linux procfs: For system-level tools that need kernel-level integration.

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