Início / coding / Perguntas / 77224637
Accepted
frankenapps
Asked: 2023-10-04 02:15:33 +0800 CST

Quando exatamente um mutex é lançado no Windows?

  • 772

Usei com sucesso um mutex, criado usando CreateMutexset bInitialOwnerto TRUE, para garantir que apenas uma única instância do aplicativo seja executada várias vezes sem problemas.

Minha expectativa era que isso também fosse dimensionado para permitir no máximo duas instâncias em execução simultâneas. Aqui está meu código com o objetivo de conseguir isso:

#include <windows.h>
#include <synchapi.h>

#include <codecvt>
#include <chrono>
#include <iostream>
#include <thread>

int main() {
    std::cout << "New instance started.\n";

    HANDLE mutex_handle = CreateMutexW(0, TRUE, L"myMutex1");
    if (GetLastError() == ERROR_ALREADY_EXISTS) {
        std::cout << "At least one instance is already running.\nChecking if this is the second instance...\n";

        HANDLE mutex_handle2 = CreateMutexW(0, TRUE, L"myMutex2");

        if (GetLastError() == ERROR_ALREADY_EXISTS) {
            std::cout << "A second instance also exists already.\n";
        }
    }

    // In every case wait for 25 seconds to simulate a long running program (e.g. GUI, etc.).
    std::this_thread::sleep_for(std::chrono::milliseconds(25000));

    return 0;
}

Depois de abrir o programa três vezes, obtive a saída desejada na terceira instância:

New instance started.
At least one instance is already running.
Checking if this is the second instance...
A second instance also exists already.

No entanto, mesmo depois de fechar todas as instâncias abertas, exceto uma (por uma questão de simplicidade, digamos que todas, exceto a terceira instância, foram fechadas), ainda recebo a saída acima e não a esperada:

New instance started.

No entanto, após fechar todas as instâncias, o programa se comporta novamente conforme o esperado. Isso me leva a acreditar que os mutexes só são liberados após todas as instâncias serem fechadas, porém a documentação afirma:

Use a função CloseHandle para fechar o identificador. O sistema fecha o identificador automaticamente quando o processo termina. O objeto mutex é destruído quando seu último identificador é fechado.

Portanto, eu esperava que o mutex fosse liberado assim que seu processo de propriedade terminasse.

Por que isso não parece ser o caso e como eu poderia usar mutexes para limitar meu aplicativo a duas instâncias?

Informações adicionais

Minha suspeita era que cada thread subseqüente também adquiriu um identificador chamando CreateMutexWe, portanto, os mutexes só são destruídos quando o último identificador é fechado (por exemplo, a última instância em execução do "lote" é fechada e nenhuma outra instância está em execução).

Para atenuar isso pensei em simplesmente chamar CloseHandlecom o identificador o thread obtido, sempre que ERROR_ALREADY_EXISTSfor encontrado. O código que implementa isso está abaixo, mas leva exatamente ao mesmo comportamento descrito acima:

#include <windows.h>
#include <synchapi.h>

#include <codecvt>
#include <chrono>
#include <iostream>
#include <thread>

int main() {
    std::cout << "New instance started.\n";

    HANDLE mutex_handle = CreateMutexW(0, TRUE, L"myMutex1");
    if (GetLastError() == ERROR_ALREADY_EXISTS) {
        if (mutex_handle != NULL)
        {
            CloseHandle(mutex_handle);
        }

        std::cout << "At least one instance is already running.\nChecking if this is the second instance...\n";

        HANDLE mutex_handle2 = CreateMutexW(0, TRUE, L"myMutex2");
        if (GetLastError() == ERROR_ALREADY_EXISTS) {
            if (mutex_handle2 != NULL)
            {
                CloseHandle(mutex_handle2);
            }
            
            std::cout << "A second instance also exists already.\n";
        }
    }

    // In every case wait for 25 seconds to simulate a long running program (e.g. GUI, etc.).
    std::this_thread::sleep_for(std::chrono::milliseconds(25000));

    return 0;
}

Editar: o código acima realmente se comporta da maneira que pretendi. Cometi um erro ao testá-lo (executando o binário antigo com o código inicial).

c++

2 respostas

  1. Best Answer

    Você cria os mutexes em um estado próprio , mas não chama ReleaseMutexpara permitir a entrada de outros processos. Como você está usando os mutexes apenas para contar instâncias e não para fazer qualquer outra sincronização, apenas criá-los "sem propriedade" seria suficiente - e se o mutex que você tenta criar já existe, feche-o e tente em seguida, até que o número máximo de instâncias seja atingido.

    Poderia ser assim:

    template<std::size_t I>
class InstanceCounter {
public:
    InstanceCounter() {
        for(m_id = 0; m_id < I; ++m_id) {
            hMtx = CreateMutexW(nullptr, false,
                                (L"MUTEX" + std::to_wstring(m_id)).c_str());
            if(not hMtx)
                throw std::runtime_error("Could not create mutex");
            if(GetLastError() != ERROR_ALREADY_EXISTS)
                return;        // we found a free slot
            CloseHandle(hMtx); // don't lock this one up
        }
        // max instances reached
        throw std::runtime_error("Max instances running");
    }
    InstanceCounter(const InstanceCounter&) = delete;
    InstanceCounter& operator=(const InstanceCounter&) = delete;
    ~InstanceCounter() { CloseHandle(hMtx); }

    std::size_t my_id() const { return m_id; }

private:
    HANDLE hMtx;
    std::size_t m_id;
};

    E você poderia usá-lo assim. Aqui está um exemplo em que são permitidas no máximo 3 instâncias:

    int main() {
    try {
        InstanceCounter<3> ic;

        std::cout << ic.my_id() << '\n';

        std::this_thread::sleep_for(std::chrono::seconds(10));

        std::cout << ic.my_id() << " Done\n";
    } catch(const std::exception& ex) {
        std::cerr << "Exception: " << ex.what() << '\n';
    }
}
    • 3

  2. Um mutex está apenas ativo ou inativo. Se você deseja que um número não binário de chamadas de espera passe, você pode usar uma primitiva feita especificamente para isso, como semáforos , que pode definir um número máximo de chamadas a passar (no seu caso, 2).

    O único problema com essa abordagem é que, diferentemente dos mutexes, você também precisa lidar com o encerramento do aplicativo (para diminuir a contagem de semáforos, para que outra instância possa "entrar"). Isso, e de modo geral, se você precisar de 2 instâncias ao mesmo tempo, há muito poucos motivos para não permitir também qualquer número arbitrário.

    • 1

relate perguntas