[★]WinForm中，主线程如何优雅的控制子线程?
在Winform界面中，为了客户的体验或者其他原因，我们总是将耗时的事务在另外新开的线程中进行操作，那么对于这些线程的控制，涉及到下面的这些情况，各位都是用什么方法解决呢?
1. 启动线程；
2. 线程间通讯；
3. 线程终止；
4. 线程中的异常处理；
欢迎大家一起讨论下，我发现在这块现在感觉很难驾驭。
当然，如果还有其他没有提到的，还请兄弟们直接给出。多谢！
————————————————————————————————
BTW：这个坛子里面的搜索现在很难用，我没有办法找到我想要的信息，不知道各位是否有同样的问题?
[解决办法]
● 如果是需要很频繁的开线程，会使用线程池（微软的或自己写的），目前我用自己写的
● 对于线程间的通信，主要是通过线程同步或者回调方法（或者说是委托）来实现
● 线程的终止，用事件AUTORESET之类
● 线程中的异常通过事件传回到主线程处理或者是写错误日志便于进一步跟踪问题
[解决办法]
委托
[解决办法]
参考愚翁专栏文章CSDN第一期总结之三：Thread的问题
[解决办法]
好文章
[解决办法]
灌水
[解决办法]
委托安全调用
用BackgroundWorker控件
参考
参考
[解决办法]
顶下
[解决办法]
关注中，多线程的确不好搞，期待大师指点。
[解决办法]
mark
[解决办法]
mark up
[解决办法]
顶
using System;
using System.Threading;
using System.Collections;
using System.Collections.Generic;
public class SyncEvents
{
public SyncEvents()
{
_newItemEvent = new AutoResetEvent(false);
_exitThreadEvent = new ManualResetEvent(false);
_eventArray = new WaitHandle[2];
_eventArray[0] = _newItemEvent;
_eventArray[1] = _exitThreadEvent;
}
public EventWaitHandle ExitThreadEvent
{
get { return _exitThreadEvent; }
}
public EventWaitHandle NewItemEvent
{
get { return _newItemEvent; }
}
public WaitHandle[] EventArray
{
get { return _eventArray; }
}
private EventWaitHandle _newItemEvent;
private EventWaitHandle _exitThreadEvent;
private WaitHandle[] _eventArray;
}
public class Producer
{
public Producer(Queue <int> q, SyncEvents e)
{
_queue = q;
_syncEvents = e;
}
// Producer.ThreadRun
public void ThreadRun()
{
int count = 0;
Random r = new Random();
while (!_syncEvents.ExitThreadEvent.WaitOne(0, false))
{
lock (((ICollection)_queue).SyncRoot)
{
while (_queue.Count < 20)
{
_queue.Enqueue(r.Next(0,100));
_syncEvents.NewItemEvent.Set();
count++;
}
}
}
Console.WriteLine("Producer thread: produced {0} items", count);
}
private Queue <int> _queue;
private SyncEvents _syncEvents;
}
public class Consumer
{
public Consumer(Queue <int> q, SyncEvents e)
{
_queue = q;
_syncEvents = e;
}
// Consumer.ThreadRun
public void ThreadRun()
{
int count = 0;
while (WaitHandle.WaitAny(_syncEvents.EventArray) != 1)
{
lock (((ICollection)_queue).SyncRoot)
{
int item = _queue.Dequeue();
}
count++;
}
Console.WriteLine("Consumer Thread: consumed {0} items", count);
}
private Queue <int> _queue;
private SyncEvents _syncEvents;
}
public class ThreadSyncSample
{
private static void ShowQueueContents(Queue <int> q)
{
lock (((ICollection)q).SyncRoot)
{
foreach (int item in q)
{
Console.Write("{0} ", item);
}
}
Console.WriteLine();
}
static void Main()
{
Queue <int> queue = new Queue <int>();
SyncEvents syncEvents = new SyncEvents();
Console.WriteLine("Configuring worker threads...");
Producer producer = new Producer(queue, syncEvents);
Consumer consumer = new Consumer(queue, syncEvents);
Thread producerThread = new Thread(producer.ThreadRun);
Thread consumerThread = new Thread(consumer.ThreadRun);
Console.WriteLine("Launching producer and consumer threads...");
producerThread.Start();
consumerThread.Start();
for (int i=0; i <4; i++)
{
Thread.Sleep(2500);
ShowQueueContents(queue);
}
Console.WriteLine("Signaling threads to terminate...");
syncEvents.ExitThreadEvent.Set();
producerThread.Join();
consumerThread.Join();
}
}
