Threads.h

Go to the documentation of this file.

/*
 * Copyright (C) 2004-2024 ZNC, see the NOTICE file for details.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#ifndef ZNC_THREADS_H
#define ZNC_THREADS_H

#include <znc/zncconfig.h>

#ifdef HAVE_PTHREAD

#include <znc/Utils.h>

#include <cerrno>
#include <csignal>
#include <cstdlib>
#include <cstring>
#include <list>
#include <pthread.h>
#include <mutex>
#include <condition_variable>

using CMutex = std::mutex;

using CMutexLocker = std::unique_lock<std::mutex>;

using CConditionVariable = std::condition_variable_any;

class CJob {
  public:
    friend class CThreadPool;

    enum EJobState { READY, RUNNING, DONE, CANCELLED };

    CJob() : m_eState(READY) {}

    virtual ~CJob() {}

    virtual void runThread() = 0;

    virtual void runMain() = 0;

    bool wasCancelled() const;

  private:
    // Undefined copy constructor and assignment operator
    CJob(const CJob&);
    CJob& operator=(const CJob&);

    // Synchronized via the thread pool's mutex! Do not access without that
    // mutex!
    EJobState m_eState;
};

class CThreadPool {
  private:
    friend class CJob;

    CThreadPool();
    ~CThreadPool();

  public:
    static CThreadPool& Get();

    void addJob(CJob* job);

    void cancelJob(CJob* job);

    void cancelJobs(const std::set<CJob*>& jobs);

    int getReadFD() const { return m_iJobPipe[0]; }

    void handlePipeReadable() const;

  private:
    void jobDone(CJob* pJob);

    // Check if the calling thread is still needed, must be called with m_mutex
    // held
    bool threadNeeded() const;

    CJob* getJobFromPipe() const;
    void finishJob(CJob*) const;

    void threadFunc();

    // mutex protecting all of these members
    CMutex m_mutex;

    // condition variable for waiting idle threads
    CConditionVariable m_cond;

    // condition variable for reporting finished cancellation
    CConditionVariable m_cancellationCond;

    // condition variable for waiting running threads == 0
    CConditionVariable m_exit_cond;

    // when this is true, all threads should exit
    bool m_done;

    // total number of running threads
    size_t m_num_threads;

    // number of idle threads waiting on the condition variable
    size_t m_num_idle;

    // pipe for waking up the main thread
    int m_iJobPipe[2];

    // list of pending jobs
    std::list<CJob*> m_jobs;
};

#endif  // HAVE_PTHREAD
#endif  // !ZNC_THREADS_H