Question

我的函数就像这样我将使用threading.timer来运行这个函数，当一个线程在锁定的myLockHolder里面然后另一个线程无法进入这个锁定时，当第一个释放这个锁时再输入另一个＆amp;线程的数量将等待执行我想只需要一个锁定＆amp;只有一个等待锁定线程池＆amp;另一个线程处理工作。

TimerCallback call = new TimerCallback(reconnect);
  TimeSpan dueTime = new TimeSpan(0, 0, 0, 0, 2000);
  TimeSpan interval = new TimeSpan(0, 0, 0, 0, 2000);
 timer1 = new System.Threading.Timer(call, _opcServer, dueTime, interval);
public void reconnect(object server)
        {          

            try
            {
                lock (myLockHolder)
                {                    
                    int  i;
                    int groupcnt1 = 0, cntgroup1 = 0;
                    DataSet dsgroup1, ds2;
                    DataTable grpdt1;
                    _opcServer2 = (OpcServer[])server;
                    while (g < _opcServer2.Length)
                    {
                        SrvStatus status;
                        i = _opcServer2[g].GetStatus(out status);
                        if (HRESULTS.Failed(i))
                        {
                            int j = _opcServer[g].Connect(_opcServer2[g].HostInfo.HostName, _opcServer2[g].ServerName);
                            int id1 = opcconn.getserverID(_opcServer2[g].ServerName, _opcServer2[g].HostInfo.HostName);
                            dsgroup1 = grpclass.getgroupinfo(id1);

                            if (dsgroup1.Tables[0].Rows.Count != 0 && dsgroup1 != null)
                            {
                                grpdt1 = new DataTable();
                                grpdt1 = dsgroup1.Tables[0].Copy();
                                foreach (DataRow Row in grpdt1.Rows)
                                {
                                    if (groupcnt1 < 128)
                                    {
                                        if (cntgroup1 < grpdt1.Rows.Count)
                                        {
                                            ds2 = param.getparameter1(Convert.ToInt32(Row["groupID"]));
                                            int timerstart = (Convert.ToInt32(Row["groupID"])) - 1;
                                            if (ds2.Tables[0].Rows.Count != 0)
                                            {
                                                OPCthread(Row, timerstart, g);

                                            }
                                            groupcnt1++;
                                            cntgroup1++;
                                        }
                                    }
                                }
                            }

                        }
                        cntgroup1 = 0;
                        g++;
                    }
                    if (g == _opcServer2.Length)
                    {
                        g = 0;
                    }
                }
            }
}

Answer 1

在你的计时器回调中你应该做两件事：

1）调用timer1.Adjust以防止发生新的回调

2）设置一个标志，以便在调整定时器之前发生另一个回调，回调立即返回。您应该在执行回调中的实际工作时将其与您所持有的锁同步锁定

Answer 2

您可以使用Semaphore类来重新访问有限数量的线程，然后您可以使用lock来提供对有限线程中的一个线程的访问

你可以使用返回bool的用户semaphore.WaitOne方法来确定线程是否应该等待或者它应该继续。如果它返回true，您可以将锁定允许一个线程访问您的逻辑

定时器锁定属性为只读锁定功能

2 个答案: