C＃锁定线程

Question

I am currently trying to do some reading for locking for threads in C# .

If I have a class similar to below

public class Connection
{
    bool Connected;
    internal bool startConnection(Device dev)
    {
       // start connection
       Connected = true;
    }

    internal bool endConnection(Device dev)
    {
       // End connection
       Connected = false;
    }

    private void readFromConnected(Device dev)
    {
        if(Connected)
        {
            // read values from connected device
        }
    }
}

The problem I have right now is that i have multiple threads using this class to read values from different devices

A problem arises when a thread tries to read values when it is actually disconnected, but attempts to read the values anyways because another thread has kept the Connected bool to true;

The thread that is calling this class looks like this.

Device deviceReceived;
public PollingInstance(Device deviceSent)
    {
        deviceReceived = deviceSent;
        aTimer = new System.Timers.Timer(2500); //1000 = 1 sec
        aTimer.Elapsed += OnTimedEvent;
        aTimer.Enabled = true;
    }


 private void OnTimedEvent(Object source, ElapsedEventArgs e)
 {
     for (int i = 0; i < 10; i++)
     {
        Connection.startConnection(deviceReceived);
        Connection.readFromConnected(deviceReceived);
        Connection.endConnection(deviceReceived);
     }
 }

The part of the main class calling Polling Instance looks similar to this

foreach(Device dev in listOfDev)
{
    Task.Factory.StartNew(() => pollThread(dev));
}
private void pollThread(Device dev)
{
    PollingInstance testingPoll = new PollingInstance(dev);
}

Answer 1

Simple. Why is connected a bool ?

Try this.

public class Connection
{
    private int _connections = 0;
    internal bool startConnection(Device dev)
    {
       // start connection
       if(Interlocked.Increment(ref _connections) == 1)
       {
          //do work to connect.
       }
    }

    internal bool endConnection(Device dev)
    {
       // End connection
       if(Interlocked.Decrement(ref _connections) == 0)
       {
          //do work to disconnect.
       }
    }

    private void readFromConnected(Device dev)
    {
        if(_connections > 0)
        {
            // read values from connected device
        }
    }
}

This will "works" for some values of work. But is prone to connections being left open due to exceptions and sloppy/forgetful programming. Therefore I would advise the following.

Device device = ...
using(var connection = device.CreateConnection())
{
    var results = connection.Read();
}

public abstract class Connection : IDisposable
{
    public object Read();
}

public class Device
{
    private class DeviceConnection : Connection 
    {
        private Device Parent { get; set; }

        void Dispose()
        {
            Parent.StopConnection();
        }
        public object Read() 
        {
            return Device.readFromConnected();
        }
    }        

    private int _connections = 0;
    public Connection CreateConnection()
    {
       // start connection
       if(Interlocked.Increment(ref _connections) == 1)
       {
          //do work to connect.
       }
       return new DeviceConnection { Parent = this };
    }

    private bool StopConnection()
    {
       // End connection
       if(Interlocked.Decrement(ref _connections) == 0)
       {
          //do work to disconnect.
       }
    }

    private object readFromConnected()
    {
        //Device is guaranteed to be connected now!
    }
}

Answer 2

It's hard to say exactly what will happen, because the code you posted won't even compile.

you wan't something like this:

private void OnTimedEvent(Object source, ElapsedEventArgs e)
{
    Connection connection = whereverThisComesFrom();
    if(!Monitor.TryEnter(connection))  return; // another timer is in progress
    try
    {
      for (int i = 0; i < 10; i++)
      {
         connection.startConnection(deviceReceived);
         connection.readFromConnected(deviceReceived);
         connection.endConnection(deviceReceived);
      }
    }
    finally
    {
      Monitor.Exit(connection);
    }
}

Answer 3

You said:

A problem arises when a thread tries to read values when it is actually disconnected, but attempts to read the values anyways because another thread has kept the Connected bool to true;

Can you use a try/finally to ensure you set the boolean properly?

The lock keyword is equivalent to a Monitor try/finally.

object syncObject = new object();
Monitor.Enter(syncObject);
try {
    // Code updating shared data
}
finally {
    Monitor.Exit(syncObject);
}

object syncObject = new object();
lock (syncObject) {
// Code updating shared data
}