--- tecla de bloqueo multi-hilo programación de la serie de aprendizaje

concepto

Ver Declaración de bloqueo mutex bloquear un objeto dado, ejecutar bloque de instrucciones, y luego liberar el bloqueo. Mientras que mantiene un bloqueo, que llevan a cabo las discusiones de bloqueo pueden obtener de nuevo y bloqueo de seguridad. Prevenir cualquier otro hilo para obtener cerradura y espera para el cierre de liberación.
cerradura se aplica sólo casos individuales, distribuye y la deuda equilibrada puede ser considerado como un bloqueo distribuido.

formulario

1. cerradura (esto)
2. cerradura (cadena)
3. cerradura (objeto)
4. cerradura (staticObject)

Código de ensayo:

class Program
{
     const string firstOrderId = "001";
     const string secondOrderId = "002";
     const string thirdOrderId = "003";

     static void Main()
     {
         test(LockType.LockThis);
         //test(LockType.LockString);
         //test(LockType.LockObject);
         //test(LockType.LockStaticObject);

         Console.ReadLine();
     }

     static void test(LockType lockType)
     {
         Console.ForegroundColor = ConsoleColor.Yellow;
         Console.WriteLine("------------测试相同订单------------");
         Console.ForegroundColor = ConsoleColor.White;
         OrderPay(firstOrderId, 1, lockType);
         OrderPay(firstOrderId, 2, lockType);
         OrderPay(firstOrderId, 3, lockType);
         Thread.Sleep(10000);

         Console.ForegroundColor = ConsoleColor.Yellow;
         Console.WriteLine("------------测试不同订单------------");
         Console.ForegroundColor = ConsoleColor.White;
         OrderPay(firstOrderId, 1, lockType);
         OrderPay(secondOrderId, 1, lockType);
         OrderPay(thirdOrderId, 1, lockType);
     }

     static void OrderPay(string orderId, int threadNo, LockType lockType)
     {
         new Thread(() => new Payment(orderId, threadNo).Pay(lockType)).Start();
         Thread.Sleep(10);
     }
 }
  public class Payment
  {
      private readonly string LockString;
      public readonly int ThreadNo;
      private readonly Object LockObj = new object();
      private static readonly Object StaticLockObj = new object();

      public Payment(string orderID, int threadNo)
      {
          LockString = orderID;
          ThreadNo = threadNo;
      }

      public void Pay(LockType lockType)
      {
          ShowMessage("等待锁资源");
          switch (lockType)
          {
              case LockType.LockThis:
                  lock (this)
                  {
                      showAction();
                  }
                  break;
              case LockType.LockString:
                  lock (LockString)
                  {
                      showAction();
                  }
                  break;
              case LockType.LockObject:
                  lock (LockObj)
                  {
                      showAction();
                  }
                  break;
              case LockType.LockStaticObject:
                  lock (StaticLockObj)
                  {
                      showAction();
                  }
                  break;
          }
          ShowMessage("释放锁");
      }

      private void showAction()
      {
          ShowMessage("进入锁并开始操作");
          Thread.Sleep(2000);
          ShowMessage("操作完成,完成时间为" + DateTime.Now);
      }

      private void ShowMessage(string message)
      {
          Console.WriteLine(String.Format("订单{0}的第{1}个线程 {2}", LockString, ThreadNo, message));
      }

  }

  public enum LockType
  {
      LockThis = 0,
      LockString = 1,
      LockObject = 2,
      LockStaticObject = 3
  }

cerradura (esto) resultado:

Se puede observar bloqueo (este), si se trata de una clase no estática no Singleton normal, entonces la cerradura (esto) no cumple con nuestras necesidades, incluso además del hilo actual y no ver ningún efecto.

Resultado bloqueo (cadena):

Cerradura (LockString) a partir de los resultados de la comparación, se ajusta a los requisitos, pero debido a la cadena especial para el mecanismo CRL residen cadena, diferentes variables para la misma cadena con un bloque de memoria montón administrado valor de cadena a punto de hacerlo. Puede resultar en orden post-conflicto similar a pagar el mismo desarrollo de negocios provocada por el mismo valor de cadena Identificador de identificación de los pedidos realizados con otros servicios, esto hará que el hilo de exclusión mutua entre los diferentes servicios

bloquear resultados (objeto):

Puede de este modo cambiar el objeto operador typeof o los obtenidos por la reflexión, la naturaleza, y de bloqueo (esto) como

bloquear resultados (staticObject):

Cerradura (StaticObject) para lograr la misma suma para pedidos hilo mutuamente excluyentes, pero no puede cumplir con los pedidos de diferentes pluma de la misma manera mutuamente excluyentes.

Resumir : Cuando un hilo para sincronizar el acceso a los recursos compartidos, la instancia de objeto específico de bloqueo (por ejemplo, balanceLock objeto de sólo lectura privada = nuevo objeto ();) o el otro es poco probable que sea como bloqueo de código instancia de objeto parte independiente. Evitar el uso de la misma instancia de objeto de bloqueo a diferentes recursos compartidos, ya que esto puede conducir a un callejón sin salida o bloqueo de contención. En particular, deben evitarse los objetos siguientes se utilizan como objetos de bloqueo :

• esto (la persona que llama puede utilizar como un bloqueo).
• Ejemplos de Tipo (typeof operador puede obtener a través de o reflejada).
• Ejemplos de la cadena, la cadena que comprende texto, (que puede ser almacenado temporalmente).