resetevent
c#线程学习之ManualResetEvent和AutoResetEvent的区别
我理解线程间通讯问题接收a候主线程创建新线程运行函数(比叫WorkRun)新线程（比叫thA）运行主线程接收b需要通知thA使止或改变其运行逻辑
启线程写：
Thread thA = new Thread(new ThreadStart(WorkRun));
thA.Start();
事实两种能场景第种主线程向thA发送止线程指令让函数止执行；另种函数执行某点候停等待主线程给信号决定该执行逻辑
1. 止线程需要接收b候写
if(thA.ThreadState == ThreadState.Running)
{
thA.Abort();
}
2. 需要运行停等待主线程指令使用ManualResetEventManualResetEvent 允许线程通发信号互相通信通通信涉及线程其线程进行前必须完任务
线程始（必须完其线程才能始）调用 Reset ManualResetEvent 置于非终止状态线程视控制 ManualResetEvent调用 ManualResetEvent WaitOne 线程阻止并等待信号控制线程完调用 Set 发等待线程继续进行信号并释放所等待线程
旦终止ManualResetEvent 保持终止状态直手重置即 WaitOne 调用立即返
通布尔值传递给构造函数控制 ManualResetEvent 初始状态初始状态处于终止状态 true；否则 false
ManualResetEvent 同 staticWaitAll WaitAny 起使用
实例（面代码示例阐释何使用等待句柄发送复杂数字计算同阶段完信号计算格式：结 = 第项 + 第二项 + 第三项其每项都要求使用计算基数进行预计算终计算）：
using System;
using System.Threading;
class CalculateTest
{
static void Main()
{
Calculate calc = new Calculate();
Console.WriteLine("Result = .",
calc.Result(234).ToString());
Console.WriteLine("Result = .",
calc.Result(55).ToString());
}
}
class Calculate
{
double baseNumber, firstTerm, secondTerm, thirdTerm;
AutoResetEvent[] autoEvents;
ManualResetEvent manualEvent;
// Generate random numbers to simulate the actual calculations.
Random randomGenerator;
public Calculate()
{
autoEvents = new AutoResetEvent[]
{
new AutoResetEvent(false),
new AutoResetEvent(false),
new AutoResetEvent(false)
};
manualEvent = new ManualResetEvent(false);
}
void CalculateBase(object stateInfo)
{
baseNumber = randomGenerator.NextDouble();
// Signal that baseNumber is ready.
manualEvent.Set();
}
// The following CalculateX methods all perform the same
// series of steps as commented in CalculateFirstTerm.
void CalculateFirstTerm(object stateInfo)
{
// Perform a precalculation.
double preCalc = randomGenerator.NextDouble();
// Wait for baseNumber to be calculated.
manualEvent.WaitOne();
// Calculate the first term from preCalc and baseNumber.
firstTerm = preCalc * baseNumber *
randomGenerator.NextDouble();
// Signal that the calculation is finished.
autoEvents[0].Set();
}
void CalculateSecondTerm(object stateInfo)
{
double preCalc = randomGenerator.NextDouble();
manualEvent.WaitOne();
secondTerm = preCalc * baseNumber *
randomGenerator.NextDouble();
autoEvents[1].Set();
}
void CalculateThirdTerm(object stateInfo)
{
double preCalc = randomGenerator.NextDouble();
manualEvent.WaitOne();
thirdTerm = preCalc * baseNumber *
randomGenerator.NextDouble();
autoEvents[2].Set();
}
public double Result(int seed)
{
randomGenerator = new Random(seed);
// Simultaneously calculate the terms.
ThreadPool.QueueUserWorkItem(
new WaitCallback(CalculateBase));
ThreadPool.QueueUserWorkItem(
new WaitCallback(CalculateFirstTerm));
ThreadPool.QueueUserWorkItem(
new WaitCallback(CalculateSecondTerm));
ThreadPool.QueueUserWorkItem(
new WaitCallback(CalculateThirdTerm));
// Wait for all of the terms to be calculated.
WaitHandle.WaitAll(autoEvents);
// Reset the wait handle for the next calculation.
manualEvent.Reset();
return firstTerm + secondTerm + thirdTerm;
}
}
C#里 有关线程 ManualResetEvent的问题
我的理解这是一个线程间通讯的问题，接收到a的时候主线程创建一个新的线程，运行的函数(比如叫WorkRun方法)在新线程（比如叫thA）中运行，当主线程接收到b时需要通知thA使他中止或改变其运行逻辑。
启动线程的写法：
Thread thA = new Thread(new ThreadStart(WorkRun));
thA.Start();
事实上，只有两种可能的场景，第一种是主线程向thA发送中止线程指令，让函数中止执行；另一种是函数在执行到某一个点的时候停下来等待主线程给他一个信号来决定该执行怎样的逻辑。
1. 如果是中止线程的话，只需要在接收到b的时候写
if(thA.ThreadState == ThreadState.Running)
{
thA.Abort();
}
2. 如果需要在运行中停下来等待主线程指令的话，使用ManualResetEvent，ManualResetEvent 允许线程通过发信号互相通信。通常，此通信涉及一个线程在其他线程进行之前必须完成的任务。
当一个线程开始一个活动（此活动必须完成后，其他线程才能开始）时，它调用 Reset 以将 ManualResetEvent 置于非终止状态。此线程可被视为控制 ManualResetEvent。调用 ManualResetEvent 上的 WaitOne 的线程将阻止，并等待信号。当控制线程完成活动时，它调用 Set 以发出等待线程可以继续进行的信号。并释放所有等待线程。
一旦它被终止，ManualResetEvent 将保持终止状态，直到它被手动重置。即对 WaitOne 的调用将立即返回。
可以通过将布尔值传递给构造函数来控制 ManualResetEvent 的初始状态，如果初始状态处于终止状态，为 true；否则为 false。
ManualResetEvent 也可以同 staticWaitAll 和 WaitAny 方法一起使用。
以下为实例（下面的代码示例阐释了如何使用等待句柄来发送复杂数字计算的不同阶段的完成信号。计算的格式为：结果 = 第一项 + 第二项 + 第三项，其中每一项都要求使用计算出的基数进行预计算和最终计算。）：
using System;
using System.Threading;
class CalculateTest
{
static void Main()
{
Calculate calc = new Calculate();
Console.WriteLine("Result = .",
calc.Result(234).ToString());
Console.WriteLine("Result = .",
calc.Result(55).ToString());
}
}
class Calculate
{
double baseNumber, firstTerm, secondTerm, thirdTerm;
AutoResetEvent[] autoEvents;
ManualResetEvent manualEvent;
// Generate random numbers to simulate the actual calculations.
Random randomGenerator;
public Calculate()
{
autoEvents = new AutoResetEvent[]
{
new AutoResetEvent(false),
new AutoResetEvent(false),
new AutoResetEvent(false)
};
manualEvent = new ManualResetEvent(false);
}
void CalculateBase(object stateInfo)
{
baseNumber = randomGenerator.NextDouble();
// Signal that baseNumber is ready.
manualEvent.Set();
}
// The following CalculateX methods all perform the same
// series of steps as commented in CalculateFirstTerm.
void CalculateFirstTerm(object stateInfo)
{
// Perform a precalculation.
double preCalc = randomGenerator.NextDouble();
// Wait for baseNumber to be calculated.
manualEvent.WaitOne();
// Calculate the first term from preCalc and baseNumber.
firstTerm = preCalc * baseNumber *
randomGenerator.NextDouble();
// Signal that the calculation is finished.
autoEvents[0].Set();
}
void CalculateSecondTerm(object stateInfo)
{
double preCalc = randomGenerator.NextDouble();
manualEvent.WaitOne();
secondTerm = preCalc * baseNumber *
randomGenerator.NextDouble();
autoEvents[1].Set();
}
void CalculateThirdTerm(object stateInfo)
{
double preCalc = randomGenerator.NextDouble();
manualEvent.WaitOne();
thirdTerm = preCalc * baseNumber *
randomGenerator.NextDouble();
autoEvents[2].Set();
}
public double Result(int seed)
{
randomGenerator = new Random(seed);
// Simultaneously calculate the terms.
ThreadPool.QueueUserWorkItem(
new WaitCallback(CalculateBase));
ThreadPool.QueueUserWorkItem(
new WaitCallback(CalculateFirstTerm));
ThreadPool.QueueUserWorkItem(
new WaitCallback(CalculateSecondTerm));
ThreadPool.QueueUserWorkItem(
new WaitCallback(CalculateThirdTerm));
// Wait for all of the terms to be calculated.
WaitHandle.WaitAll(autoEvents);
// Reset the wait handle for the next calculation.
manualEvent.Reset();
return firstTerm + secondTerm + thirdTerm;
}
}
manualresetevent和autoresetevent的区别
搜索来的，不知道能否帮上你
在讨论这个问题之前，我们先了解这样一种观点，线程之间的通信是通过发信号来进行沟通的。(这不是废话)
先来讨论ManualResetEvent，讨论过程中我会穿插一些AutoResetEvent的内容，来做对比:
ManualResetEvent都可以阻塞一个或多个线程,直到收到一个信号告诉ManualResetEvent不要再阻塞当前的线程。
可以想象ManualResetEvent这个对象内部有一个Boolean类型的属性IsRelease来控制是否要阻塞当前线程。这个属性我们在初始化的时候可以设置它，如ManualResetEvent event=new ManualResetEvent(false);这就表明默认的属性是要阻塞当前线程。
代码举例：
ManualResetEvent _manualResetEvent = new ManualResetEvent(false);
private void BT_Temp_Click(object sender, RoutedEventArgs e)
{
Thread t1 = new Thread(this.Thread1Foo);
t1.Start(); //启动线程1
Thread t2 = new Thread(this.Thread2Foo);
t2.Start(); //启动线程2
Thread.Sleep(3000); //睡眠当前主线程，即调用BT_Temp_Click的线程
_manualResetEvent .Set(); //想象成将IsRelease设为True
}
void Thread1Foo()
{
_manualResetEvent .WaitOne();
//阻塞线程1，直到主线程发信号给线程1,告知_menuResetEvent你的IsRelease属性已经为true，
//这时不再阻塞线程1,程序继续往下跑
MessageBox.Show("t1 end");
}
void Thread2Foo()
{
_manualResetEvent .WaitOne();
//阻塞线程2，直到主线程发信号给线程1,告知_menuResetEvent你的IsRelease属性已经为true，
//这时不再阻塞线程2,程序继续往下跑
MessageBox.Show("t2 end");
}
注意这里ManualResetEvent和AutoResetEvent的一个重要区别：
manual的话肯定会给线程1和线程2都发送一个信号，而auto只会随机给其中一个发送信号。
为什么一个叫manual而一个叫auto呢？我想这是很多人的疑问，现在我们就来看这个问题。
刚才_manualResetEvent .Set();的这句话我想大家都明白了，可以看做将IsRelease的属性设置为true.线程1中
_manualResetEvent.WaitOne();接收到信号后不再阻塞线程1。在此之后的整个过程中IsRelease的值都是true.如果
想将IsRelease的值回复成false,就必须再调用_manualResetEvent.Reset()的方法。
如果是_autoResetEvent.set(),那么_autoResetEvent.WaitOne()后会自动将IsRelease的值自动设置为false.
这就是为什么一个叫auto,一个叫manual.
C#AutoResetEvent和ManualResetEvent的区别
C#中的AutoResetEvent和ManualResetEvent用于实现线程同步。其基本工作原理是多个线程持有同一个XXXResetEvent，在这个XXXResetEvent未被set前，各线程都在WaitOne()除挂起；在这个XXXResetEvent被set后，所有被挂起的线程中有一个（AutoResetEvent的情况下）或全部（ManualResetEvent的情况下）恢复执行。
AutoResetEvent与ManualResetEvent的差别在于某个线程在WaitOne()被挂起后重新获得执行权时，是否自动reset这个事件(Event)，前者是自动reset的，后者不是。所以从这个角度上也可以解释上段提到的“在这个XXXResetEvent被set后，所有被挂起的线程中有一个（AutoResetEvent的情况下）或全部（ManualResetEvent的情况下）恢复执行”——因为前者一旦被某个线程获取后，立即自动reset这个事件(Event)，所以其他持有前者的线程之后WaitOne()时又被挂起；而后者被某个获取后，不会自动reset这个事件(Event)，所以后续持有后者的线程在WaitOne()时不会被挂起。
namespace AutoResetEvent_Examples {
class MyMainClass {
/*
* 构造方法的参数设置成false后，表示创建一个没有被set的AutoResetEvent
* 这就导致所有持有这个AutoResetEvent的线程都会在WaitOne()处挂起
* 此时如果挂起的线程数比较多，那么你看一下自己的内存使用量……。
* 如果将参数设置成true，表示创建一个被set的AutoResetEvent
* 持有这个AutoResetEvent的线程们会竞争这个Event
* 此时，在其他条件满足的情况下
* 至少会有一个线程得到执行
* 而不是因得不到Event而导致所有线程都得不到执行
*/
static AutoResetEvent myResetEvent = new AutoResetEvent(false);
static int _Count = 0;
static void Main() {
Thread myThread = null;
for(int i = 0;i < 100;i++) {
myThread = new Thread(new ThreadStart(MyThreadProc));
myThread.Name = "Thread" + i;
myThread.Start();
}
myResetEvent.Set();
Console.Read();
}
static void MyThreadProc() {
myResetEvent.WaitOne();
_Count++;
Console.WriteLine("In thread:{0},label={1}.",Thread.CurrentThread.Name,_Count);
myResetEvent.Set();
}
}
}
namespace ManualResetEvent_Examples {
class MyMainClass {
/*
* 构造方法的参数设置成false后，表示创建一个没有被set的ManualResetEvent
* 这就导致所有持有这个ManualResetEvent的线程都会在WaitOne()处挂起
* 此时如果挂起的线程数比较多，那么你看一下自己的内存使用量……。
* 如果将参数设置成true，表示创建一个被set的ManualResetEvent
* 持有这个ManualResetEvent的线程们在其他条件满足的情况下
* 会同时得到执行（注意，是同时得到执行！所以本例中的_Count的结果一般是不正确的^_^）
* 而不是因得不到Event而导致所有线程都得不到执行
*/
static ManualResetEvent myResetEvent = new ManualResetEvent(false);
static int _Count = 0;
static void Main() {
Thread myThread = null;
for(int i = 0;i < 1000;i++) {
myThread = new Thread(new ThreadStart(MyThreadProc));
myThread.Name = "Thread" + i;
myThread.Start();
}
myResetEvent.Set();
Console.Read();
}
static void MyThreadProc() {
myResetEvent.WaitOne();
_Count++;
/*
* 在new ManualResetEvent(false);的情况下
* 下面的输出结果可能比较诡异：多个线程都输出label=1000！
* 一种可能的原因是多个线程在各自执行到_Count++后，被挂起
* 随后打印的_Count值就不是本线程中刚刚修改过的_Count值了。
*/
Console.WriteLine("In thread:{0},_Count={1}.",Thread.CurrentThread.Name,_Count);
}
}
}
set是让事件(Event)发生，而reset是让事件(Event)复位或者说忽略已经的事件(Event)。WaitOne是等待事件(Event)的发生，之后继续向下执行，否则一直等待。
在构造AutoResetEvent和ManualResetEvent的时候，它们的构造方法里需要一个参数initState，中文版MSDN（2005和2008）上的解释是“若要将初始状态设置为终止，则为 true；若要将初始状态设置为非终止，则为false。”，我看了一个下午，没弄明白，而看一下英文版后大概就明白了“A value that you set totrueto set the initial state of the specified event to signaled. Set this value tofalseto set the initial state of the event to nonsignaled.”（参见：http://msdn.microsoft.com/en-us/library/ee432364.aspx），大体意思是说这个参数决定是否在构造这个Event的时候就设置它为“发生”状态（signaled），如果是，则设置为true，也就是说持有这个Event的一个或多个线程在一开始就可以执行，而不需要挂起，至少是不会全部挂起（持有AutoResetEvent的一个或多个线程在任意时刻至多有一个线程在执行；持有ManualResetEvent的一个或多个线程会同时执行），否则为false（持有AutoResetEvent和ManualResetEvent的所有线程都将挂起，因为事件(Event)没有被set，即事件没有发生）。
另外稍微提一下，我在做多线程测试的时候，发现在线程数少的情况下，即使多个线程不做任何同步，如果对一个公共变量进行非互斥式修改时，不会至少很难出现不一致的情况，比如开100个线程，这个线程不做任何同步就分别给一个公共变量执行加1操作，那么结果在绝绝绝大部分的情况下是100！所以，我最后就下了狠心，把线程数增加到1000个，这个时候才出现问题，但问题也不是想象得那么严重——结果在991-1000之间！
再有，MSDN上对Monitor的Wait和Pulse两个方法用法的举例会导致死锁，一种死锁的执行顺序是：
1、线程tSecond在SecondThread()中执行到while(Monitor.Wait(m_smplQueue,1000))后，释放m_smplQueue的锁，线程tSecond挂起；
2、线程tFirst在FirstThread()中执行到Monitor.Wait(m_smplQueue)之前耗费的时间超过1000毫秒，此时线程tSecond退出，线程tFirst挂起，并且从此以后不会被恢复！
可以使用如下改动过的代码验证：
public void FirstThread() {
int counter = 0;
lock(m_smplQueue) {
Console.WriteLine("11");
while(counter < MAX_LOOP_TIME) {
//Wait, if the queue is busy.
Console.WriteLine("12");
Monitor.Wait(m_smplQueue);
Console.WriteLine("13");
//Push one element.
m_smplQueue.Enqueue(counter);
Console.WriteLine("14");
//Release the waiting thread.
Monitor.Pulse(m_smplQueue);
Console.WriteLine("15");
counter++;
Console.WriteLine("16");
}
}
}
public void SecondThread() {
lock(m_smplQueue) {
Console.WriteLine("21");
//Release the waiting thread.
Monitor.Pulse(m_smplQueue);
Console.WriteLine("22");
//Wait in the loop, while the queue is busy.
//Exit on the time-out when the first thread stops.
while(Monitor.Wait(m_smplQueue,1000)) {
Console.WriteLine("23");
//Pop the first element.
int counter = (int) m_smplQueue.Dequeue();
Console.WriteLine("24");
//Print the first element.
Console.WriteLine(counter.ToString());
Console.WriteLine("25");
//Release the waiting thread.
Monitor.Pulse(m_smplQueue);
Console.WriteLine("26");
}
Console.WriteLine("27");
}
}
c#线程学习之ManualResetEvent和AutoResetEvent的区别
先来讨论ManualResetEvent，讨论过程中我会穿插一些AutoResetEvent的内容，来做对比:
ManualResetEvent都可以阻塞一个或多个线程,直到收到一个信号告诉ManualResetEvent不要再阻塞当前的线程。
可以想象ManualResetEvent这个对象内部有一个Boolean类型的属性IsRelease来控制是否要阻塞当前线程。这个属性我们在初始化的时候可以设置它，如ManualResetEvent event=new ManualResetEvent(false);这就表明默认的属性是要阻塞当前线程。
代码举例：
ManualResetEvent _manualResetEvent = new ManualResetEvent(false);
private void BT_Temp_Click(object sender, RoutedEventArgs e)
{
Thread t1 = new Thread(this.Thread1Foo);
t1.Start(); //启动线程1
Thread t2 = new Thread(this.Thread2Foo);
t2.Start(); //启动线程2
Thread.Sleep(3000); //睡眠当前主线程，即调用BT_Temp_Click的线程
_manualResetEvent .Set(); //想象成将IsRelease设为True
}
void Thread1Foo()
{
_manualResetEvent .WaitOne();
//阻塞线程1，直到主线程发信号给线程1,告知_menuResetEvent你的IsRelease属性已经为true，
//这时不再阻塞线程1,程序继续往下跑
MessageBox.Show("t1 end");
}
void Thread2Foo()
{
_manualResetEvent .WaitOne();
//阻塞线程2，直到主线程发信号给线程1,告知_menuResetEvent你的IsRelease属性已经为true，
//这时不再阻塞线程2,程序继续往下跑
MessageBox.Show("t2 end");
}
注意这里ManualResetEvent和AutoResetEvent的一个重要区别：
manual的话肯定会给线程1和线程2都发送一个信号，而auto只会随机给其中一个发送信号。
为什么一个叫manual而一个叫auto呢？我想这是很多人的疑问，现在我们就来看这个问题。
刚才_manualResetEvent .Set();的这句话我想大家都明白了，可以看做将IsRelease的属性设置为true.线程1中
_manualResetEvent.WaitOne();接收到信号后不再阻塞线程1。在此之后的整个过程中IsRelease的值都是true.如果
想将IsRelease的值回复成false,就必须再调用_manualResetEvent.Reset()的方法。
如果是_autoResetEvent.set(),那么_autoResetEvent.WaitOne()后会自动将IsRelease的值自动设置为false.
这就是为什么一个叫auto,一个叫manual.
python多线程的几种方法
Python进阶(二十六)-多线程实现同步的四种方式
临界资源即那些一次只能被一个线程访问的资源，典型例子就是打印机，它一次只能被一个程序用来执行打印功能，因为不能多个线程同时操作，而访问这部分资源的代码通常称之为临界区。
锁机制
threading的Lock类，用该类的acquire函数进行加锁，用realease函数进行解锁
import threadingimport timeclass Num:
def __init__(self):
self.num = 0
self.lock = threading.Lock() def add(self):
self.lock.acquire()#加锁，锁住相应的资源
self.num += 1
num = self.num
self.lock.release()#解锁，离开该资源
return num
n = Num()class jdThread(threading.Thread):
def __init__(self,item):
threading.Thread.__init__(self)
self.item = item def run(self):
time.sleep(2)
value = n.add()#将num加1，并输出原来的数据和+1之后的数据
print(self.item,value)for item in range(5):
t = jdThread(item)
t.start()
t.join()#使线程一个一个执行12345678910111213141516171819202122232425262728
当一个线程调用锁的acquire()方法获得锁时，锁就进入“locked”状态。每次只有一个线程可以获得锁。如果此时另一个线程试图获得这个锁，该线程就会变为“blocked”状态，称为“同步阻塞”（参见多线程的基本概念）。
直到拥有锁的线程调用锁的release()方法释放锁之后，锁进入“unlocked”状态。线程调度程序从处于同步阻塞状态的线程中选择一个来获得锁，并使得该线程进入运行（running）状态。
信号量
信号量也提供acquire方法和release方法，每当调用acquire方法的时候，如果内部计数器大于0，则将其减1，如果内部计数器等于0，则会阻塞该线程，知道有线程调用了release方法将内部计数器更新到大于1位置。
import threadingimport timeclass Num:
def __init__(self):
self.num = 0
self.sem = threading.Semaphore(value = 3) #允许最多三个线程同时访问资源
def add(self):
self.sem.acquire()#内部计数器减1
self.num += 1
num = self.num
self.sem.release()#内部计数器加1
return num
n = Num()class jdThread(threading.Thread):
def __init__(self,item):
threading.Thread.__init__(self)
self.item = item def run(self):
time.sleep(2)
value = n.add()
print(self.item,value)for item in range(100):
多线程问题，挂起和恢复
有必要这样构架么？多线程操作同张表。
有必要就往下看：
SQL本身有挂起功能，如果你添加到SQL消息队列，它是不会造成冲突。
唯一的原因是因为你声明了多个连接，每个线程都是通过一个独立
的口连过去。只做一个环境配置，和实例化一个连接类就可以解决
冲突问题。
线程你也没有说是前台还是后台，前台的话，你按顺序排就得了。
后台的话一般是作为并行线程，你只有通过链表结构加起来。
不推荐这样搞，逻辑复杂度很高
c# .net 的System.Threading.Timer 怎么实现每10分钟启动一次 线程？
1）定义TimerSystem.Threading.Timer timer = new System.Thread.Timer( MyTimerCallback, //定时回调函数 null, Timeout.Infinite, 10*60*1000);2）在定时回调函数中void MyTimerCallback(object o){ // (要定时执行的代码写在这里) timer.Change(Timeout.Infinite, 60*10 *1000); //<--每10分钟启动一次！}
System.Threading.Timer 在什么情况下会悄无声息的“终止”
//Timer构造函数参数说明：
1、Callback：一个 TimerCallback 委托，表示要执行的方法。
2、State：一个包含回调方法要使用的信息的对象，或者为空引用（Visual Basic 中为 Nothing）。
3、dueTime：调用 callback 之前延迟的时间量（以毫秒为单位）。指定 Timeout.Infinite 以防止计时器开始计时。指定零 (0) 以立即启动计时器。
4、Period：调用 callback 的时间间隔（以毫秒为单位）。指定 Timeout.Infinite 可以禁用定期终止。
java多线程有几种实现方法
java中实现多线程常用的方法有以下三种：/** * 方法一：继承Thread类，重写run方法 * * @author qd * */public class MyThread extends Thread { @Override public void run() { super.run(); }}/** * 方法二：实现Runnable接口，，重写run方法 * * @author qd * */class MyThread1 implements Runnable { @Override public void run() { }}/** * 方法三：实现Callable接口，重写call方法 * 优点：可以传参数，有返回值类型（参数与返回值类型一致） * * @author qd * */class MyThread2 implements Callable { @Override public Integer call() throws Exception { return null; }}
c#多线程有几种实现方法
这篇文章主要介绍了c#使用多线程的几种方式,通过示例学习c#的多线程使用方式，大家参考使用吧
(1)不需要传递参数,也不需要返回参数
ThreadStart是一个委托，这个委托的定义为void ThreadStart()，没有参数与返回值。
复制代码 代码如下:
class Program
{
static void Main(string[] args)
{
for (int i = 0; i < 30; i++)
{
ThreadStart threadStart = new ThreadStart(Calculate);
Thread thread = new Thread(threadStart);
thread.Start();
}
Thread.Sleep(2000);
Console.Read();
}
public static void Calculate()
{
DateTime time = DateTime.Now;//得到当前时间
Random ra = new Random();//随机数对象
Thread.Sleep(ra.Next(10,100));//随机休眠一段时间
Console.WriteLine(time.Minute + ":" + time.Millisecond);
}
}
(2)需要传递单个参数
ParameterThreadStart委托定义为void ParameterizedThreadStart(object state)，有一个参数但是没有返回值。
复制代码 代码如下:
class Program
{
static void Main(string[] args)
{
for (int i = 0; i < 30; i++)
{
ParameterizedThreadStart tStart = new ParameterizedThreadStart(Calculate);
Thread thread = new Thread(tStart);
thread.Start(i*10+10);//传递参数
}
Thread.Sleep(2000);
Console.Read();
}
public static void Calculate(object arg)
{
Random ra = new Random();//随机数对象
Thread.Sleep(ra.Next(10, 100));//随机休眠一段时间
Console.WriteLine(arg);
}
}
(3)使用专门的线程类(常用)
使用线程类可以有多个参数与多个返回值，十分灵活！
复制代码 代码如下:
class Program
{
static void Main(string[] args)
{
MyThread mt = new MyThread(100);
ThreadStart threadStart = new ThreadStart(mt.Calculate);
Thread thread = new Thread(threadStart);
thread.Start();
//等待线程结束
while (thread.ThreadState != ThreadState.Stopped)
{
Thread.Sleep(10);
}
Console.WriteLine(mt.Result);//打印返回值
Console.Read();
}
}
public class MyThread//线程类
{
public int Parame { set; get; }//参数
public int Result { set; get; }//返回值
//构造函数
public MyThread(int parame)
{
this.Parame = parame;
}
//线程执行方法
public void Calculate()
{
Random ra = new Random();//随机数对象
Thread.Sleep(ra.Next(10, 100));//随机休眠一段时间
Console.WriteLine(this.Parame);
this.Result = this.Parame * ra.Next(10, 100);
}
}
(4)使用匿名方法(常用)
使用匿名方法启动线程可以有多个参数和返回值，而且使用非常方便！
复制代码 代码如下:
class Program
{
static void Main(string[] args)
{
int Parame = 100;//当做参数
int Result = 0;//当做返回值
//匿名方法
ThreadStart threadStart = new ThreadStart(delegate()
{
Random ra = new Random();//随机数对象
Thread.Sleep(ra.Next(10, 100));//随机休眠一段时间
Console.WriteLine(Parame);//输出参数
Result = Parame * ra.Next(10, 100);//计算返回值
});
Thread thread = new Thread(threadStart);
thread.Start();//多线程启动匿名方法
//等待线程结束
while (thread.ThreadState != ThreadState.Stopped)
{
Thread.Sleep(10);
}
Console.WriteLine(Result);//打印返回值
Console.Read();
}
}
(5)使用委托开启多线程(多线程深入)
1、用委托(Delegate)的BeginInvoke和EndInvoke方法操作线程
BeginInvoke方法可以使用线程异步地执行委托所指向的方法。然后通过EndInvoke方法获得方法的返回值（EndInvoke方法的返回值就是被调用方法的返回值），或是确定方法已经被成功调用。
复制代码 代码如下:
class Program
{
private delegate int NewTaskDelegate(int ms);
private static int newTask(int ms)
{
Console.WriteLine("任务开始");
Thread.Sleep(ms);
Random random = new Random();
int n = random.Next(10000);
Console.WriteLine("任务完成");
return n;
}
static void Main(string[] args)
{
NewTaskDelegate task = newTask;
IAsyncResult asyncResult = task.BeginInvoke(2000, null, null);
//EndInvoke方法将被阻塞2秒
int result = task.EndInvoke(asyncResult);
Console.WriteLine(result);
Console.Read();
}
}
2、使用IAsyncResult.IsCompleted属性来判断异步调用是否完成
复制代码 代码如下:
class Program
{
private delegate int NewTaskDelegate(int ms);
private static int newTask(int ms)
{
Console.WriteLine("任务开始");
Thread.Sleep(ms);
Random random = new Random();
int n = random.Next(10000);
Console.WriteLine("任务完成");
return n;
}
static void Main(string[] args)
{
NewTaskDelegate task = newTask;
IAsyncResult asyncResult = task.BeginInvoke(2000, null, null);
//等待异步执行完成
while (!asyncResult.IsCompleted)
{
Console.Write("*");
Thread.Sleep(100);
}
// 由于异步调用已经完成，因此， EndInvoke会立刻返回结果
int result = task.EndInvoke(asyncResult);
Console.WriteLine(result);
Console.Read();
}
}
3、使用WaitOne方法等待异步方法执行完成
WaitOne的第一个参数表示要等待的毫秒数，在指定时间之内，WaitOne方法将一直等待，直到异步调用完成，并发出通知，WaitOne方法才返回true。当等待指定时间之后，异步调用仍未完成，WaitOne方法返回false，如果指定时间为0，表示不等待，如果为-1，表示永远等待，直到异步调用完成。
复制代码 代码如下:
class Program
{
private delegate int NewTaskDelegate(int ms);
private static int newTask(int ms)
{
Console.WriteLine("任务开始");
Thread.Sleep(ms);
Random random = new Random();
int n = random.Next(10000);
Console.WriteLine("任务完成");
return n;
}
static void Main(string[] args)
{
NewTaskDelegate task = newTask;
IAsyncResult asyncResult = task.BeginInvoke(2000, null, null);
//等待异步执行完成
while (!asyncResult.AsyncWaitHandle.WaitOne(100, false))
{
Console.Write("*");
}
int result = task.EndInvoke(asyncResult);
Console.WriteLine(result);
Console.Read();
}
}
4、使用回调方式返回结果
要注意的是“my.BeginInvoke(3,300, MethodCompleted, my)”，BeginInvoke方法的参数传递方式：
前面一部分(3,300)是其委托本身的参数。
倒数第二个参数(MethodCompleted)是回调方法委托类型，他是回调方法的委托，此委托没有返回值，有一个IAsyncResult类型的参数，当method方法执行完后，系统会自动调用MethodCompleted方法。
最后一个参数(my)需要向MethodCompleted方法中传递一些值，一般可以传递被调用方法的委托，这个值可以使用IAsyncResult.AsyncState属性获得。
复制代码 代码如下:
class Program
{
private delegate int MyMethod(int second, int millisecond);
//线程执行方法
private static int method(int second, int millisecond)
{
Console.WriteLine("线程休眠" + (second * 1000 + millisecond) + "毫秒");
Thread.Sleep(second * 1000 + millisecond);
Random random = new Random();
return random.Next(10000);
}
//回调方法
private static void MethodCompleted(IAsyncResult asyncResult)
{
if (asyncResult == null || asyncResult.AsyncState == null)
{
Console.WriteLine("回调失败！！！");
return;
}
int result = (asyncResult.AsyncState as MyMethod).EndInvoke(asyncResult);
Console.WriteLine("任务完成，结果：" + result);
}
static void Main(string[] args)
{
MyMethod my = method;
IAsyncResult asyncResult = my.BeginInvoke(3,300, MethodCompleted, my);
Console.WriteLine("任务开始");
Console.Read();
}
}
5、其他组件的BeginXXX和EndXXX方法
在其他的.net组件中也有类似BeginInvoke和EndInvoke的方法，如System.Net.HttpWebRequest类的BeginGetResponse和EndGetResponse方法。其使用方法类似于委托类型的BeginInvoke和EndInvoke方法，例如：
复制代码 代码如下:
class Program
{
//回调函数
private static void requestCompleted(IAsyncResult asyncResult)
{
if (asyncResult == null || asyncResult.AsyncState==null)
{
Console.WriteLine("回调失败");
return;
}
HttpWebRequest hwr = asyncResult.AsyncState as HttpWebRequest;
HttpWebResponse response = (HttpWebResponse)hwr.EndGetResponse(asyncResult);
StreamReader sr = new StreamReader(response.GetResponseStream());
string str = sr.ReadToEnd();
Console.WriteLine("返回流长度："+str.Length);
}
static void Main(string[] args)
{
HttpWebRequest request =
(HttpWebRequest)WebRequest.Create("http://www.baidu.com");
//异步请求
IAsyncResult asyncResult = request.BeginGetResponse(requestCompleted, request);
Console.WriteLine("任务开始");
Console.Read();
}
}
C#如何让一个线程一直等待直到到一个事件的发生，然后处理完后继续等待
有专门控制信号的两个类AutoResetEvent和ManualResetEvent
使用简单说明：
实例化对象
EventWaitHandle _waitHandle = new AutoResetEvent (false);
在线程函数中
while（true）
{
_waitHandle.WaitOne();
//事件发生后要做的任务
}
事件发生时调用 _waitHandle.Set()
补充下： 循环中_waitHandle一直在等待，且不会占用cpu 当调用Set时 就执行WaitOne一下的代码了，然后又循环 又WaitOne 等待再次Set()
C# 线程很好的文章，看看学习下吧
http://www.albahari.com/threading/
上一篇：notifyicon
下一篇：没有了
