CAMThread-Klasse

[Das dieser Seite zugeordnete Feature DirectShow ist ein Legacyfeature. Es wurde von MediaPlayer, IMFMediaEngine und Audio/Video Capture in Media Foundation abgelöst. Diese Features wurden für Windows 10 und Windows 11 optimiert. Microsoft empfiehlt dringend, dass neuer Code mediaPlayer, IMFMediaEngine und Audio/Video Capture in Media Foundation anstelle von DirectShow verwendet, wenn möglich. Microsoft schlägt vor, dass vorhandener Code, der die Legacy-APIs verwendet, so umgeschrieben wird, dass nach Möglichkeit die neuen APIs verwendet werden.]

Die CAMThread -Klasse ist eine abstrakte Klasse zum Verwalten von Arbeitsthreads.

Geschützte Membervariablen	BESCHREIBUNG
m_hThread	Handle für den Thread.
Öffentliche Membervariablen	BESCHREIBUNG
m_AccessLock	Kritischer Abschnitt, der den Zugriff auf den Thread durch andere Threads verhindert.
m_WorkerLock	Kritischer Abschnitt, in dem Daten gesperrt werden, die für Threads freigegeben werden.
Öffentliche Methoden	BESCHREIBUNG
CAMThread	Konstruktormethode.
~ CAMThread	Destruktormethode. Virtuellen.
InitialThreadProc	Ruft die ThreadProc-Methode auf, wenn der Thread erstellt wird.
Erstellen	Erstellt den Thread.
CallWorker	Signalisiert den Thread mit einer Anforderung.
Schließen	Wartet, bis der Thread beendet wird, und gibt dann seine Ressourcen frei.
ThreadExists	Fragt ab, ob der Thread vorhanden ist.
GetRequest	Wartet auf die nächste Anforderung.
CheckRequest	Überprüft, ob eine Anforderung vorhanden ist, ohne zu blockieren.
Antwort	Antwortet auf eine Anforderung.
GetRequestHandle	Ruft ein Handle für das Ereignis ab, das von der CallWorker-Methode signalisiert wird.
GetRequestParam	Ruft die neueste Anforderung ab.
CoInitializeHelper	Ruft CoInitializeEx am Anfang des Threads auf.
Reine virtuelle Methoden	BESCHREIBUNG
ThreadProc	Threadprozedur.

Bemerkungen

Diese Klasse bietet Methoden zum Erstellen eines Workerthreads, zum Übergeben von Anforderungen an den Thread und zum Warten auf das Beenden des Threads. Gehen Sie wie folgt vor, um diese Klasse zu verwenden:

• Leiten Sie eine Klasse von ab CAMThread , und überschreiben Sie die reine virtuelle Methode CAMThread::ThreadProc. Diese Methode ist die Threadprozedur, die am Anfang des Threads aufgerufen wird.
• Erstellen Sie in Ihrer Anwendung eine instance Ihrer abgeleiteten Klasse. Beim Erstellen des Objekts wird der Thread nicht erstellt. Rufen Sie zum Erstellen des Threads die CAMThread::Create-Methode auf.
• Um Anforderungen an den Thread zu senden, rufen Sie die CAMThread::CallWorker-Methode auf. Diese Methode verwendet einen DWORD-Parameter, dessen Bedeutung durch Ihre -Klasse definiert wird. Die -Methode blockiert, bis der Thread antwortet (siehe unten).
• Antworten Sie in Ihrer Threadprozedur auf Anforderungen, indem Sie camThread::GetRequest oder CAMThread::CheckRequest aufrufen. Die GetRequest-Methode blockiert, bis ein anderer Thread CallWorker aufruft. Die CheckRequest-Methode ist nicht blockierend, sodass der Thread während der asynchronen Arbeit nach neuen Anforderungen suchen kann.
• Wenn der Thread eine Anforderung empfängt, rufen Sie CAMThread::Reply auf, um die Blockierung des aufrufenden Threads aufzuheben. Die Reply-Methode akzeptiert einen DWORD-Parameter, der an den aufrufenden Thread als Rückgabewert für CallWorker übergeben wird.

Wenn Sie mit dem Thread fertig sind, rufen Sie die CAMThread::Close-Methode auf. Diese Methode wartet, bis der Thread beendet wird, und schließt dann das Threadhandle. Ihre ThreadProc-Nachricht muss entweder allein oder als Reaktion auf eine CallWorker-Anforderung beendet werden. Die Destruktormethode ruft auch Close auf.

Im folgenden Beispiel werden die folgenden Schritte veranschaulicht:

class MyThread : public CAMThread
{
protected:
    DWORD ThreadProc(void);
};

DWORD MyThread::ThreadProc()
{
    BOOL bShutDown = FALSE;
    while (!bShutDown)
    {
        DWORD req = GetRequest();
        printf("Request: %d\n", req);
        bShutDown = (req == 0);
        Reply(bShutDown ? S_FALSE : S_OK);
    }
    printf("Quitting Thread\n");
    return 1;
}

void main()
{
    MyThread thread;
    DWORD reply;
    
    thread.Create();
    reply = thread.CallWorker(3);
    reply = thread.CallWorker(0); // Thread exits.
}

In Der abgeleiteten Klasse können Sie auch Memberfunktionen definieren, die die Parameter für CallWorker überprüfen. Das folgende Beispiel zeigt eine typische Vorgehensweise:

enum Command {CMD_INIT, CMD_RUN, CMD_STOP, CMD_EXIT};

HRESULT Init(void)  { return CallWorker(CMD_INIT); }
HRESULT Run(void)   { return CallWorker(CMD_RUN); }
HRESULT Stop(void)  { return CallWorker(CMD_STOP); }
HRESULT Exit(void)  { return CallWorker(CMD_EXIT); }

Die CAMThread -Klasse stellt zwei kritische Abschnitte als öffentliche Membervariablen bereit. Verwenden Sie CAMThread::m_AccessLock , um den Zugriff auf den Thread durch andere Threads zu sperren. (Beispielsweise enthalten die Create- und CallWorker-Methoden diese Sperre, um Vorgänge im Thread zu serialisieren.) Verwenden Sie CAMThread::m_WorkerLock , um Daten zu sperren, die von Threads gemeinsam genutzt werden.

Anforderungen

Anforderung	Wert
Header	Wxutil.h (Streams.h einschließen)
Bibliothek	Strmbase.lib (Einzelhandelsbuilds); Strmbasd.lib (Debugbuilds)