Threads.h

Go to the documentation of this file.

/*
 * Copyright (C) 2004-2025 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