在工作中，遇到这样一个需求，我要做一个业务，要验证一下现有的数据是否正确，但这个验证又不是必须的，只是说如果这里验证不通过，后面流程就可以不走了，但是如果这里没有验证到，后面也会有验证。也就是说不影响主流程，算得上是一个优化吧。比如我要查询一个东西，但是这个时间不能超过1秒。
在网上查了一下，基本上都是异步执行，有两个线程来做。我查到有两种方法。
第一种 独立成一个类
代码如下：
(1)、FuncTimeOut类
/// <summary>
/// 超时设置类
/// </summary>
public class FuncTimeOut
{
/// <summary>
/// 信号量
/// </summary>
private ManualResetEvent manu = new ManualResetEvent(false);
/// <summary>
/// 是否接受到信号
/// </summary>
private bool isgetSignal;
/// <summary>
/// 设置超时时间
/// </summary>
private int timeout;
/// <summary>
/// 要委托调用的方法的一个委托
/// </summary>
private Action<int> funcNeedRun;
/// <summary>
/// 构造函数
/// </summary>
/// <param name="action">委托</param>
/// <param name="timeout">超时时间</param>
public FuncTimeOut(Action<int> action, int timeout)
{
this.funcNeedRun = action;
this.timeout = timeout;
}
/// <summary>
/// 执行方法
/// </summary>
/// <param name="param">参数</param>
public void Execute(int param)
{
Action<int> tempAction = this.CombineActionAndManuset;
var r = tempAction.BeginInvoke(param, this.MyAsynCallback, null);
this.isgetSignal = this.manu.WaitOne(this.timeout);
if (this.isgetSignal == true)
{
Console.WriteLine("未超时.");
Console.WriteLine("ThreadName:" + Thread.CurrentThread.Name);
}
else
{
Console.WriteLine("超时");
Console.WriteLine("ThreadName:" + Thread.CurrentThread.Name);
}
}
/// <summary>
/// 回调函数
/// </summary>
/// <param name="ar">异步操作时的状态</param>
private void MyAsynCallback(IAsyncResult ar)
{
if (this.isgetSignal == false)
{
Console.WriteLine(Thread.CurrentThread.Name + ",超时,放弃执行回调函数");
Thread.CurrentThread.Abort();
}
else
{
Console.WriteLine(Thread.CurrentThread.Name + ",执行成功");
}
}
/// <summary>
/// 执行方法
/// </summary>
/// <param name="para">参数</param>
private void CombineActionAndManuset(int para)
{
Thread.CurrentThread.Name = "subThread";
this.funcNeedRun(para);
this.manu.Set();
}
}
(2)、测试代码
/// <summary>
/// Class Program
/// </summary>
public class Program
{
/// <summary>
/// Defines the entry point of the application.
/// </summary>
/// <param name="args">The args.</param>
public static void Main(string[] args)
{
TestFuncTimeOut();
Console.Read();
}
#region FunTimeOut测试
/// <summary>
/// 测试超时设置操作
/// </summary>
private static void TestFuncTimeOut()
{
Console.WriteLine("start");
Thread.CurrentThread.Name = "Main";
FuncTimeOut ft = new FuncTimeOut(ComputeSum, 3000);
ft.Execute(10); // 测试修改点
Console.WriteLine("ThreadName:" + Thread.CurrentThread.Name);
Console.WriteLine("end");
}
/// <summary>
/// Does the STH.
/// </summary>
/// <param name="num">The num.</param>
private static void ComputeSum(int num)
{
int sum = 0;
for (int i = 0; i < num; i++)
{
Thread.Sleep(500);
sum += i;
Console.WriteLine(i + ":ThreadName:" + Thread.CurrentThread.Name);
}
Console.WriteLine("sum = " + sum);
// return sum;
}
#endregion
}
(3)、执行结果
a、超时的情况（上面的测试代码测出来的结果）
1 start 2 0:ThreadName:subThread 3 1:ThreadName:subThread 4 2:ThreadName:subThread 5 3:ThreadName:subThread 6 4:ThreadName:subThread 7 超时 8 ThreadName:Main 9 ThreadName:Main 10 end 11 5:ThreadName:subThread 12 6:ThreadName:subThread 13 7:ThreadName:subThread 14 8:ThreadName:subThread 15 9:ThreadName:subThread 16 sum = 45 17 subThread,超时,放弃执行回调函数
b、未超时的情况(将上述黄色部分的标示改为:ft.Execute(3);的结果)
1 start 2 0:ThreadName:subThread 3 1:ThreadName:subThread 4 2:ThreadName:subThread 5 sum = 3 6 未超时. 7 ThreadName:Main 8 ThreadName:Main 9 end 10 subThread,执行成功
(4)、总结
从上面的结果可以看出：
第一、有两个线程
第二、无论是否超时，方法都会被执行完毕，如果超时，则不忘下执行回调函数，否则执行。
第二种 封装成一个方法
(1)、源代码
/// <summary>
/// 连续整数求和【测试方法】
/// </summary>
/// <param name="num">个数</param>
/// <returns>结果</returns>
private static int ComputeSumResult(int num)
{
int sum = 0;
for (int i = 0; i < num; i++)
{
Thread.Sleep(500);
sum += i;
Console.WriteLine(i + ",ThreadName:" + Thread.CurrentThread.Name);
}
return sum;
}
/// <summary>
/// 超时方法调用
/// </summary>
/// <param name="func">要调用的方法</param>
/// <param name="param">要调用方法的参数</param>
/// <param name="timeoutMillisecondes">超时时间</param>
/// <returns>结束</returns>
private static int CallWithTimeOutFun(Func<int, int> func, int param, int timeoutMillisecondes)
{
Thread threadToKill = null;
int sum = 0;
Action wrappedAction = () =>
{
threadToKill = Thread.CurrentThread;
threadToKill.Name = "threadToKill";
sum = func(param);
};
IAsyncResult result = wrappedAction.BeginInvoke(null, null);
if (result.AsyncWaitHandle.WaitOne(timeoutMillisecondes))
{
Console.WriteLine("ThreadName:" + Thread.CurrentThread.Name);
wrappedAction.EndInvoke(result);
Console.WriteLine("没有超时");
Console.WriteLine("ThreadName:" + Thread.CurrentThread.Name);
return sum;
}
else
{
Console.WriteLine("ThreadName:" + Thread.CurrentThread.Name);
threadToKill.Abort();
Console.WriteLine("超时");
Console.WriteLine("ThreadName:" + Thread.CurrentThread.Name);
return sum;
}
}
(2)、测试代码
/// <summary>
/// Class Program
/// </summary>
public class Program
{
/// <summary>
/// Defines the entry point of the application.
/// </summary>
/// <param name="args">The args.</param>
public static void Main(string[] args)
{
Console.WriteLine("start");
Thread.CurrentThread.Name = "Main";
int result = CallWithTimeOutFun(ComputeSumResult, 10, 3000);// 测试需要修改的代码
Console.WriteLine("ThreadName:" + Thread.CurrentThread.Name + ", 结果是:" + result);
Console.WriteLine("end");
Console.Read();
}
}
(3)、测试结果
a、超时情况
1 start 2 0,ThreadName:threadToKill 3 1,ThreadName:threadToKill 4 2,ThreadName:threadToKill 5 3,ThreadName:threadToKill 6 4,ThreadName:threadToKill 7 ThreadName:Main 8 超时 9 ThreadName:Main 10 ThreadName:Main, 结果是:0 11 end
b、不超时的情况(将上面测试需要修改的代码修改为：int result = CallWithTimeOutFun(ComputeSumResult, 3, 3000);// 测试需要修改的代码)
1 start 2 0,ThreadName:threadToKill 3 1,ThreadName:threadToKill 4 2,ThreadName:threadToKill 5 ThreadName:Main 6 没有超时 7 ThreadName:Main 8 ThreadName:Main, 结果是:3 9 end
(4)、总结
从上面的结果可以看出：
第一、有两个线程
第二、如果方法超时，则不会将被调用的方法执行完毕，可以看出，方法是执行了，但由于超时，结果是不对的。如果方法没有超时，结果为正确的。这与上面方法的区别在于，方法超时就不会继续执行了。
时间： 2024-10-27 13:58:43