相关疑难解决方法(0)

我有obj第三方组件的对象,

// this could take more than 30 seconds
int result = obj.PerformInitTransaction(); 

我不知道里面发生了什么.我所知道的是,如果需要更长的时间,那就失败了.

如何为此操作设置超时机制,以便如果超过30秒我只是抛出MoreThan30SecondsException？

如果同步方法执行时间太长,我正在寻找一种有效的方法来抛出超时异常.我见过一些样品,但没有什么能完全符合我的要求.

我需要做的是

1. 检查同步方法是否超过其SLA
2. 如果它确实抛出超时异常

我不是要终止同步方法,如果执行时间过长.(多次故障会使断路器跳闸并防止级联故障)

到目前为止我的解决方案如下所示.请注意,我确实将CancellationToken传递给了sync方法,希望它能在超时时遵循取消请求.此外,我的解决方案返回一个任务,然后我可以根据需要等待我的调用代码.

我担心的是,这个代码会为每个监控方法创建两个任务.我认为TPL会很好地管理这个,但我想证实一下.

这有意义吗？有一个更好的方法吗？

private Task TimeoutSyncMethod( Action<CancellationToken> syncAction, TimeSpan timeout )
{
  var cts = new CancellationTokenSource();

  var outer = Task.Run( () =>
  {
     try
     {
        //Start the synchronous method - passing it a cancellation token
        var inner = Task.Run( () => syncAction( cts.Token ), cts.Token );

        if( !inner.Wait( timeout ) )
        {
            //Try give the sync method a chance to abort grecefully
            cts.Cancel();
            //There was a timeout regardless of what the sync …

我有一个线程从网络或串口抓取一些数据.如果在5秒内没有收到数据,则线程必须终止(或返回false).

换句话说,如果运行线程花费的时间超过5秒,则必须停止.

我用C#编写,但任何.NET语言都可以.

我有一个函数,它在串行端口上调用读或写请求,然后返回读取的值.我正在使用Commstudio express(我正在实现Commstudio中的一个类),但它的超时功能似乎根本不起作用,所以我正在尝试实现自己的超时.目前我有一个定时器,根据请求设置读取或写入端口,如果定时器熄灭,回调将关闭连接导致异常.我试图让计时器的回调抛出一个异常,但异常需要通过调用原始读/写函数的线程传播,所以这样,它起作用,但我觉得它很混乱,那里必须是一个更好的方式来做我想要的.

我是C#新线程的新手.有没有为线程设置超时而不阻塞调用线程(在C#3.5中)？

如果没有,使用线程执行函数是否合乎逻辑,并且在该函数内创建一个线程并加入它来克服这个主线程阻塞问题？为了显示:

代替:

Public void main()
{
        ...
        Thread thrd1 = new Thread(new ThreadStart(targetObj.targetFunc));
        thrd1.Start();
        thrd1.Join();
        ...
}

使用类似的东西:

Public void main()
{
        ...
        Thread thrd1 = new Thread(new ThreadStart(middleObj.waiter));
        thrd1.Start();
        ...
}

//And in the middleObj.waiter():
Public void waiter()
{
        Thread thrd2 = new Thread(new ThreadStart(targetObj.targetFunc));
        thrd2.Start();
        thrd2.Join();
}

使用这样的while循环是不好的做法吗？也许最好使用秒表,或者这个解决方案有一些陷阱？

    public void DoWork()
    {
        //do some preparation
        DateTime startTime = DateTime.Now;
        int rowsCount = 0;
        int finalCount = getFinalCount();
        do
        {
            Thread.Sleep(1000);
            rowsCount = getRowsCount(); // gets rows count from database, rows are added by external app.
        } while (rowsCount < finalCount && DateTime.Now - startTime < TimeSpan.FromMinutes(10));

    }

我看到这篇文章实现了C#Generic Timeout,但是在简单的场景中使用它太复杂了 - 你需要考虑线程的同步,是否适合中止它们等等.

我有一个组件,它在每个单独的线程中处理多个Web请求.每个WebRequest处理都是同步的.

public class WebRequestProcessor:System.ComponentModel.Component
{
    List<Worker> tlist = new List<Worker>();
    public void Start()
    {
        foreach(string url in urlList){
            // Create the thread object. This does not start the thread.
            Worker workerObject = new Worker();
            Thread workerThread = new Thread(workerObject.DoWork);

            // Start the worker thread.
            workerThread.Start(url);
            tlist.Add(workerThread);
        }
    }
}

public class Worker
{
    // This method will be called when the thread is started.
    public void DoWork(string url)
    {
        // prepare the web page we will be asking for
        HttpWebRequest …

通过Thread.Abort()取消线程时,Thread Thread.Abort内部会抛出一个ThreadAbortException.这导致线程立即停止其工作,并且异常在调用堆栈中冒泡,直到它离开线程的main方法.这会导致线程中止.

线程主方法中调用Thread.ResetAbort()的ThreadAbortException的ExceptionHandler有什么好处,当线程因为跳出其主方法而在catch块之后终止自身时？

private void ThreadMainMethod( )
{
    try
    {
        while(runningAllowed = true)
        {
            //Do some work here
        }
    }
    catch ( ThreadAbortException )
    {
        Thread.ResetAbort( );
    }
}

有没有办法在System.Linq.Xml.XDocument.Load(string uri)上设置超时？或者我应该使用实现C#通用超时中描述的技术？

我实现了一个自定义状态“已阻止”，该状态在满足某些外部要求之后将进入排队状态。

有时，这些外部要求从未得到满足，这导致作业陷入阻塞状态。我想让处于这种状态的作业在经过一段可配置的时间后自动过期。

有这种要求的支持吗？有一个ExpirationDate领域，但是从代码来看，它似乎仅用于final状态。

状态非常简单：

    internal sealed class BlockedState : IState
    {
        internal const string STATE_NAME = "Blocked";

        public Dictionary<string, string> SerializeData()
        {
            return new Dictionary<string, string>();
        }

        public string Name => STATE_NAME;

        public string Reason => "Waiting for external resource";

        public bool IsFinal => false;

        public bool IgnoreJobLoadException => false;
    }

并简单地用作 _hangfireBackgroundJobClient.Create(() => Console.WriteLine("hello world"), new BlockedState());

在稍后的阶段，然后通过 _hangfireBackgroundJobClient.ChangeState(jobId, new EnqueuedState(), BlockedState.STATE_NAME)