Classe CAMThread

[La funzionalità associata a questa pagina, DirectShow, è una funzionalità legacy. È stata sostituita da MediaPlayer, IMFMediaEngine e Audio/Video Capture in Media Foundation. Queste funzionalità sono state ottimizzate per Windows 10 e Windows 11. Microsoft consiglia vivamente che il nuovo codice usi MediaPlayer, IMFMediaEngine e Audio/Video Capture in Media Foundation invece di DirectShow, quando possibile. Microsoft suggerisce che il codice esistente che usa le API legacy venga riscritto per usare le nuove API, se possibile.

La CAMThread classe è una classe astratta per la gestione dei thread di lavoro.

Commenti

Questa classe fornisce metodi per la creazione di un thread di lavoro, il passaggio delle richieste al thread e l'attesa dell'uscita del thread. Per usare questa classe, eseguire le operazioni seguenti:

• Derivare una classe da CAMThread ed eseguire l'override del metodo virtuale puro CAMThread::ThreadProc. Questo metodo è la routine thread che viene chiamata all'inizio del thread.
• Nell'applicazione creare un'istanza della classe derivata. La creazione dell'oggetto non crea il thread. Per creare il thread, chiamare il metodo CAMThread::Create .
• Per inviare richieste al thread, chiamare il metodo CAMThread::CallWorker . Questo metodo accetta un parametro DWORD, il cui significato è definito dalla classe . Il metodo si blocca fino a quando il thread non risponde (vedere di seguito).
• Nella procedura di thread rispondere alle richieste chiamando CAMThread::GetRequest o CAMThread::CheckRequest. Il metodo GetRequest si blocca fino a quando un altro thread chiama CallWorker. Il metodo CheckRequest non blocca, che consente al thread di verificare la presenza di nuove richieste durante il funzionamento asincrono.
• Quando il thread riceve una richiesta, chiama CAMThread::Reply per sbloccare il thread chiamante. Il metodo Reply accetta un parametro DWORD, che viene passato al thread chiamante come valore restituito per CallWorker.

Al termine del thread, chiamare il metodo CAMThread::Close . Questo metodo attende l'uscita del thread e quindi chiude l'handle del thread. È necessario garantire che il messaggio ThreadProc venga chiuso autonomamente o in risposta a una richiesta callworker. Il metodo distruttore chiama anche Close.

L'esempio seguente illustra questi passaggi:

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.
}

Nella classe derivata è anche possibile definire funzioni membro che convalidano i parametri in CallWorker. L'esempio seguente illustra un modo tipico per eseguire questa operazione:

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); }

La CAMThread classe fornisce due sezioni critiche come variabili membro pubblico. Usare CAMThread::m_AccessLock per bloccare l'accesso al thread da altri thread. Ad esempio, i metodi Create e CallWorker contengono questo blocco per serializzare le operazioni nel thread. Usare CAMThread::m_WorkerLock per bloccare i dati condivisi tra thread.

Requisiti