C#线程执行超时处理与并发线程数控制实例

 更新时间:2014年11月04日 09:59:21   投稿:shichen2014  
这篇文章主要介绍了C#线程执行超时处理与并发线程数控制的方法,实例讲述了并发执行存储过程的最大个数,读者可对程序稍做改动即控制并发线程数,具有一定的参考借鉴价值,需要的朋友可以参考下

本文实例讲述了C#线程执行超时处理与并发线程数控制的方法。分享给大家供大家参考。具体实现方法如下:

特别说明:

1、为了测试方便,这里对存储过程的执行是模拟的

2、这里限制了并发执行存储过程的最大个数,但并没有对并发线程数进行控制,与文章标题略有不符,但程序稍做改动即可控制并发线程数

代码如下:

复制代码 代码如下:

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Data.OracleClient;
using System.Diagnostics;
using System.IO;
using System.ServiceProcess;
using System.Text;
using System.Threading;
using System.Timers;
using System.Xml;
using DBUtil;
using FQDService.Utils;

namespace FQDService
{
    /// <summary>
    /// FQD服务
    /// </summary>
    partial class FQDService : ServiceBase
    {
        #region 变量
        /// <summary>
        /// 存储过程配置文档
        /// </summary>
        public static XmlDocument doc;
        /// <summary>
        /// 执行存储过程线程数锁
        /// </summary>
        public static Object lockTreadCount = new Object();
        /// <summary>
        /// 执行存储过程超时时间
        /// </summary>
        public static int timeout = 1000;
        /// <summary>
        /// 等待执行存储过程时间间隔
        /// </summary>
        public static int interval = 100;
        /// <summary>
        /// 执行存储过程最大数
        /// </summary>
        public static int maxRunProcCount = 5;
        /// <summary>
        /// 执行存储过程数
        /// </summary>
        public static int runProcCount = 0;
        #endregion

        #region 构造函数
        public FQDService()
        {
            InitializeComponent();
        }
        #endregion

        #region 启动
        protected override void OnStart(string[] args)
        {
            // TODO: 在此处添加代码以启动服务。
            doc = XMLHelper.GetXmlDocument();
            System.Timers.Timer timer = new System.Timers.Timer(60 * 1000);
            timer.Elapsed += new System.Timers.ElapsedEventHandler(RunProc);
            timer.Start();
        }
        #endregion

        #region 结束
        protected override void OnStop()
        {
            // TODO: 在此处添加代码以执行停止服务所需的关闭操作。
        }
        #endregion

        #region 执行存储过程
        /// <summary>
        /// 执行存储过程
        /// </summary>
        public void RunProc(object sender, ElapsedEventArgs e)
        {
            try
            {
                Random rnd = new Random();
                XmlNode rootNode = doc.SelectSingleNode("settings");

                foreach (XmlNode procNode in rootNode.ChildNodes) // 遍历Proc
                {
                    string procName = procNode.SelectSingleNode("Name").InnerText.Trim();
                    string runTime = procNode.SelectSingleNode("RunTime").InnerText.Trim();

                    if (DateTime.Now.ToString("HH:mm") == "14:55")
                    {
                        bool finish = false; //存储过程是否执行完毕
                        Thread thread = null;
                        thread = new Thread(new ParameterizedThreadStart(delegate(object obj)
                        {
                            #region 等待执行存储过程
                            lock (lockTreadCount)
                            {
                                while (runProcCount >= maxRunProcCount)
                                {
                                    Thread.Sleep(interval);
                                }
                                runProcCount++;
                            }
                            #endregion

                            #region 执行存储过程超时处理
                            Thread threadTimer = new Thread(new ParameterizedThreadStart(delegate(object obj2)
                            {
                                Thread.Sleep(timeout);
                                if (finish == false)
                                {
                                    FileLogger.WriteLog(string.Format("存储过程{0}执行超时", procName));
                                    if (thread != null)
                                    {
                                        try
                                        {
                                            thread.Abort();
                                        }
                                        catch (Exception ex)
                                        {
                                            FileLogger.WriteErrorLog(string.Format("存储过程{0}终止线程出错:{1}", procName, ex.Message));
                                        }
                                    }
                                }
                            }));
                            threadTimer.Start();
                            #endregion

                            #region 为执行存储过程准备参数
                            XmlNodeList paramList = procNode.SelectSingleNode("Params").ChildNodes;
                            OracleParameter[] oracleParams = new OracleParameter[paramList.Count];
                            for (int i = 0; i < paramList.Count; i++) // 遍历param
                            {
                                XmlNode paramNode = paramList[i];
                                string paramName = paramNode.SelectSingleNode("Name").InnerText.Trim();
                                string paramType = paramNode.SelectSingleNode("Type").InnerText.Trim();
                                string paramValue = paramNode.SelectSingleNode("Value").InnerText.Trim();

                                oracleParams[i] = new OracleParameter(paramName, Enum.Parse(typeof(OracleType), paramType));
                                if ((OracleType)Enum.Parse(typeof(OracleType), paramType) == OracleType.DateTime)
                                {
                                    DateTime now = DateTime.Now;
                                    string[] paramValueArray = paramValue.Split(':');
                                    oracleParams[i].Value = new DateTime(now.Year, now.Month, now.Day, int.Parse(paramValueArray[0]), int.Parse(paramValueArray[1]), int.Parse(paramValueArray[2]));
                                }
                                else
                                {
                                    oracleParams[i].Value = paramValue;
                                }
                            }
                            #endregion

                            try
                            {
                                try
                                {
                                    #region 执行存储过程
                                    FileLogger.WriteLog(string.Format("开始执行存储过程{0}", procName));

                                    //执行存储过程
                                    //OracleHelper.RunProcedure(procName, oracleParams);

                                    //模拟执行存储过程
                                    Thread.Sleep(rnd.Next(100, 1900));

                                    FileLogger.WriteLog(string.Format("存储过程{0}执行成功", procName));
                                    finish = true;
                                    #endregion
                                }
                                catch (Exception ex)
                                {
                                    #region 执行存储过程失败日志
                                    StringBuilder sbParams = new StringBuilder();
                                    foreach (OracleParameter oracleParam in oracleParams)
                                    {
                                        sbParams.Append(string.Format("{0}:{1},", oracleParam.ParameterName, oracleParam.Value.ToString()));
                                    }
                                    string strParams = "";
                                    if (sbParams.Length > 0) strParams = sbParams.ToString(0, sbParams.Length - 1);
                                    FileLogger.WriteErrorLog(string.Format("存储过程执行失败{0}({1}):{2}", procName, strParams, ex.Message));
                                    #endregion
                                }
                            }
                            catch
                            {
                                //捕获线程终止异常
                            }
                            finally
                            {
                                runProcCount--;
                            }
                        }));
                        thread.Start();
                    }
                }
            }
            catch (Exception ex)
            {
                FileLogger.WriteErrorLog(ex.Message);
            }
        }
        #endregion

    }
}

希望本文所述对大家的C#程序设计有所帮助。

相关文章

  • 在C#语言里对NULL的技术处理小结

    在C#语言里对NULL的技术处理小结

    在 C# 中处理 null 值是编写可靠且可靠的代码的一个重要方面,在本文中,我将讨论一些在 C# 中处理 null 值的最常用技术,感兴趣的朋友跟随小编一起看看吧
    2024-05-05
  • 详解C#实现MD5加密的示例代码

    详解C#实现MD5加密的示例代码

    本篇文章主要介绍了C#实现MD5加密的示例代码,详细的介绍了几种方法,具有一定的参考价值,有兴趣的可以了解一下。
    2016-12-12
  • C# 运算符 ?、??、?: 各种问号的用法和说明

    C# 运算符 ?、??、?: 各种问号的用法和说明

    本文介绍C#中三种常见的问号运算符的使用方法,简单讲解给大家,希望对大家有所帮助。
    2016-04-04
  • c#实现繁体转简体的示例代码

    c#实现繁体转简体的示例代码

    OpenCC是一个开源的中文繁简转换工具,支持多种语言,这篇文章主要为大家介绍了C#如何使用OpenCC实现繁体转简体功能,有需要的可以了解下
    2025-01-01
  • C# DataTable中查询指定字段名称的数据

    C# DataTable中查询指定字段名称的数据

    这篇文章主要介绍了C# DataTable中查询指定字段名称的数据,本文直接给出实例代码,简单易懂,需要的朋友可以参考下
    2015-06-06
  • C#线程池ThreadPool用法简介

    C#线程池ThreadPool用法简介

    这篇文章介绍了C#线程池ThreadPool的用法,文中通过示例代码介绍的非常详细。对大家的学习或工作具有一定的参考借鉴价值,需要的朋友可以参考下
    2022-06-06
  • C#使用异步流高效处理序列数据的方法详解

    C#使用异步流高效处理序列数据的方法详解

    C#中的异步流(Async Streams),异步流是C# 8.0引入的一个新特性,它允许你异步地处理序列数据,非常适合处理大量数据或长时间运行的任务,本文给大家介绍了C#使用异步流高效处理序列数据的方法步骤,需要的朋友可以参考下
    2024-11-11
  • C# VB.NET 将Html转为Excel

    C# VB.NET 将Html转为Excel

    本文介绍通过C#和VB.NET代码展示将Html转为Excel文档的方法。文中的示例代码讲解详细,对我们学习C#有一定帮助,感兴趣的小伙伴可以了解一下
    2022-03-03
  • C#实现Word转换TXT的方法详解

    C#实现Word转换TXT的方法详解

    这篇文章主要为大家详细介绍了如何利用C#实现Word转换TXT的功能,文中的示例代码讲解详细,对我们学习C#有一定的帮助,感兴趣的小伙伴可以跟随小编一起了解一下
    2022-12-12
  • 关于async和await的一些误区实例详解

    关于async和await的一些误区实例详解

    这篇文章主要介绍了关于async和await的一些误区实例详解,有助于更加深入的理解C#程序设计,需要的朋友可以参考下
    2014-08-08

最新评论