¿Cuál es la mejor práctica para usar el bloqueo dentro de clases heredadas

Question

Quiero saber si una clase hereda de otra, es mejor que las clases compartan un objeto de bloqueo definido en la clase base o que tenga un objeto de bloqueo definido en cada nivel de herencia.

Un ejemplo muy simple de un objeto de bloqueo en cada nivel de la clase

public class Foo { 
    private object thisLock = new object(); 
    private int ivalue; 

    public int Value { 
    get { 
     lock(thisLock) { 
     return ivalue; 
     } 
    } 
    set { 
     lock(thisLock) { 
     ivalue= value; 
     } 
    } 
    } 
} 

public class Foo2: Foo { 
    private object thisLock2 = new object(); 

    public int DoubleValue { 
    get { 
     lock(thisLock2) { 
     return base.Value * 2; 
     } 
    } 
    set { 
     lock(thisLock2) { 
     base.Value = value/2; 
     } 
    } 
    } 
} 

public class Foo6: Foo2 { 
    private object thisLock6 = new object(); 

    public int TripleDoubleValue { 
    get { 
     lock(thisLock6) { 
     return base.DoubleValue * 3; 
     } 
    } 
    set { 
     lock(thisLock6) { 
     base.DoubleValue = value/3; 
     } 
    } 
    } 
} 

Un ejemplo muy simple de un objeto de bloqueo compartido

public class Foo { 
    protected object thisLock = new object(); 
    private int ivalue; 

    public int Value { 
    get { 
     lock(thisLock) { 
     return ivalue; 
     } 
    } 
    set { 
     lock(thisLock) { 
     ivalue= value; 
     } 
    } 
    } 
} 

public class Foo2: Foo {  
    public int DoubleValue { 
    get { 
     lock(thisLock) { 
     return base.Value * 2; 
     } 
    } 
    set { 
     lock(thisLock) { 
     base.Value = value/2; 
     } 
    } 
    } 
} 
public class Foo6: Foo2 {  
    public int TripleDoubleValue { 
    get { 
     lock(thisLock) { 
     return base.DoubleValue * 3; 
     } 
    } 
    set { 
     lock(thisLock) { 
     base.DoubleValue = value/3; 
     } 
    } 
    } 
} 

Qué ejemplo es la manera preferida para administrar bloqueo dentro de una clase heredada?

Answer 1

Puede encontrar su segunda opción muy a menudo en el .NET Framework, utilizando una propiedad en lugar de un campo, aunque (por ejemplo, la CommunicationObject.ThisLock Property):

public class Foo { 
    private readonly object thisLock = new object(); 
    private int ivalue; 

    protected object ThisLock { 
    get { 
     return thisLock; 
    } 
    } 

    public int Value { 
    get { 
     lock(ThisLock) { 
     return ivalue; 
     } 
    } 
    set { 
     lock(ThisLock) { 
     ivalue= value; 
     } 
    } 
    } 
} 

y

public class Foo2: Foo {  
    public int DoubleValue { 
    get { 
     lock(ThisLock) { 
     return base.Value * 2; 
     } 
    } 
    set { 
     lock(ThisLock) { 
     base.Value = value/2; 
     } 
    } 
    } 
} 

Answer 2

¿Cuántas las instancias de un objeto de bloqueo que tenga deben ser iguales a la cantidad de cosas a las que intenta controlar el acceso. Si todas las subclases comparten el mismo recurso, entonces debe haber un único objeto de bloqueo, por ejemplo, un campo/propiedad en la clase base.