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

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

View Code

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.启动多个线程，完成多个任务

View Code

  1 using System;
  2 using System.Collections.Generic;
  3 using System.ComponentModel;
  4 using System.Data;
  5 using System.Drawing;
  6 using System.Linq;
  7 using System.Text;
  8 using System.Windows.Forms;
  9 using CommonLibrary.Asynchronous;
 10 using System.Threading;
 11 
 12 namespace WindowsFormsApplication3
 13 {
 14     public partial class Form1 : Form
 15     {
 16         //异步加载对象 
 17         private AsynchLoader _asynchLoader;
 18         public Form1()
 19         {
 20             InitializeComponent();
 21 
 22             //初始化异步变量
 23             _asynchLoader = new AsynchLoader();
 24             _asynchLoader.InvokeParameterizedMethod += AsynchLoadData;
 25             _asynchLoader.InvokeParameterizedMethodCompleted += AsynchLoadDataComplete;
 26             _asynchLoader.ParentControl = this;
 27 
 28        
 29         }
 30         #region 异步操作相关函数
 31 
 32         #region 异步加载入口方法
 33 
 34         /// <summary>
 35         /// 列子
 36         /// </summary>
 37         public void StartAsynch()
 38         {
 39             //下载公共资源信息
 40             LoaderObject loaderObject = new LoaderObject();
 41             loaderObject.Pool = LoaderPool.Pool0;
 42             _asynchLoader.Start(loaderObject);
 43         }
 44         /// <summary>
 45         /// 列子
 46         /// </summary>
 47         public void StartAsynch2()
 48         {
 49             //下载公共资源信息
 50             LoaderObject loaderObject = new LoaderObject();
 51             loaderObject.Pool = LoaderPool.Pool2;
 52             _asynchLoader.Start(loaderObject);
 53         }
 54         /// <summary>
 55         /// 列子
 56         /// </summary>
 57         public void StartAsynch3()
 58         {
 59             //下载公共资源信息
 60             LoaderObject loaderObject = new LoaderObject();
 61             loaderObject.Pool = LoaderPool.Pool3;
 62             _asynchLoader.Start(loaderObject);
 63         }
 64         #endregion
 65 
 66         #region 异步加载线程方法
 67 
 68         /// <summary>
 69         /// 异步方法
 70         /// </summary>
 71         private void AsynchMeth()
 72         {
 73             Thread.Sleep(1000);
 74 
 75         }
 76         /// <summary>
 77         /// 异步方法
 78         /// </summary>
 79         private void AsynchMeth2()
 80         {
 81             Thread.Sleep(5000);
 82            
 83             
 84         }
 85         /// <summary>
 86         /// 异步方法
 87         /// </summary>
 88         private void AsynchMeth3()
 89         {
 90             Thread.Sleep(10000);
 91             
 92            
 93         }
 94         #endregion
 95 
 96         #region 异步加载完成处理方法
 97         private void AsynchLoadComplete()
 98         {
 99             label1.Text="我是0,我完成了";
100         }
101 
102         private void AsynchLoadComplete2()
103         {
104             label2.Text="我是2我完成了";
105         }
106         private void AsynchLoadComplete3()
107         {
108             label3.Text="我是3 我完成了";
109         }
110         #endregion
111 
112         /// <summary>
113         /// 异步加载数据事件方法
114         /// </summary>
115         /// <param name="loaderObject"></param>
116         private void AsynchLoadData(ref LoaderObject loaderObject)
117         {
118             switch (loaderObject.Pool)
119             {
120                 case LoaderPool.Pool0://更新公共资源
121                     this.AsynchMeth();
122                     break;
123                 case LoaderPool.Pool2://更新公共资源
124                     this.AsynchMeth2();
125                     break;
126                 case LoaderPool.Pool3://更新公共资源
127                     this.AsynchMeth3();
128                     break;
129                
130             }
131         }
132 
133         /// <summary>
134         /// 异步加载数据完成事件方法
135         /// </summary>
136         /// <param name="loaderObject"></param>
137         private void AsynchLoadDataComplete(ref LoaderObject loaderObject)
138         {
139             switch (loaderObject.Pool)
140             {
141                 case LoaderPool.Pool0://更新公共资源完成
142                     AsynchLoadComplete();
143                     break;
144                 case LoaderPool.Pool2://更新公共资源完成
145                     AsynchLoadComplete2();
146                     break;
147                 case LoaderPool.Pool3://更新公共资源完成
148                     AsynchLoadComplete3();
149                     break;
150             }
151         }
152 
153         #endregion
154 
155 
156         private void Form1_Load(object sender, EventArgs e)
157         {
158             //启动加载
159             StartAsynch();
160             StartAsynch2();
161             StartAsynch3();
162            
163         }
164 
165 
166     }
167 }

View Code

  1 using System;
  2 using System.Collections.Generic;
  3 using System.Text;
  4 using System.Threading;
  5 using System.Windows.Forms;
  6 
  7 namespace CommonLibrary.Asynchronous
  8 {
  9     /// <summary>
 10     /// 线程异步读取器
 11     /// </summary>
 12     public class AsynchLoader
 13     {
 14         //当前运行的线程
 15         private Dictionary<int, Thread> _threadList = new Dictionary<int, Thread>();
 16         //父控件
 17         private System.Windows.Forms.Control parentControl;
 18         
 19         /// <summary>
 20         /// 将关联的特定控件
 21         /// </summary>
 22         public System.Windows.Forms.Control ParentControl
 23         {
 24             get { return parentControl; }
 25             set { parentControl = value; }
 26         }
 27 
 28         private Boolean controlThreadManaged = false;
 29         /// <summary>
 30         /// 是否操作特定控件
 31         /// </summary>
 32         public Boolean ControlThreadManaged
 33         {
 34             get { return controlThreadManaged; }
 35             set { controlThreadManaged = value; }
 36         }
 37 
 38         #region 带参方法的调用事件
 39         /// <summary>
 40         /// 带参数方法的委托
 41         /// </summary>
 42         /// <param name="loaderObject"></param>
 43         public delegate void ParameterizedThreadHandler(ref LoaderObject loaderObject);
 44 
 45         /// <summary>
 46         /// 带参方法的调用事件,需要自行处理控件线程操作
 47         /// </summary>
 48         public event ParameterizedThreadHandler InvokeParameterizedMethod;
 49         private void OnInvokeParameterizedMethod(ref LoaderObject loaderObject)
 50         {
 51             if (InvokeParameterizedMethod != null)
 52             {
 53                 InvokeParameterizedMethod(ref loaderObject);
 54             }
 55         }
 56         /// <summary>
 57         /// 带参方法的调用完成事件,需要自行处理控件线程操作
 58         /// </summary>
 59         public event ParameterizedThreadHandler InvokeParameterizedMethodCompleted;
 60         private void OnInvokeParameterizedMethodCompleted(ref LoaderObject loaderObject)
 61         {
 62             if (InvokeParameterizedMethodCompleted != null)
 63             {
 64                 InvokeParameterizedMethodCompleted(ref loaderObject);
 65             }
 66         }
 67         #endregion 带参方法的调用事件
 68 
 69         #region 不带参方法的调用事件
 70         /// <summary>
 71         /// 不带参数方法的委托
 72         /// </summary>
 73         public delegate void ThreadHandler();
 74         /// <summary>
 75         /// 不带参方法的调用事件
 76         /// </summary>
 77         public event ThreadHandler InvokeMethod;
 78         /// <summary>
 79         /// 触发不带参方法的调用事件
 80         /// </summary>
 81         private void OnInvokeMethod()
 82         {
 83             if (InvokeMethod != null)
 84             {
 85                 InvokeMethod();
 86             }
 87         }
 88 
 89         /// <summary>
 90         /// 不带参数的方法的调用完成事件
 91         /// </summary>
 92         public event ThreadHandler InvokeMethodCompleted;
 93         /// <summary>
 94         /// 触发不带参方法的调用完成事件
 95         /// </summary>
 96         private void OnInvokeMethodCompleted()
 97         {
 98             if (InvokeMethodCompleted != null)
 99             {
100                 InvokeMethodCompleted();
101             }
102         }
103 
104         #endregion 不带参方法的调用事件
105 
106         #region 异常事件
107         /// <summary>
108         /// 异常事件
109         /// </summary>
110         public event DelegateException ThrowException;
111         /// <summary>
112         /// 异常事件触发
113         /// </summary>
114         /// <param name="exception">异常对象</param>
115         protected void OnThrowException(Exception exception)
116         {
117             if (ThrowException != null)
118                 ThrowException(exception);
119         }
120         #endregion 异常事件
121 
122         /// <summary>
123         /// 构造器
124         /// </summary>
125         public AsynchLoader()
126         {
127             _threadList = new Dictionary<int, Thread>();
128             controlThreadManaged = false;
129 
130         }
131 
132         /// <summary>
133         /// 构造器
134         /// </summary>
135         public AsynchLoader(Control ownerControl)
136             : base()
137         {
138             _threadList = new Dictionary<int, Thread>();
139             controlThreadManaged = false;
140             parentControl = ownerControl;
141         }
142 
143         /// <summary>
144         /// 析构函数
145         /// </summary>
146         ~AsynchLoader()
147         {
148             AbortAllThread();
149         }
150 
151         /// <summary>
152         ///终止释放所有线程 
153         /// </summary>
154         public void AbortAllThread()
155         {
156             foreach (var th in _threadList.Values)
157             {
158                 if (th.IsAlive)
159                 {
160                     th.Abort();
161                 }                
162             }
163             _threadList.Clear();
164         }
165 
166         /// <summary>
167         ///终止释放指定的线程 
168         /// </summary>
169         public bool AbortThread(int key)
170         {
171             if (_threadList.ContainsKey(key))
172             {
173                 if (_threadList[key].IsAlive)
174                 {
175                     _threadList[key].Abort();
176                     _threadList.Remove(key);
177                     return true;
178                 }                
179             }
180             return false;
181         } 
182 
183         /// <summary>
184         /// 启动无参数线程
185         /// </summary>
186         /// <returns>返回当前启动线程的唯一ID</returns>
187         public int Start()
188         {
189             Thread th = new Thread(new ThreadStart(InvokeMethodInThread));             
190             th.Start();
191             _threadList.Add(th.ManagedThreadId, th);
192             return th.ManagedThreadId;
193         }
194 
195         /// <summary>
196         /// 启动带参数线程
197         /// </summary>
198         /// <param name="obj"></param>
199         /// <returns>返回当前启动线程的唯一ID</returns>
200         public int Start(LoaderObject loaderObject)
201         {
202             Thread th = new Thread(new ParameterizedThreadStart(InvokeParameterizedMethodInThread));
203             th.Start(loaderObject);
204             _threadList.Add(th.ManagedThreadId, th);
205             return th.ManagedThreadId;
206         }
207 
208         private bool RemoveThread(int key)
209         {
210             return _threadList.Remove(key);          
211         }
212 
213         /// <summary>
214         /// 无参数的线程内方法
215         /// </summary>
216         private void InvokeMethodInThread()
217         {
218             try
219             {
220                 //触发不带参数的方法调用事件
221                 try
222                 {
223                     if (controlThreadManaged || parentControl != null && parentControl.IsHandleCreated)
224                     {
225                         parentControl.BeginInvoke(new ThreadHandler(OnInvokeMethod));
226                     }
227                     else
228                     {
229                         OnInvokeMethod();
230                     }
231                 }
232                 catch (Exception ex)
233                 {
234                     
235                     OnThrowException(ex);
236 
237                 }
238                 //触发不带参数的方法调用完成事件
239                 try
240                 {
241                     if (controlThreadManaged || parentControl != null && parentControl.IsHandleCreated)
242                     {
243                         parentControl.BeginInvoke(new ThreadHandler(OnInvokeMethodCompleted));
244                     }
245                     else
246                     {
247                         OnInvokeMethodCompleted();
248                     }
249                 }
250                 catch (Exception ex)
251                 {
252                     
253                     OnThrowException(ex);
254                 }
255             }
256             finally
257             {
258                 //移除当前线程
259                 RemoveThread(Thread.CurrentThread.ManagedThreadId);
260             }
261         }//end method
262 
263         /// <summary>
264         /// 带参数的线程内的方法
265         /// </summary>
266         /// <param name="obj"></param>
267         private void InvokeParameterizedMethodInThread(object obj)
268         {
269             LoaderObject loaderObject = obj as LoaderObject;
270             try
271             {
272                 //触发带参数的方法调用事件
273                 try
274                 {
275                     //if (controlThreadManaged || parentControl != null && parentControl.IsHandleCreated)
276                     //{
277                     //    parentControl.BeginInvoke(new ParameterizedThreadHandler(OnInvokeParameterizedMethod), new object[] { loaderObject });
278                     //}
279                     //else
280                     //{
281                     //    OnInvokeParameterizedMethod(ref loaderObject);
282                     //}
283                     OnInvokeParameterizedMethod(ref loaderObject);
284 
285 
286                 }
287                 catch (Exception ex)
288                 {
289                    
290                     OnThrowException(ex);
291 #if DEBUG
292                     throw ex;
293 #endif
294                 }
295                 //触发带参数的方法调用完成事件
296                 try
297                 {
298                     if (controlThreadManaged || parentControl != null && parentControl.IsHandleCreated)
299                     {
300                         parentControl.BeginInvoke(new ParameterizedThreadHandler(OnInvokeParameterizedMethodCompleted), new object[] { loaderObject });
301                     }
302                     else
303                     {
304                         OnInvokeParameterizedMethodCompleted(ref loaderObject);
305                     }
306                 }
307                 catch (Exception ex)
308                 {
309                    
310                     OnThrowException(ex);
311                 }
312             }
313             finally
314             {
315                 //移除当前线程
316                 RemoveThread(Thread.CurrentThread.ManagedThreadId);
317             }
318         }//end method
319 
320     }//end class
321 }//end namespace

View Code

 1 using System;
 2 using System.Collections.Generic;
 3 using System.Text;
 4 
 5 namespace CommonLibrary.Asynchronous
 6 {
 7 
 8     /// <summary>
 9     /// 识别读取池(一般默认为Pool0，在同一界面中使用多个线程控制时可以使用)
10     /// </summary>
11     public enum LoaderPool
12     {
13         Pool0,
14         Pool1,
15         Pool2,
16         Pool3,
17         Pool4,
18         Pool5,
19         Pool6,
20         Pool7,
21         Pool8,
22         Pool9
23     }
24 
25     /// <summary>
26     /// 异步读取器对象
27     /// </summary>
28     public class LoaderObject
29     {
30         /// <summary>
31         /// 数据对象
32         /// </summary>
33         private object _obj = new object();
34         /// <summary>
35         /// 数据对象
36         /// </summary>
37         public object Obj
38         {
39             get
40             {
41                 return _obj;
42             }
43             set
44             {
45                 _obj = value;
46             }
47         }
48 
49         /// <summary>
50         /// 异步池(一般默认为pool0，在同一界面中使用多个线程控制时可以使用)
51         /// </summary>
52         private LoaderPool _pool = LoaderPool.Pool0;
53         /// <summary>
54         /// 异步池(一般默认为pool0，在同一界面中使用多个线程控制时可以使用)
55         /// </summary>
56         public LoaderPool Pool
57         {
58             get
59             {
60                 return _pool;
61             }
62             set
63             {
64                 _pool = value;
65             }
66         }
67         /// <summary>
68         /// 数据对象
69         /// </summary>
70         private object _data;
71         /// <summary>
72         /// 数据对象
73         /// </summary>
74         public object Data
75         {
76             get
77             {
78                 return _data;
79             }
80             set
81             {
82                 _data = value;
83             }
84         }
85     }
86 }

View Code

 1 using System;
 2 using System.Collections.Generic;
 3 using System.Text;
 4 
 5 namespace CommonLibrary.Asynchronous
 6 {
 7     /// <summary>
 8     /// 异常委托
 9     /// </summary>
10     /// <param name="exception">异常对象</param>
11     public delegate void DelegateException(Exception exception);
12 
13     /// <summary>
14     /// 提示信息委托
15     /// </summary>
16     /// <param name="hintInformation">提示信息</param>
17     public delegate void DelegateHintInformation(string hintInformation);
18 
19     class SystemUtils
20     {
21     }
22 }