多线程处理一个问题和多个问题

1.启动多个线程，完成同一个任务（控制台应用程序）：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;

namespace ConsoleApplication1
{
    class Program
    {
        static internal Thread[] threads = new Thread[10];
        public static void Main()
        {
            Account acc = new Account(10000);
            for (int i = 0; i < 10; i++)
            {
                Thread t = new Thread(new ThreadStart(acc.DoTransactions));
                threads[i] = t;
            }
            for (int i = 0; i < 10; i++)
            {
                threads[i].Name = i.ToString();
            }
            for (int i = 0; i < 10; i++)
            {
                threads[i].Start();
               
            }
            Console.ReadLine();
        }
    }

    internal class Account
    { 
        int balance; //余额
        Random r=new Random(); 
        internal Account(int initial)  
        {  
            balance=initial; 
        }
        internal int Withdraw(int amount) //取回、取款
        { 
            if(balance<0) 
            {  
                //如果balance小于0则抛出异常  
                throw new Exception("NegativeBalance");//负的 余额 
            } 
            //下面的代码保证在当前线程修改balance的值完成之前 
            //不会有其他线程也执行这段代码来修改balance的值  
            //因此，balance的值是不可能小于0的  
            lock(this)  
            { 
                Console.WriteLine("CurrentThread:"+Thread.CurrentThread.Name); 
                //如果没有lock关键字的保护，那么可能在执行完if的条件判断(成立)之后  
                //另外一个线程却执行了balance=balance-amount修改了balance的值 
                //而这个修改对这个线程是不可见的，所以可能导致这时if的条件已经不成立了 
                //但是，这个线程却继续执行 balance=balance-amount，所以导致balance可能小于0 
                if(balance>=amount) 
                { 
                    Thread.Sleep(1000);
                    balance=balance-amount;
                    Console.WriteLine("余下钱："+ balance.ToString());
                    return  amount; 
                }  else 
                { 
                    return 0;
                    //transactionrejected 
                } 
            }  
        }
        internal void DoTransactions()//取款事务
        {
            //for (int i = 0; i < 100; i++)
            //{
                int index = r.Next(20, 100);
                Console.WriteLine("本次取款" + index.ToString());
                Withdraw(index);
            //}
        }
    }   



    internal class Test  
    {  
     
    } 
} 

2.启动多个线程，完成多个任务

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using CommonLibrary.Asynchronous;
using System.Threading;

namespace WindowsFormsApplication3
{
    public partial class Form1 : Form
    {
        //异步加载对象 
        private AsynchLoader _asynchLoader;
        public Form1()
        {
            InitializeComponent();

            //初始化异步变量
            _asynchLoader = new AsynchLoader();
            _asynchLoader.InvokeParameterizedMethod += AsynchLoadData;
            _asynchLoader.InvokeParameterizedMethodCompleted += AsynchLoadDataComplete;
            _asynchLoader.ParentControl = this;

       
        }
        #region 异步操作相关函数

        #region 异步加载入口方法

        /// <summary>
        /// 列子
        /// </summary>
        public void StartAsynch()
        {
            //下载公共资源信息
            LoaderObject loaderObject = new LoaderObject();
            loaderObject.Pool = LoaderPool.Pool0;
            _asynchLoader.Start(loaderObject);
        }
        /// <summary>
        /// 列子
        /// </summary>
        public void StartAsynch2()
        {
            //下载公共资源信息
            LoaderObject loaderObject = new LoaderObject();
            loaderObject.Pool = LoaderPool.Pool2;
            _asynchLoader.Start(loaderObject);
        }
        /// <summary>
        /// 列子
        /// </summary>
        public void StartAsynch3()
        {
            //下载公共资源信息
            LoaderObject loaderObject = new LoaderObject();
            loaderObject.Pool = LoaderPool.Pool3;
            _asynchLoader.Start(loaderObject);
        }
        #endregion

        #region 异步加载线程方法

        /// <summary>
        /// 异步方法
        /// </summary>
        private void AsynchMeth()
        {
            Thread.Sleep(1000);

        }
        /// <summary>
        /// 异步方法
        /// </summary>
        private void AsynchMeth2()
        {
            Thread.Sleep(5000);
           
            
        }
        /// <summary>
        /// 异步方法
        /// </summary>
        private void AsynchMeth3()
        {
            Thread.Sleep(10000);
            
           
        }
        #endregion

        #region 异步加载完成处理方法
        private void AsynchLoadComplete()
        {
            label1.Text="我是0,我完成了";
        }

        private void AsynchLoadComplete2()
        {
            label2.Text="我是2我完成了";
        }
        private void AsynchLoadComplete3()
        {
            label3.Text="我是3 我完成了";
        }
        #endregion

        /// <summary>
        /// 异步加载数据事件方法
        /// </summary>
        /// <param name="loaderObject"></param>
        private void AsynchLoadData(ref LoaderObject loaderObject)
        {
            switch (loaderObject.Pool)
            {
                case LoaderPool.Pool0://更新公共资源
                    this.AsynchMeth();
                    break;
                case LoaderPool.Pool2://更新公共资源
                    this.AsynchMeth2();
                    break;
                case LoaderPool.Pool3://更新公共资源
                    this.AsynchMeth3();
                    break;
               
            }
        }

        /// <summary>
        /// 异步加载数据完成事件方法
        /// </summary>
        /// <param name="loaderObject"></param>
        private void AsynchLoadDataComplete(ref LoaderObject loaderObject)
        {
            switch (loaderObject.Pool)
            {
                case LoaderPool.Pool0://更新公共资源完成
                    AsynchLoadComplete();
                    break;
                case LoaderPool.Pool2://更新公共资源完成
                    AsynchLoadComplete2();
                    break;
                case LoaderPool.Pool3://更新公共资源完成
                    AsynchLoadComplete3();
                    break;
            }
        }

        #endregion


        private void Form1_Load(object sender, EventArgs e)
        {
            //启动加载
            StartAsynch();
            StartAsynch2();
            StartAsynch3();
           
        }


    }
}

using System;
using System.Collections.Generic;
using System.Text;
using System.Threading;
using System.Windows.Forms;

namespace CommonLibrary.Asynchronous
{
    /// <summary>
    /// 线程异步读取器
    /// </summary>
    public class AsynchLoader
    {
        //当前运行的线程
        private Dictionary<int, Thread> _threadList = new Dictionary<int, Thread>();
        //父控件
        private System.Windows.Forms.Control parentControl;
        
        /// <summary>
        /// 将关联的特定控件
        /// </summary>
        public System.Windows.Forms.Control ParentControl
        {
            get { return parentControl; }
            set { parentControl = value; }
        }

        private Boolean controlThreadManaged = false;
        /// <summary>
        /// 是否操作特定控件
        /// </summary>
        public Boolean ControlThreadManaged
        {
            get { return controlThreadManaged; }
            set { controlThreadManaged = value; }
        }

        #region 带参方法的调用事件
        /// <summary>
        /// 带参数方法的委托
        /// </summary>
        /// <param name="loaderObject"></param>
        public delegate void ParameterizedThreadHandler(ref LoaderObject loaderObject);

        /// <summary>
        /// 带参方法的调用事件,需要自行处理控件线程操作
        /// </summary>
        public event ParameterizedThreadHandler InvokeParameterizedMethod;
        private void OnInvokeParameterizedMethod(ref LoaderObject loaderObject)
        {
            if (InvokeParameterizedMethod != null)
            {
                InvokeParameterizedMethod(ref loaderObject);
            }
        }
        /// <summary>
        /// 带参方法的调用完成事件,需要自行处理控件线程操作
        /// </summary>
        public event ParameterizedThreadHandler InvokeParameterizedMethodCompleted;
        private void OnInvokeParameterizedMethodCompleted(ref LoaderObject loaderObject)
        {
            if (InvokeParameterizedMethodCompleted != null)
            {
                InvokeParameterizedMethodCompleted(ref loaderObject);
            }
        }
        #endregion 带参方法的调用事件

        #region 不带参方法的调用事件
        /// <summary>
        /// 不带参数方法的委托
        /// </summary>
        public delegate void ThreadHandler();
        /// <summary>
        /// 不带参方法的调用事件
        /// </summary>
        public event ThreadHandler InvokeMethod;
        /// <summary>
        /// 触发不带参方法的调用事件
        /// </summary>
        private void OnInvokeMethod()
        {
            if (InvokeMethod != null)
            {
                InvokeMethod();
            }
        }

        /// <summary>
        /// 不带参数的方法的调用完成事件
        /// </summary>
        public event ThreadHandler InvokeMethodCompleted;
        /// <summary>
        /// 触发不带参方法的调用完成事件
        /// </summary>
        private void OnInvokeMethodCompleted()
        {
            if (InvokeMethodCompleted != null)
            {
                InvokeMethodCompleted();
            }
        }

        #endregion 不带参方法的调用事件

        #region 异常事件
        /// <summary>
        /// 异常事件
        /// </summary>
        public event DelegateException ThrowException;
        /// <summary>
        /// 异常事件触发
        /// </summary>
        /// <param name="exception">异常对象</param>
        protected void OnThrowException(Exception exception)
        {
            if (ThrowException != null)
                ThrowException(exception);
        }
        #endregion 异常事件

        /// <summary>
        /// 构造器
        /// </summary>
        public AsynchLoader()
        {
            _threadList = new Dictionary<int, Thread>();
            controlThreadManaged = false;

        }

        /// <summary>
        /// 构造器
        /// </summary>
        public AsynchLoader(Control ownerControl)
            : base()
        {
            _threadList = new Dictionary<int, Thread>();
            controlThreadManaged = false;
            parentControl = ownerControl;
        }

        /// <summary>
        /// 析构函数
        /// </summary>
        ~AsynchLoader()
        {
            AbortAllThread();
        }

        /// <summary>
        ///终止释放所有线程 
        /// </summary>
        public void AbortAllThread()
        {
            foreach (var th in _threadList.Values)
            {
                if (th.IsAlive)
                {
                    th.Abort();
                }                
            }
            _threadList.Clear();
        }

        /// <summary>
        ///终止释放指定的线程 
        /// </summary>
        public bool AbortThread(int key)
        {
            if (_threadList.ContainsKey(key))
            {
                if (_threadList[key].IsAlive)
                {
                    _threadList[key].Abort();
                    _threadList.Remove(key);
                    return true;
                }                
            }
            return false;
        } 

        /// <summary>
        /// 启动无参数线程
        /// </summary>
        /// <returns>返回当前启动线程的唯一ID</returns>
        public int Start()
        {
            Thread th = new Thread(new ThreadStart(InvokeMethodInThread));             
            th.Start();
            _threadList.Add(th.ManagedThreadId, th);
            return th.ManagedThreadId;
        }

        /// <summary>
        /// 启动带参数线程
        /// </summary>
        /// <param name="obj"></param>
        /// <returns>返回当前启动线程的唯一ID</returns>
        public int Start(LoaderObject loaderObject)
        {
            Thread th = new Thread(new ParameterizedThreadStart(InvokeParameterizedMethodInThread));
            th.Start(loaderObject);
            _threadList.Add(th.ManagedThreadId, th);
            return th.ManagedThreadId;
        }

        private bool RemoveThread(int key)
        {
            return _threadList.Remove(key);          
        }

        /// <summary>
        /// 无参数的线程内方法
        /// </summary>
        private void InvokeMethodInThread()
        {
            try
            {
                //触发不带参数的方法调用事件
                try
                {
                    if (controlThreadManaged || parentControl != null && parentControl.IsHandleCreated)
                    {
                        parentControl.BeginInvoke(new ThreadHandler(OnInvokeMethod));
                    }
                    else
                    {
                        OnInvokeMethod();
                    }
                }
                catch (Exception ex)
                {
                    
                    OnThrowException(ex);

                }
                //触发不带参数的方法调用完成事件
                try
                {
                    if (controlThreadManaged || parentControl != null && parentControl.IsHandleCreated)
                    {
                        parentControl.BeginInvoke(new ThreadHandler(OnInvokeMethodCompleted));
                    }
                    else
                    {
                        OnInvokeMethodCompleted();
                    }
                }
                catch (Exception ex)
                {
                    
                    OnThrowException(ex);
                }
            }
            finally
            {
                //移除当前线程
                RemoveThread(Thread.CurrentThread.ManagedThreadId);
            }
        }//end method

        /// <summary>
        /// 带参数的线程内的方法
        /// </summary>
        /// <param name="obj"></param>
        private void InvokeParameterizedMethodInThread(object obj)
        {
            LoaderObject loaderObject = obj as LoaderObject;
            try
            {
                //触发带参数的方法调用事件
                try
                {
                    //if (controlThreadManaged || parentControl != null && parentControl.IsHandleCreated)
                    //{
                    //    parentControl.BeginInvoke(new ParameterizedThreadHandler(OnInvokeParameterizedMethod), new object[] { loaderObject });
                    //}
                    //else
                    //{
                    //    OnInvokeParameterizedMethod(ref loaderObject);
                    //}
                    OnInvokeParameterizedMethod(ref loaderObject);


                }
                catch (Exception ex)
                {
                   
                    OnThrowException(ex);
#if DEBUG
                    throw ex;
#endif
                }
                //触发带参数的方法调用完成事件
                try
                {
                    if (controlThreadManaged || parentControl != null && parentControl.IsHandleCreated)
                    {
                        parentControl.BeginInvoke(new ParameterizedThreadHandler(OnInvokeParameterizedMethodCompleted), new object[] { loaderObject });
                    }
                    else
                    {
                        OnInvokeParameterizedMethodCompleted(ref loaderObject);
                    }
                }
                catch (Exception ex)
                {
                   
                    OnThrowException(ex);
                }
            }
            finally
            {
                //移除当前线程
                RemoveThread(Thread.CurrentThread.ManagedThreadId);
            }
        }//end method

    }//end class
}//end namespace

using System;
using System.Collections.Generic;
using System.Text;

namespace CommonLibrary.Asynchronous
{

    /// <summary>
    /// 识别读取池(一般默认为Pool0，在同一界面中使用多个线程控制时可以使用)
    /// </summary>
    public enum LoaderPool
    {
        Pool0,
        Pool1,
        Pool2,
        Pool3,
        Pool4,
        Pool5,
        Pool6,
        Pool7,
        Pool8,
        Pool9
    }

    /// <summary>
    /// 异步读取器对象
    /// </summary>
    public class LoaderObject
    {
        /// <summary>
        /// 数据对象
        /// </summary>
        private object _obj = new object();
        /// <summary>
        /// 数据对象
        /// </summary>
        public object Obj
        {
            get
            {
                return _obj;
            }
            set
            {
                _obj = value;
            }
        }

        /// <summary>
        /// 异步池(一般默认为pool0，在同一界面中使用多个线程控制时可以使用)
        /// </summary>
        private LoaderPool _pool = LoaderPool.Pool0;
        /// <summary>
        /// 异步池(一般默认为pool0，在同一界面中使用多个线程控制时可以使用)
        /// </summary>
        public LoaderPool Pool
        {
            get
            {
                return _pool;
            }
            set
            {
                _pool = value;
            }
        }
        /// <summary>
        /// 数据对象
        /// </summary>
        private object _data;
        /// <summary>
        /// 数据对象
        /// </summary>
        public object Data
        {
            get
            {
                return _data;
            }
            set
            {
                _data = value;
            }
        }
    }
}

using System;
using System.Collections.Generic;
using System.Text;

namespace CommonLibrary.Asynchronous
{
    /// <summary>
    /// 异常委托
    /// </summary>
    /// <param name="exception">异常对象</param>
    public delegate void DelegateException(Exception exception);

    /// <summary>
    /// 提示信息委托
    /// </summary>
    /// <param name="hintInformation">提示信息</param>
    public delegate void DelegateHintInformation(string hintInformation);

    class SystemUtils
    {
    }
}