Aktives Objekt

Ein aktives Objekt enthält einen (oder auch mehrere) Threads.
Man kann es mit start() starten und mit stop() stoppen. Um Anregungen zu erhalten, wie man es programmiert, habe ich Chat CPT gefragt. Folgendes Programm ist dabei herausgekommen:

#include <iostream>
#include <thread>
#include <mutex>
#include <condition_variable>

class ThreadOwner {
public:
  ThreadOwner() : running_(false) {}

  ~ThreadOwner() {
    stop();
  }

  void start() {
    if (!running_) {
      running_ = true;
      thread_ = std::thread(&ThreadOwner::threadFunction, this);
    }
  }

  void stop() {
    if (running_) {
      running_ = false;
      cv_.notify_one();
      if (thread_.joinable()) {
        thread_.join();
      }
    }
  }

  bool isRunning() const {
    return running_;
  }

private:
  void threadFunction() {
    while (running_) {
      // Do some work in the thread
      std::unique_lock<std::mutex> lock(mutex_);
      cv_.wait_for(lock, std::chrono::milliseconds(1000));
      std::cout << "Thread is running\n";
    }
  }

private:
  std::thread thread_;
  bool running_;
  std::mutex mutex_;
  std::condition_variable cv_;
};

int main()
{
  ThreadOwner owner;
  owner.start();
  // Do some work in the main thread
  std::cout << "Main thread is running\n";
  std::this_thread::sleep_for(std::chrono::seconds(5));
  owner.stop();
  return 0;
}

Übersetzt wird dieses Programm mit

 g++ -o activeobject -g activeobject.cpp