Parallel Computation

#include <iostream>
#include <vector>
#include <boost/thread.hpp>
#include <boost/chrono.hpp>
#include <boost/atomic.hpp>

// Shared flag to signal when to stop background threads
boost::atomic<bool> running(true);
boost::mutex coutMutex;  // Synchronizes console output

// Simulated background task
void backgroundTask(int id) {
    int count = 0;
    while (running) {
        {
            boost::lock_guard<boost::mutex> lock(coutMutex);
            std::cout << count << ": Background Task " << id << " is running...\n";
        }
        boost::this_thread::sleep_for(boost::chrono::seconds(1));  // Simulate work
        ++count;
    }

    // Final message when thread exits
    boost::lock_guard<boost::mutex> lock(coutMutex);
    std::cout << "Background Task " << id << " exiting...\n";
}

// Main foreground task
void foregroundTask() {
    std::string input;
    while (running) {
        {
            boost::lock_guard<boost::mutex> lock(coutMutex);
            std::cout << "Foreground: Type 'x' then <return> to exit.\n\n";
        }
        std::cin >> input;

        if (input == "x") {
            std::cout << "\nForeground task exiting...\n\n";
            running = false;
        }
    }
}

// Entry point
int main() {
    const int numThreads = 3;  // Number of background threads
    std::vector<boost::thread> workers;

    // Start background threads
    for (int i = 0; i < numThreads; ++i) {
        workers.emplace_back(backgroundTask, i + 1);
    }

    // Start foreground task (user interaction)
    foregroundTask();

    // Wait for all background threads to finish
    for (auto& thread : workers) {
        thread.join();
    }

    std::cout << "All threads exited. Program shutting down.\n";
    return 0;
}

Foreground: Type 'x' then <return> to exit.

0: Background Task 3 is running...
0: Background Task 2 is running...
0: Background Task 1 is running...
1: Background Task 1 is running...
1: Background Task 3 is running...
1: Background Task 2 is running...
x

Foreground task exiting...

Background Task 2 exiting...
Background Task 1 exiting...
Background Task 3 exiting...
All threads exited. Program shutting down.

#include <iostream>
#include <boost/asio.hpp>
#include <boost/thread.hpp>
#include <boost/atomic.hpp>
#include <boost/chrono.hpp>

boost::atomic<bool> running(true);  // Atomic flag to signal threads to stop
boost::atomic<int> taskCounter(0);  // Tracks running tasks
boost::mutex coutMutex;             // Synchronizes console output

const int max_tasks = 4;

// Simulated background task
void backgroundTask(int id) {
    taskCounter++;  // Increment task count
    int count = 0;
    while (running) {
        {
            boost::lock_guard<boost::mutex> lock(coutMutex);
            std::cout << count++ << ") Task " << id << " is running... (Active tasks: "
                << taskCounter.load() << ")\n";
        }
        boost::this_thread::sleep_for(boost::chrono::seconds(1));  // Simulate work
    }

    taskCounter--;  // Decrement task count
    boost::lock_guard<boost::mutex> lock(coutMutex);
    std::cout << "Task " << id << " exiting...\n";
}

// Foreground task handling user input
void foregroundTask(boost::asio::thread_pool& pool) {
    std::string input;
    while (running) {
        {
            boost::lock_guard<boost::mutex> lock(coutMutex);
            std::cout << "Foreground: Type 'x' <return> to exit, 'a' <return> to add a task.\n";
        }
        std::cin >> input;

        if (input == "x") {
            running = false;
        }
        else if (input == "a" && taskCounter < max_tasks) {
            static boost::atomic<int> taskId(0);
            boost::asio::post(pool, [id = ++taskId] { backgroundTask(id); });
        }
    }
}

// Main function
int main() {
    boost::asio::thread_pool pool(max_tasks);  // Thread pool with max_tasks worker threads

    // Start foreground task
    foregroundTask(pool);

    // Wait for all tasks in the pool to complete
    pool.join();

    std::cout << "\nAll tasks completed. Program shutting down.\n";
    return 0;
}

...
10) Task 1 is running... (Active tasks: 2)
a

Foreground: Type 'x' <return> to exit, 'a' <return> to add a task.
0) Task 3 is running... (Active tasks: 3)
5) Task 2 is running... (Active tasks: 3)
11) Task 1 is running... (Active tasks: 3)
6) Task 2 is running... (Active tasks: 3)
1) Task 3 is running... (Active tasks: 3)
12) Task 1 is running... (Active tasks: 3)

x
Task 1 exiting...
Task 3 exiting...
Task 2 exiting...

#include <boost/fiber/all.hpp>
#include <iostream>
#include <queue>
#include <string>
#include <atomic>

class MessageQueue {
public:
    void send(const std::string& msg) {
        std::unique_lock<boost::fibers::mutex> lock(mutex_);
        queue_.push(msg);
        cond_.notify_one();
    }

    std::string receive(std::string to) {
        std::unique_lock<boost::fibers::mutex> lock(mutex_);
        cond_.wait(lock, [this]() { return !queue_.empty(); });
        std::string msg = queue_.front();
        if (msg[0] == to[0] || to[0] == 'x' || msg == "/quit")
        {
            queue_.pop();
            return msg;
        }
        else
            return "";
    }

private:
    std::queue<std::string> queue_;
    boost::fibers::mutex mutex_;
    boost::fibers::condition_variable cond_;
};

int main() {
    MessageQueue msg_queue;
    std::atomic<bool> running(true);
    const int num_receivers = 3;
    std::string to;

    // Launch multiple receiver fibers
    std::vector<boost::fibers::fiber> receivers;
    for (int i = 0; i < num_receivers; ++i) {
        receivers.emplace_back([&, id = i + 1]() {
            while (running) {
                switch (id)
                {
                case 1: to = "1";
                    break;
                case 2: to = "2";
                    break;
                case 3: to = "x";
                    break;
                }
                std::string msg = msg_queue.receive(to);

                if (msg == "/quit") {
                    running = false;
                    msg_queue.send("/quit"); // Ensure all receivers get the quit signal
                    break;
                }
                if (msg != "")
                    std::cout << "[Receiver " << id << "] Received: " << msg << std::endl;
                boost::this_fiber::yield(); // Yield to allow fair scheduling
            }
            });
    }

    // Main thread handles user input
    std::string input;
    while (running) {
        std::cout << "Enter a message starting with the receiver Id (1,2,3) or /quit to exit > ";
        std::getline(std::cin, input);

        if (!input.empty()) {
            msg_queue.send(input);
            if (input == "/quit") {
                break;
            }
            boost::this_fiber::yield();
        }
    }

    // Join all receiver fibers
    for (auto& f : receivers) {
        f.join();
    }

    std::cout << "All receivers exited. Program shutting down.\n";
    return 0;
}

Enter a message starting with the receiver Id (1,2,3) or /quit to exit > 1 hello
[Receiver 1] Received: 1 hello
Enter a message starting with the receiver Id (1,2,3) or /quit to exit > 2 hi
[Receiver 2] Received: 2 hi
Enter a message starting with the receiver Id (1,2,3) or /quit to exit > 3 howdy
[Receiver 3] Received: 3 howdy
Enter a message starting with the receiver Id (1,2,3) or /quit to exit > 4 anyone
[Receiver 3] Received: 4 anyone
Enter a message starting with the receiver Id (1,2,3) or /quit to exit > /quit
All receivers exited. Program shutting down.