lock (new object ()) - Culto à carga ou algum “caso especial de linguagem” maluco?

Estou revisando um código escrito por um consultor e, embora dezenas de sinalizadores vermelhos já tenham surgido, não consigo entender o seguinte snippet:

private void foo()
{
    if (InvokeRequired)
    {
        lock (new object())
        {
            if (m_bar!= null)
                Invoke(new fooDelegate(foo), new object[] { });
        }
    }
    else
    {
        if(OnBazChanged != null)
            OnBazChanged();
    }
}

O que lock (new object ()) está fazendo aqui? Não deve ter nenhum efeito, pois está sempre travando em outro objeto, mas esse tipo de travamento é persistente em todo o código, mesmo em partes não copiadas e coladas. É algum caso especial na linguagem C # que é compilado para algo que eu não conheço, ou o programador simplesmente adotou algum culto ao cargo que funcionou algum tempo atrás?

Eu não ficaria surpreso se fosse alguém que visse isso:

private readonly object lockObj = new object();

private void MyMethod()
{
    lock(lockObj)
    {
        // do amazing stuff, so amazing it can only run once at a time
        // e.g. comands on the Mars Rover, or programs on iOS pre 4 / 5 ??
    }
}

e pensei que poderia cortar o número de linhas.

Eu ficaria muito preocupado se fosse esse o caso ...

Aqui está uma pergunta e resposta semelhante:

Os bloqueios garantem a exclusão mútua - não mais do que um thread pode segurar o bloqueio ao mesmo tempo. O bloqueio é identificado com uma instância de objeto específica. Você está criando um novo objeto para travar todas as vezes e não tem como informar a qualquer outro encadeamento para travar exatamente na mesma instância do objeto. Portanto, seu bloqueio é inútil.

Provavelmente é inútil. Mas existe uma chance remota de criar uma barreira de memória. Não tenho certeza se o c # bloqueia a elisão ou se preserva a semântica de ordenação do bloqueio.