QThread Class

QThread クラスは、プラットフォームに依存しないスレッド管理方法を提供します。詳細...

ヘッダー	`#include <QThread>`
CMake：	`find_package(Qt6 REQUIRED COMPONENTS Core)` `target_link_libraries(mytarget PRIVATE Qt6::Core)`
qmake：	`QT += core`
継承：	QObject

継承メンバを含む全メンバのリスト
QThread はThreading Classes の一部です。

パブリック型

enum	Priority { IdlePriority, LowestPriority, LowPriority, NormalPriority, HighPriority, …, InheritPriority }

パブリック関数

	QThread(QObject *parent = nullptr)
virtual	~QThread()
QAbstractEventDispatcher *	eventDispatcher() const
`(since 6.8)` bool	isCurrentThread() const
bool	isFinished() const
bool	isInterruptionRequested() const
bool	isRunning() const
int	loopLevel() const
QThread::Priority	priority() const
void	requestInterruption()
void	setEventDispatcher(QAbstractEventDispatcher *eventDispatcher)
void	setPriority(QThread::Priority priority)
void	setStackSize(uint stackSize)
uint	stackSize() const
bool	wait(QDeadlineTimer deadline = QDeadlineTimer(QDeadlineTimer::Forever))
bool	wait(unsigned long time)

再実装パブリック関数

virtual bool event(QEvent *event) override

パブリック・スロット

void	exit(int returnCode = 0)
void	quit()
void	start(QThread::Priority priority = InheritPriority)
void	terminate()

シグナル

void	finished()
void	started()

静的パブリックメンバ

QThread *	create(Function &&f, Args &&... args)
QThread *	currentThread()
Qt::HANDLE	currentThreadId()
int	idealThreadCount()
`(since 6.8)` bool	isMainThread()
void	msleep(unsigned long msecs)
`(since 6.6)` void	sleep(std::chrono::nanoseconds nsecs)
void	sleep(unsigned long secs)
void	usleep(unsigned long usecs)
void	yieldCurrentThread()

保護された関数

int	exec()
virtual void	run()

静的プロテクトメンバ

void	setTerminationEnabled(bool enabled = true)

詳細説明

QThread オブジェクトは、プログラム内の制御の 1 つのスレッドを管理します。QThread はrun() で実行を開始します。デフォルトでは、run() は、exec() を呼び出すことでイベントループを開始し、スレッド内部でQtイベントループを実行します。

QObject::moveToThread() を使用してスレッドに移動することで、ワーカーオブジェクトを使用できます。

class Worker : public QObject
{
    Q_OBJECT

public slots:
    void doWork(const QString &parameter) {
        QString result;
        /* ... here is the expensive or blocking operation ... */
        emit resultReady(result);
    }

signals:
    void resultReady(const QString &result);
};

class Controller : public QObject
{
    Q_OBJECT
    QThread workerThread;
public:
    Controller() {
        Worker *worker = new Worker;
        worker->moveToThread(&workerThread);
        connect(&workerThread, &QThread::finished, worker, &QObject::deleteLater);
        connect(this, &Controller::operate, worker, &Worker::doWork);
        connect(worker, &Worker::resultReady, this, &Controller::handleResults);
        workerThread.start();
    }
    ~Controller() {
        workerThread.quit();
        workerThread.wait();
    }
public slots:
    void handleResults(const QString &);
signals:
    void operate(const QString &);
};

ワーカースロット内のコードは、別のスレッドで実行されます。しかし、Workerのスロットは、どのスレッドでも、どのオブジェクトからでも、どのシグナルに接続してもかまいません。queued connections と呼ばれるメカニズムのおかげで、異なるスレッド間でシグナルとスロットを安全に接続できます。

別のスレッドでコードを実行させるもう1つの方法は、QThreadをサブクラス化し、run （）を再実装することです。例えば

class WorkerThread : public QThread
{
    Q_OBJECT
    void run() override {
        QString result;
        /* ... here is the expensive or blocking operation ... */
        emit resultReady(result);
    }
signals:
    void resultReady(const QString &s);
};

void MyObject::startWorkInAThread()
{
    WorkerThread *workerThread = new WorkerThread(this);
    connect(workerThread, &WorkerThread::resultReady, this, &MyObject::handleResults);
    connect(workerThread, &WorkerThread::finished, workerThread, &QObject::deleteLater);
    workerThread->start();
}

この例では、スレッドはrun関数が戻った後に終了します。exec() を呼び出さない限り、スレッド内でイベント・ループが実行されることはありません。

QThreadインスタンスは、run （）を呼び出す新しいスレッドではなく、それをインスタンス化した古いスレッドlives in 。これは、QThreadのキューイングされたスロットとinvoked methods のすべてが古いスレッドで実行されることを意味します。したがって、新しいスレッドでスロットを呼び出したい開発者は、ワーカーオブジェクトアプローチを使用する必要があります。

キューに入れられたスロットや呼び出されたメソッドとは異なり、QThread オブジェクト上で直接呼び出されたメソッドは、そのメソッドを呼び出したスレッドで実行されます。QThread をサブクラス化する場合、コンストラクタは古いスレッドで実行され、run() は新しいスレッドで実行されることに注意してください。メンバ変数が両方の関数からアクセスされる場合、その変数は2つの異なるスレッドからアクセスされることになります。そうすることが安全であることを確認してください。

注意： 異なるスレッド間でオブジェクトを操作する場合は注意が必要です。一般的なルールとして、関数は QThread オブジェクトを作成したスレッドからのみ呼び出すことができます（例：setPriority()）。詳細はスレッドの同期を参照してください。

スレッドの管理

QThread はスレッドがstarted() やfinished() になるとシグナルで通知します。また、isFinished() やisRunning() を使ってスレッドの状態を問い合わせることもできます。

スレッドを停止するには、exit() またはquit() を呼び出す。極端な場合、実行中のスレッドを強制的にterminate() したくなることもある。しかし、これは危険であり、お勧めできません。詳細については、terminate() およびsetTerminationEnabled() のドキュメントをお読みください。

スレッドが終了したときに、そのスレッドに存在するオブジェクトの割り当てを解除したい場合がよくあります。これを行うには、finished() シグナルをQObject::deleteLater() に接続します。

他のスレッドの実行が終了するまで（または指定した時間が経過するまで）、wait （）を使用して呼び出し元のスレッドをブロックします。

QThreadは、静的でプラットフォームに依存しないスリープ関数も提供しています。sleep()、msleep()、usleep()では、それぞれフル秒、ミリ秒、マイクロ秒の分解能を実現しています。

注： wait （）とsleep （）関数は、Qtはイベント駆動型のフレームワークなので、一般的には不要です。wait() の代わりに、finished() シグナルをリッスンしてください。sleep() 関数の代わりに、QChronoTimer を使うことを検討してください。

静的関数currentThreadId() とcurrentThread() は、現在実行中のスレッドの識別子を返します。前者はスレッドのプラットフォーム固有の ID を返し、後者は QThread ポインタを返します。

スレッドに付けられる名前（たとえば Linux ではps -L というコマンドで識別される）を選択するには、スレッドを開始する前にsetObjectName() を呼び出します。setObjectName()を呼び出さない場合、スレッドに与えられる名前は、スレッド・オブジェクトのランタイム・タイプのクラス名になります（例えば、マンデルブロの例の場合、"RenderThread" 、これはQThreadのサブクラスの名前です）。これは現在Windowsのリリースビルドでは利用できないことに注意してください。

Qtのスレッドサポート、QThreadStorage 、スレッドの同期、マンデルブロ、セマフォを使用したProducerとConsumer、待機条件を使用したProducerとConsumerも参照してください 。

メンバ型のドキュメント

enum QThread::Priority

この列挙型は、オペレーティング・システムが新しく作成されたスレッドをどのようにスケジューリングすべきかを示す。

定数	値	説明
`QThread::IdlePriority`	`0`	他のスレッドが実行されていない時にのみスケジューリングされる。
`QThread::LowestPriority`	`1`	LowPriority よりも少ない頻度でスケジューリングされる。
`QThread::LowPriority`	`2`	NormalPriority よりも低い頻度でスケジューリングされる。
`QThread::NormalPriority`	`3`	オペレーティング・システムのデフォルトの優先度。
`QThread::HighPriority`	`4`	NormalPriorityよりも頻繁にスケジュールされる。
`QThread::HighestPriority`	`5`	HighPriorityよりも頻繁にスケジュールされる。
`QThread::TimeCriticalPriority`	`6`	できるだけ頻繁にスケジュールされる。
`QThread::InheritPriority`	`7`	作成スレッドと同じ優先度を使用する。これがデフォルトである。

メンバ関数ドキュメント

`[explicit]` QThread::QThread(QObject **parent* = nullptr)

新しいスレッドを管理するために新しい QThread を構築します。parent が QThread の所有権を持つ。スレッドは、start() が呼び出されるまで実行を開始しません。

start()も参照してください 。

`[virtual noexcept]` QThread::~QThread()

QThread を破棄する。

QThread オブジェクトを削除しても、それが管理するスレッドの実行は停止しないことに注意。実行中のQThread を削除する（すなわち、isFinished() がfalse を返す）と、プログラムがクラッシュする。QThread を削除する前に、finished() シグナルを待ってください。

Qt 6.3 以降では、対応するスレッドがまだ実行中であっても、QThread::create() の呼び出しによって作成されたQThread インスタンスを削除することができます。このような場合、Qtはスレッドに割り込み要求を出し（requestInterruption()）、スレッドのイベントループ（もしあれば）に終了を求め（quit()）、スレッドが終了するまでブロックします。

create()、isInterruptionRequested()、exec()、quit()も参照してください 。

`[static]` template <typename Function, typename... Args> QThread QThread::create(Function &&f, Args &&... args*)

引数args で関数f を実行する新しいQThread オブジェクトを作成する。

新しいスレッドは開始されません。start() を明示的に呼び出して開始する必要があります。これにより、スレッドのシグナルに接続したり、QObject をスレッドに移動したり、新しいスレッドの優先順位を選択したりすることができます。関数f は新しいスレッドで呼び出されます。

新しく作成されたQThread インスタンスを返します。

注意： 呼び出し元は、返されたQThread インスタンスの所有権を取得します。

警告： 返されたQThread インスタンスに対して、start() を複数回呼び出さないでください。そうすると、未定義の動作になります。

start()も参照 。

`[static]` QThread *QThread::currentThread()

現在実行中のスレッドを管理するQThread へのポインタを返します。

`[static noexcept]` Qt::HANDLE QThread::currentThreadId()

現在実行中のスレッドのスレッドハンドルを返します。

警告この関数によって返されるハンドルは内部目的で使用されるため、アプリケーション・コードでは使用しないでください。

注意：Windowsでは、この関数はWin32関数GetCurrentThread()によって返される擬似HANDLE（Windows-Thread HANDLE）ではなく、Win32関数GetCurrentThreadId()によって返されるDWORD（Windows-Thread ID）を返す。

`[override virtual]` bool QThread::event(QEvent **event*)

再インプリメント：QObject::event(QEvent *e).

QAbstractEventDispatcher *QThread::eventDispatcher() const

スレッドのイベントディスパッチャオブジェクトへのポインタを返す。スレッドにイベントディスパッチャが存在しない場合、この関数はnullptr を返す。

setEventDispatcher()も参照のこと 。

`[protected]` int QThread::exec()

イベントループに入り、exit （）が呼び出されるまで待機し、exit （）に渡された値を返す。quit() 経由でexit() が呼び出された場合、返される値は 0 である。

この関数は、run （）内から呼び出すことを想定している。イベント処理を開始するには、この関数を呼び出す必要があります。

注意： この関数を呼び出せるのは、スレッド自体の中だけです。

quit() およびexit()も参照のこと 。

`[slot]` void QThread::exit(int returnCode = 0)

スレッドのイベント・ループに、リターン・コードで終了するように指示する。

この関数を呼び出すと、スレッドはイベント・ループから離れ、QEventLoop::exec() の呼び出しから戻る。QEventLoop::exec() 関数はreturnCode を返す。

慣例により、returnCode の0は成功を意味し、0以外の値はエラーを示す。

同名の C ライブラリ関数とは異なり、この関数は呼び出し元に戻ることに注意してください。

このスレッドでは、QThread::exec （）が再度呼び出されるまで、QEventLoopはもう開始されない。QThread::exec() のイベントループが実行されていない場合、QThread::exec() の次の呼び出しも即座に戻ります。

注意：この関数はスレッドセーフである。

quit() およびQEventLoopも参照のこと。

`[private signal]` void QThread::finished()

このシグナルは、関連スレッドが実行を終了する直前に発せられる。

このシグナルが発せられたとき、イベントループの実行はすでに停止している。遅延された削除イベントを除いて、そのスレッドではもうイベントは処理されません。このシグナルをQObject::deleteLater() に接続することで、そのスレッド内のオブジェクトを解放することができます。

注意： 関連するスレッドがterminate() を使用して終了された場合、このシグナルがどのスレッドから発せられるかは未定義である。

注意： これはプライベート・シグナルである。シグナル接続で使用することはできますが、ユーザーが発することはできません。

started()も参照のこと 。

`[static noexcept]` int QThread::idealThreadCount()

このプロセスが並列に実行できる理想的なスレッド数を返します。これは、このプロセスが使用可能な論理プロセッサ数（この OS でサポートされている場合）、またはシステム内の論理プロセッサの総数を問い合わせることで行われる。どちらの値も決定できなかった場合、この関数は 1 を返す。

注意 : 全ての論理プロセッサのサブセットへのスレッドのアフィニティ設定をサポートするオペレーティングシステムでは、この関数が返す値はスレッド間や時間の経過とともに変化する可能性があります。

注意：CPUのホットプラグとホットアンプラグをサポートするオペレーティングシステムでは、この関数が返す値も時間の経過とともに変化する可能性があります（CPUは、物理的なハードウェアの変更なしに、ソフトウェアによってオン/オフできることに注意してください）。

`[noexcept, since 6.8]` bool QThread::isCurrentThread() const

このスレッドがQThread::currentThread である場合に true を返します。

この関数は Qt 6.8 で導入されました。

currentThreadId()も参照してください 。

bool QThread::isFinished() const

スレッドが終了した場合はtrue を返し、そうでない場合はfalse を返す。

注意：この関数はスレッドセーフである。

isRunning()も参照のこと 。

bool QThread::isInterruptionRequested() const

このスレッドで実行中のタスクを停止させる必要がある場合はtrueを返す。割り込みはrequestInterruption() で要求できる。

この関数を使用すると、長時間実行中のタスクをきれいに割り込み可能にすることができる。この関数が返す値をチェックしたり操作したりすることはありません。オーバーヘッドを低く保つために、あまり頻繁に呼び出さないように注意してください。

void long_task() {
     forever {
        if ( QThread::currentThread()->isInterruptionRequested() ) {
            return;
        }
    }
}

注意： この関数は、スレッド自身の中、つまりカレント・スレッドであるときにのみ呼び出すことができます。

currentThread() およびrequestInterruption()も参照の こと。

`[static noexcept, since 6.8]` bool QThread::isMainThread()

現在実行中のスレッドがメイン・スレッドであるかどうかを返す。

メイン・スレッドとは、QCoreApplication が作成されたスレッドのことである。これは通常、main() 関数を呼び出したスレッドですが、必ずしもそうではありません。GUIイベントを処理しているスレッドであり、グラフィカル・オブジェクト (QWindow,QWidget) を作成できるスレッドです。

この関数はQt 6.8で導入されました。

currentThread() とQCoreApplication::instance()も参照して ください。

bool QThread::isRunning() const

スレッドが実行中であればtrue を返し、そうでなければfalse を返す。

注意：この関数はスレッドセーフである。

isFinished()も参照のこと 。

int QThread::loopLevel() const

スレッドの現在のイベント・ループ・レベルを返します。

注意： これはスレッド自体の中、つまり現在のスレッドの中でのみ呼び出すことができます。

`[static]` void QThread::msleep(unsigned long msecs)

これはオーバーロードされた関数であり、callと同等である：

QThread::sleep(std::chrono::milliseconds{msecs});

注意： この関数は精度を保証するものではない。高負荷状態では、アプリケーションはmsecs よりも長くスリープする可能性があります。OSによっては、msecs を10msまたは15msに切り上げることがある。

sleep() およびusleep()も参照の こと。

QThread::Priority QThread::priority() const

実行中のスレッドの優先度を返す。スレッドが実行中でない場合、この関数はInheritPriority を返す。

Priority 、setPriority()、start()も参照のこと 。

`[slot]` void QThread::quit()

スレッドのイベントループに、リターンコード0（成功）で終了するように指示する。QThread::exit(0)を呼び出すのと同じです。

スレッドがイベントループを持っていない場合、この関数は何もしない。

注意：この関数はスレッドセーフです。

exit() およびQEventLoopも参照のこと。

void QThread::requestInterruption()

スレッドの中断を要求する。この要求は勧告的なものであり、スレッド上で実行されているコード次第で、そのような要求に対してどのように対処すべきかを決めることができる。この関数は、スレッド上で実行されているイベント・ループを停止させたり、スレッドを終了させたりはしない。

注意：この関数はスレッドセーフです。

isInterruptionRequested()も参照のこと 。

`[virtual protected]` void QThread::run()

スレッドの開始点。start() を呼び出した後、新しく生成されたスレッドはこの関数を呼び出す。デフォルトの実装では、単にexec() を呼び出します。

高度なスレッド管理を容易にするために、この関数を再実装できます。このメソッドからリターンすると、スレッドの実行が終了します。

start() およびwait()も参照してください 。

void QThread::setEventDispatcher(QAbstractEventDispatcher **eventDispatcher*)

スレッドのイベント・ディスパッチャをeventDispatcher に設定する。これは、スレッドにまだイベント・ディスパッチャがインストールされていない場合にのみ可能である。

イベント・ディスパッチャは、メイン・スレッドではQCoreApplication がインスタンス化されたときに、補助スレッドではstart() のときに、自動的に作成される。

このメソッドはオブジェクトのオーナーシップを取ります。

eventDispatcher()も参照のこと 。

void QThread::setPriority(QThread::Priority priority)

この関数は、実行中のスレッドに対してpriority を設定する。スレッドが実行中でない場合、この関数は何もせず、すぐに戻ります。特定の優先度でスレッドを開始するには、start （）を使用する。

引数priority には、InheritPriority を除くQThread::Priority 列挙型の任意の値を指定できる。

priority パラメータの効果は、オペレーティング・システムのスケジューリング・ポリシーに依存する。特に、スレッド優先度をサポートしていないシステム（Linuxなど、詳しくは http://linux.die.net/man/2/sched_setscheduler を参照）では、priority は無視される。

Priority 、priority()、start()も参照の こと。

void QThread::setStackSize(uint stackSize)

スレッドのスタックサイズをstackSize に設定する。stackSize がゼロの場合、オペレーティングシステムまたはランタイムはデフォルト値を選択する。そうでない場合、スレッドのスタックサイズは指定された値になる（切り上げまたは切り下げが可能）。

ほとんどのオペレーティングシステムでは、スタックに割り当てられるメモリの量は、最初はstackSize より小さく、スレッドがスタックを使用するにつれて大きくなる。このパラメータは、スタックの最大サイズを設定する（つまり、スタックが占有することを許される仮想メモリ空間のサイズを設定する）。

この関数は、スレッドが開始される前にのみ呼び出すことができる。

警告ほとんどのオペレーティング・システムでは、スレッドのスタック・サイズに最小と最大の制限を設けています。スタック・サイズがこれらの制限を外れると、スレッドは起動に失敗する。

stackSize()も参照のこと 。

`[static protected]` void QThread::setTerminationEnabled(bool enabled = true)

enabled パラメータに基づいて、現在のスレッドの終了を有効または無効にする。スレッドはQThread によって開始されていなければならない。

enabled が false の場合、終了は無効となる。今後QThread::terminate() を呼び出すと、終了は実行されずに即座に返される。代わりに、終了が有効になるまで、終了は延期される。

enabled がtrueの場合、終了が有効になる。今後QThread::terminate() を呼び出すと、スレッドは正常に終了する。終了が延期された場合（つまり、終了が無効な状態でQThread::terminate() が呼び出された場合）、この関数は呼び出し元のスレッドを直ちに終了する。この場合、この関数は戻らないことに注意。

terminate()も参照 。

`[static, since 6.6]` void QThread::sleep(std::chrono::nanoseconds nsecs)

nsecs の間、現在のスレッドを強制的にスリープさせる。

与えられた条件が変化するのを待つ必要がある場合は、この関数の使用は避けてください。代わりに、変化を示すシグナルにスロットを接続するか、イベント・ハンドラ（QObject::event() を参照）を使用する。

注意： この関数は正確さを保証するものではありません。負荷が高い状況では、アプリケーションはnsecs よりも長くスリープする可能性があります。

この関数は Qt 6.6 で導入されました。

`[static]` void QThread::sleep(unsigned long secs)

現在のスレッドを強制的にsecs 秒間スリープさせる。

これはオーバーロードされた関数であり、callと同等である：

QThread::sleep(std::chrono::seconds{secs});

msleep() およびusleep()も参照のこと 。

uint QThread::stackSize() const

スレッドの最大スタックサイズを返す（setStackSize() で設定されている場合）。

setStackSize()も参照 。

`[slot]` void QThread::start(QThread::Priority priority = InheritPriority)

run() をコールしてスレッドの実行を開始する。オペレーティング・システムは、priority パラメータに従ってスレッドをスケジューリングする。スレッドがすでに実行されている場合、この関数は何もしない。

priority パラメータの効果は、オペレーティング・システムのスケジューリング・ポリシーに依存する。特に、スレッドの優先順位をサポートしていないシステム（Linuxなど）では、priority は無視される（詳細はsched_setschedulerのドキュメントを参照）。

run() およびterminate()も参照の こと。

`[private signal]` void QThread::started()

このシグナルは、関連するスレッドが実行を開始するときに発せられるので、それに接続されているスロットは、キューに入れられた呼び出しによって呼び出される可能性があります。run() が呼び出される前にイベントはポストされているかもしれませんが、クロススレッドでのシグナルの配信はまだ保留中かもしれません。

注意： これはプライベート・シグナルです。シグナル接続で使用することはできますが、ユーザが発行することはできません。

run() およびfinished()も参照のこと 。

`[slot]` void QThread::terminate()

スレッドの実行を終了する。スレッドは、オペレーティング・システムのスケジューリング・ポリシーによって、即座に終了する場合としない場合があります。念のため、terminate() の後にQThread::wait() を使用してください。

スレッドが終了すると、そのスレッドの終了を待っていたすべてのスレッドが起動します。

警告： この関数は危険であるため、使用は推奨されない。スレッドはコード・パスのどの時点でも終了させることができる。スレッドは、データの変更中に終了させることができる。スレッドが自分自身の後始末をしたり、保持されているミューテックスのロックを解除したりする機会はない。要するに、この関数は絶対に必要な場合にのみ使用すること。

終了は、QThread::setTerminationEnabled （）を呼び出すことで、明示的に有効にも無効にもできる。終了が無効になっているときにこの関数を呼び出すと、終了は延期され、終了が再度有効になるまで延期される。詳細については、QThread::setTerminationEnabled() のドキュメントを参照すること。

注意：この関数はスレッド・セーフである。

setTerminationEnabled()も参照 。

`[static]` void QThread::usleep(unsigned long usecs)

これはオーバーロードされた関数であり、callと同等である：

QThread::sleep(std::chrono::microseconds{secs});

注意： この関数は精度を保証するものではない。高負荷状態では、アプリケーションはusecs より長くスリープする可能性があります。OSによっては、usecs を10msまたは15msに切り上げる場合がある。Windowsでは、1msの倍数に切り上げられる。

sleep() およびmsleep()も参照の こと。

bool QThread::wait(QDeadlineTimer deadline = QDeadlineTimer(QDeadlineTimer::Forever))

これらの条件のいずれかが満たされるまで、スレッドをブロックする：

このQThread オブジェクトに関連付けられたスレッドが実行を終了したとき（すなわち、run() から戻ったとき）。スレッドが終了した場合、この関数は真を返します。スレッドがまだ開始されていない場合も真を返す。
deadline に達した。この関数は、期限に達した場合に false を返します。

QDeadlineTimer::Forever （デフォルト）に設定されたデッドライン・タイマーがタイムアウトすることはありません。この場合、この関数は、スレッドがrun （）から戻るか、スレッドがまだ開始されていない場合にのみ戻ります。

これはPOSIXのpthread_join() 関数と同様の機能を提供する。

sleep() およびterminate()も参照のこと 。

bool QThread::wait(unsigned long time)

これはオーバーロードされた関数である。

time はミリ秒単位の待ち時間である。がULONG_MAXの場合、待ち時間がタイムアウトすることはない。time

`[static]` void QThread::yieldCurrentThread()

実行可能なスレッドがあれば、現在のスレッドの実行を他のスレッドに移す。どのスレッドに切り替えるかはオペレーティング・システムが決定することに注意。

© 2025 The Qt Company Ltd. Documentation contributions included herein are the copyrights of their respective owners. The documentation provided herein is licensed under the terms of the GNU Free Documentation License version 1.3 as published by the Free Software Foundation. Qt and respective logos are trademarks of The Qt Company Ltd. in Finland and/or other countries worldwide. All other trademarks are property of their respective owners.

QThread Class

パブリック型

パブリック関数

再実装パブリック関数

パブリック・スロット

シグナル

静的パブリックメンバ

保護された関数

静的プロテクトメンバ

詳細説明

スレッドの管理

メンバ型のドキュメント

enum QThread::Priority

メンバ関数ドキュメント

[explicit] QThread::QThread(QObject *parent = nullptr)

[virtual noexcept] QThread::~QThread()

[static] template <typename Function, typename... Args> QThread *QThread::create(Function &&f, Args &&... args)

[static] QThread *QThread::currentThread()

[static noexcept] Qt::HANDLE QThread::currentThreadId()

[override virtual] bool QThread::event(QEvent *event)

QAbstractEventDispatcher *QThread::eventDispatcher() const

[protected] int QThread::exec()

[slot] void QThread::exit(int returnCode = 0)

[private signal] void QThread::finished()

[static noexcept] int QThread::idealThreadCount()

[noexcept, since 6.8] bool QThread::isCurrentThread() const

bool QThread::isFinished() const

bool QThread::isInterruptionRequested() const

[static noexcept, since 6.8] bool QThread::isMainThread()

bool QThread::isRunning() const

int QThread::loopLevel() const

[static] void QThread::msleep(unsigned long msecs)

QThread::Priority QThread::priority() const

[slot] void QThread::quit()

void QThread::requestInterruption()

[virtual protected] void QThread::run()

void QThread::setEventDispatcher(QAbstractEventDispatcher *eventDispatcher)

void QThread::setPriority(QThread::Priority priority)

void QThread::setStackSize(uint stackSize)

[static protected] void QThread::setTerminationEnabled(bool enabled = true)

[static, since 6.6] void QThread::sleep(std::chrono::nanoseconds nsecs)

[static] void QThread::sleep(unsigned long secs)

uint QThread::stackSize() const

[slot] void QThread::start(QThread::Priority priority = InheritPriority)

[private signal] void QThread::started()

[slot] void QThread::terminate()

[static] void QThread::usleep(unsigned long usecs)

bool QThread::wait(QDeadlineTimer deadline = QDeadlineTimer(QDeadlineTimer::Forever))

bool QThread::wait(unsigned long time)

[static] void QThread::yieldCurrentThread()

`[explicit]` QThread::QThread(QObject **parent* = nullptr)

`[virtual noexcept]` QThread::~QThread()

`[static]` template <typename Function, typename... Args> QThread QThread::create(Function &&f, Args &&... args*)

`[static]` QThread *QThread::currentThread()

`[static noexcept]` Qt::HANDLE QThread::currentThreadId()

`[override virtual]` bool QThread::event(QEvent **event*)

`[protected]` int QThread::exec()

`[slot]` void QThread::exit(int returnCode = 0)

`[private signal]` void QThread::finished()

`[static noexcept]` int QThread::idealThreadCount()

`[noexcept, since 6.8]` bool QThread::isCurrentThread() const

`[static noexcept, since 6.8]` bool QThread::isMainThread()

`[static]` void QThread::msleep(unsigned long msecs)

`[slot]` void QThread::quit()

`[virtual protected]` void QThread::run()

void QThread::setEventDispatcher(QAbstractEventDispatcher **eventDispatcher*)

`[static protected]` void QThread::setTerminationEnabled(bool enabled = true)

`[static, since 6.6]` void QThread::sleep(std::chrono::nanoseconds nsecs)

`[static]` void QThread::sleep(unsigned long secs)

`[slot]` void QThread::start(QThread::Priority priority = InheritPriority)

`[private signal]` void QThread::started()

`[slot]` void QThread::terminate()

`[static]` void QThread::usleep(unsigned long usecs)

`[static]` void QThread::yieldCurrentThread()