29WxOrder/AllBase/Threadx.cs

/*
 * 带超时的线程管理
 * 肖俊
 * 2014-8-21
 */

using System;
using System.Collections.Generic;
using System.Threading;

namespace AllBase
{
    /// <summary>
    /// 带超时的线程管理
    /// </summary>
    public class Threadx
    {
        /// <summary>
        /// 超时：秒
        /// </summary>
        public int TimeOut = 30;
        /// <summary>
        /// 主线程
        /// </summary>
        private Thread t=null;
        /// <summary>
        /// 判断是否结束线程
        /// </summary>
        private Thread te = null;
        /// <summary>
        /// 启动时间
        /// </summary>
        public DateTime StartTime;
        /// <summary>
        /// 是否存活
        /// </summary>
        public bool IsActive { get {
            try
            {
                return (t == null ? false : t.IsAlive);
            }
            catch
            {
                return false;
            }
            } }
        /// <summary>
        /// 线程名称
        /// </summary>
        public string Name = "";
        /// <summary>
        /// 初始化
        /// </summary>
        /// <param name="ts">要启动的线程</param>
        public Threadx(Thread ts)
        {
            t = ts;
            te = new Thread(End);
        }
        /// <summary>
        /// 初始化
        /// </summary>
        /// <param name="ts">要启动的线程</param>
        /// <param name="dt">启动时间</param>
        public Threadx(Thread ts, DateTime dt)
        {
            StartTime = dt;
            t = ts;
            Start();
        }
        /// <summary>
        /// 初始化+立即启动
        /// </summary>
        /// <param name="ts">要启动的线程</param>
        /// <param name="timeOut">超时</param>
        public Threadx(Thread ts, int timeOut)
        {
            t = ts;
            TimeOut = timeOut;
            te = new Thread(End);
            Start();
        }
        /// <summary>
        /// 初始化+立即启动
        /// </summary>
        /// <param name="ts">要启动的线程</param>
        /// <param name="timeOut">超时</param>
        /// <param name="name">名称</param>
        public Threadx(Thread ts, int timeOut, string name)
        {
            Name = name;
            t = ts;
            TimeOut = timeOut;
            te = new Thread(End);
            Start();
        }
        /// <summary>
        /// 启动，以最低优先级运行
        /// </summary>
        public void Start()
        {
            StartTime = DateTime.Now;
            if(t==null || t.IsAlive)
                return;
            try
            {
                t.Priority = ThreadPriority.Lowest;
                t.Start();
                if(te==null)
                    return;
                te.Priority = ThreadPriority.BelowNormal;
                te.Start();
            }
            catch 
            {
                Abort();
            }
        }

        /// <summary>
        /// 终止线程
        /// </summary>
        public void Abort()
        {
            try
            {
                if (t != null && t.IsAlive)
                    t.Abort();
                if(te!=null && te.IsAlive)
                    te.Abort();
                t = null;
                te = null;
            }
            catch
            {
            }
        }

        /// <summary>
        /// 判断超时与自动结束
        /// </summary>
        private void End()
        {
            if(t==null)
                return;
            int i = 0;
            while (t!=null && t.IsAlive && i < 10 * TimeOut)
            {
                Thread.Sleep(100);
                i++;
            }
            if (t != null && t.IsAlive)
                Abort();
        }

        /// <summary>
        /// 线程队列批量启动与执行超时控制
        /// </summary>
        /// <param name="ts">线程队列</param>
        /// <param name="timeOut">超时(单位秒)</param>
        /// <param name="sleep">启动等待（单位毫秒）</param>
        public static void ThreadListTimeOut(ref List<Thread> ts, int timeOut, int sleep)
        {
            if (timeOut < 1)
                return;
            try
            {
                int i;
                for (i = 0; i < ts.Count; i++)
                {
                    if(!ts[i].IsAlive)
                        ts[i].Start();
                    if (sleep > 0 && i < ts.Count - 1)
                        Thread.Sleep(sleep);
                }
                i = 0;
                while (ts.Count > 0 && i < 1000)
                {
                    if (ts[0] == null || !ts[0].IsAlive)
                        ts.RemoveAt(0);
                    Thread.Sleep(timeOut);
                    i++;
                }
                while (ts.Count > 0)
                {
                    try
                    {
                        if (ts[0] != null && ts[0].IsAlive)
                            ts[0].Abort();
                    }
                    catch 
                    {
                    }
                    ts.RemoveAt(0);
                }
            }
            catch
            {
            }
        }

        /// <summary>
        /// 等待队列
        /// </summary>
        /// <param name="ts">线程队列</param>
        /// <param name="t">新增线程</param>
        /// <param name="count">线程总数</param>
        public static void ThreadListWait(ref List<Thread> ts, Thread t, int count)
        {
            //t.SetApartmentState(ApartmentState.MTA);
            t.IsBackground = true;
            t.Start();
            ts.Add(t);
            if (ts.Count < count)
                return;
            while (ts.Count >= count)
            {
                for (int i = 0; i < ts.Count; i++)
                {
                    if (ts[i] == null || !ts[i].IsAlive)
                        ts.RemoveAt(i);
                }
                Thread.Sleep(10);
            }
        }
        /// <summary>
        /// 等待队列完全结束
        /// </summary>
        /// <param name="ts">线程队列</param>
        public static void ThreadListWait(ref List<Thread> ts)
        {
            while (ts.Count > 0)
            {
                if (ts[0] == null || !ts[0].IsAlive)
                    ts.RemoveAt(0);
                Thread.Sleep(10);
            }
        }
    }
}