稳扎稳打Silverlight(25) - 2.0线程之Thread, Timer, BackgroundWorker, ThreadPool_app

概述[索引页] [源码下载] 稳扎稳打Silverlight(25) - 2.0线程之Thread, Timer, BackgroundWorker, ThreadPool 作者： webabcd 介绍 Silverlight 2.0 使用Thread, Timer, BackgroundWorker, ThreadPool来实现多线程开发     Thread - 用于线程的创建和控制的类     [索引页]
[源码下载]

稳扎稳打Silverlight(25) - 2.0线程之Thread,Timer,BackgrounDWorker,ThreadPool

作者： webabcd

介绍
Silverlight 2.0 使用Thread,ThreadPool来实现多线程开发
    Thread - 用于线程的创建和控制的类
    Timer - 用于以指定的时间间隔执行指定的方法的类
    BackgrounDWorker - 用于在单独的线程上运行 *** 作
    ThreadPool - 线程池的管理类

在线DEMO
http://www.cnblogs.com/webabcd/archive/2008/10/09/1307486.html

示例
1、Thread.xaml

< UserControl x:Class ="Silverlight20.Thread.Thread"

xmlns ="http://schemas.microsoft.com/winfx/2006/xaml/presentation"

xmlns:x ="http://schemas.microsoft.com/winfx/2006/xaml" >

< StackPanel HorizontalAlignment ="left" margin ="5" >

< TextBlock x:name ="txtMsg" />

</ StackPanel >

</ UserControl >

Thread.xaml.cs

using System;

using System.Collections.Generic;

using System.linq;

using System.Net;

using System.windows;

using System.windows.Controls;

using System.windows.documents;

using System.windows.input;

using System.windows.Media;

using System.windows.Media.Animation;

using System.windows.Shapes;

namespace Silverlight20.Thread

{

public partial class Thread : UserControl

{

string result = "";

public Thread()

{

InitializeComponent();

Demo();

}

voID Demo()

{

/**//*

* Thread - 用于线程的创建和控制的类

* name - 线程名称

* IsBackground - 是否是后台线程（对于Silverlight来说，是否是后台线程没区别）

* Start(object parameter) - 启动后台线程

* object parameter - 为后台线程传递的参数

* IsAlive - 线程是否在执行中

* ManagedThreadID - 当前托管线程的唯一标识符

* ThreadState - 指定线程的状态 [System.Threading.ThreadState枚举]

* Abort() - 终止线程

// DoWork 是后台线程所执行的方法（此处省略掉了委托类型）

// ThreadStart 委托不可以带参数, ParameterizedThreadStart 委托可以带参数

System.Threading.Thread thread = new System.Threading.Thread(DoWork);

thread.name = "ThreadDemo";

thread.IsBackground = true;

thread.Start(1000);

result += thread.IsAlive + "/r/n";

result += thread.ManagedThreadID + "/r/n";

result += thread.name + "/r/n";

result += thread.ThreadState + "/r/n";

// thread.Join(); 阻塞调用线程（本例为主线程），直到指定线程（本例为thread）执行完毕为止

// 阻塞调用线程（本例为主线程）

// 如果指定线程执行完毕则继续（本例为thread执行完毕则继续）

// 如果指定线程运行的时间超过指定时间则继续（本例为thread执行时间如果超过5秒则继续）

// 返回值为在指定时间内指定线程是否执行完毕（本例中thread的执行时间为1秒，所以会返回true）

if (thread.Join(5000))

{

result += "指定线程在5秒内执行完毕/r/n";

}

txtMsg.Text = result;

}

voID DoWork(object sleepMillisecond)

{

System.Threading.Thread.Sleep((int)sleepMillisecond);

result += "新开线程执行完毕/r/n";

}

2、Timer.xaml

< UserControl x:Class ="Silverlight20.Thread.Timer"

xmlns ="http://schemas.microsoft.com/winfx/2006/xaml/presentation"

xmlns:x ="http://schemas.microsoft.com/winfx/2006/xaml" >

< StackPanel HorizontalAlignment ="left" margin ="5" >

< TextBlock x:name ="txtMsg" />

</ StackPanel >

</ UserControl >

Timer.xaml.cs

using System;

using System.Collections.Generic;

using System.linq;

using System.Net;

using System.windows;

using System.windows.Controls;

using System.windows.documents;

using System.windows.input;

using System.windows.Media;

using System.windows.Media.Animation;

using System.windows.Shapes;

namespace Silverlight20.Thread

{

public partial class Timer : UserControl

{

System.Threading.SynchronizationContext _syncContext;

// Timer - 用于以指定的时间间隔执行指定的方法的类

System.Threading.Timer _timer;

private int _flag = 0;

public Timer()

{

InitializeComponent();

// UI 线程

_syncContext = System.Threading.SynchronizationContext.Current;

Demo();

}

voID Demo()

@H_403_1208@{

// 输出当前时间

txtMsg.Text = DateTime.Now.ToString() + "/r/n";

// 第一个参数：定时器需要调用的方法

// 第二个参数：传给需要调用的方法的参数

// 第三个参数：此时间后启动定时器

// 第四个参数：调用指定方法的间隔时间（System.Threading.Timeout.Infinite 为无穷大）

_timer = new System.Threading.Timer(MyTimerCallback, "webabcd", 3000, 1000);

}

private voID MyTimerCallback(object state)

{

string result = string.Format("{0} - {1}/r/n", DateTime.Now.ToString(), (string)state);

// 调用 UI 线程。不会做自动线程同步

_syncContext.Post(delegate

{ txtMsg.Text += result; }, null);

_flag++;

if (_flag == 5)

_timer.Change(5000, 500); // 执行5次后，计时器重置为5秒后启动，每5毫秒的间隔时间执行一次指定的方法

else if (_flag == 10)

_timer.dispose(); // 执行10次后，释放计时器所使用的全部资源

}

3、BackgrounDWorker.xaml

< UserControl x:Class ="Silverlight20.Thread.BackgrounDWorker"

xmlns ="http://schemas.microsoft.com/winfx/2006/xaml/presentation"

xmlns:x ="http://schemas.microsoft.com/winfx/2006/xaml" >

< StackPanel HorizontalAlignment ="left" margin ="5" >

< StackPanel OrIEntation ="Horizontal" margin ="5" >

< button x:name ="btnStart" Content ="开始" margin ="5" Click ="btnStart_Click" />

< button x:name ="btnCancel" Content ="取消" margin ="5" Click ="btnCancel_Click" />

</ StackPanel >

< StackPanel margin ="5" >

< TextBlock x:name ="txtProgress" margin ="5" />

< TextBlock x:name ="txtMsg" margin ="5" />

</ StackPanel >

</ UserControl >

BackgrounDWorker.xaml.cs

/**/ /*

* 演示用 BackgrounDWorker 在后台线程上执行耗时的 *** 作

* 按“开始”键，开始在后台线程执行耗时 *** 作，并向UI线程汇报执行进度

* 按“取消”键，终止后台线程

* BackgrounDWorker 调用 UI 线程时会自动做线程同步

using System;

using System.Collections.Generic;

using System.linq;

using System.Net;

using System.windows;

using System.windows.Controls;

using System.windows.documents;

using System.windows.input;

using System.windows.Media;

using System.windows.Media.Animation;

using System.windows.Shapes;

namespace Silverlight20.Thread

{

public partial class BackgrounDWorker : UserControl

{

// BackgrounDWorker - 用于在单独的线程上运行 *** 作。例如可以在非UI线程上运行耗时 *** 作，以避免UI停止响应

System.ComponentModel.BackgrounDWorker _backgrounDWorker;

public BackgrounDWorker()

{

InitializeComponent();

BackgrounDWorkerDemo();

}

voID BackgrounDWorkerDemo()

{

/**//*

* WorkerSupportsCancellation - 是否支持在其他线程中取消该线程的 *** 作

* WorkerReportsProgress - 是否可以报告 *** 作进度

* ProgressChanged - 报告 *** 作进度时触发的事件

* DoWork - BackgrounDWorker 调用 RunWorkerAsync() 方法时触发的事件。在此执行具体 *** 作

* RunWorkerCompleted - *** 作完成/取消/出错时触发的事件

_backgrounDWorker = new System.ComponentModel.BackgrounDWorker();

_backgrounDWorker.WorkerSupportsCancellation = true;

_backgrounDWorker.WorkerReportsProgress = true;

_backgrounDWorker.ProgressChanged += new System.ComponentModel.ProgressChangedEventHandler(_backgrounDWorker_ProgressChanged);

_backgrounDWorker.DoWork += new System.ComponentModel.DoWorkEventHandler(_backgrounDWorker_DoWork);

_backgrounDWorker.RunWorkerCompleted += new System.ComponentModel.RunWorkerCompletedEventHandler(_backgrounDWorker_RunWorkerCompleted);

}

private voID btnStart_Click(object sender, RoutedEventArgs e)

{

// IsBusy - 指定的 BackgrounDWorker 是否正在后台 *** 作

// RunWorkerAsync(object argument) - 开始在后台线程执行指定的 *** 作

// object argument - 需要传递到 DoWork 的参数

if (!_backgrounDWorker.IsBusy)

_backgrounDWorker.RunWorkerAsync("需要传递的参数");

}

private voID btnCancel_Click(object sender, RoutedEventArgs e)

{

// CancelAsync() - 取消 BackgrounDWorker 正在执行的后台 *** 作

if (_backgrounDWorker.WorkerSupportsCancellation)

_backgrounDWorker.CancelAsync();

}

voID _backgrounDWorker_DoWork(object sender, System.ComponentModel.DoWorkEventArgs e)

{

/**//*

* DoWorkEventArgs.Argument - RunWorkerAsync(object argument)传递过来的参数

* DoWorkEventArgs.Cancel - 取消 *** 作

* DoWorkEventArgs.Result - *** 作的结果。将传递到 RunWorkerCompleted 所指定的方法

* BackgrounDWorker.ReportProgress(int percentProgress, object userState) - 向 ProgressChanged 汇报 *** 作的完成进度

* int percentProgress - *** 作完成的百分比 1% - 100%

* object userState - 传递到 ProgressChanged 的参数

for (int i = 0; i < 10; i++)

{

if ((_backgrounDWorker.CancellationPending == true))

{

e.Cancel = true;

break;

}

else

{

System.Threading.Thread.Sleep(1000);

_backgrounDWorker.ReportProgress((i + 1) * 10, i);

}

e.Result = " *** 作已完成";

}

voID _backgrounDWorker_ProgressChanged(object sender, System.ComponentModel.ProgressChangedEventArgs e)

{

// ProgressChangedEventArgs.Progresspercentage - ReportProgress 传递过来的 *** 作完成的百分比

// ProgressChangedEventArgs.UserState - ReportProgress 传递过来的参数

txtProgress.Text = string.Format("完成进度：{0}%；参数：{1}",

e.Progresspercentage,

e.UserState);

}

voID _backgrounDWorker_RunWorkerCompleted(object sender, System.ComponentModel.RunWorkerCompletedEventArgs e)

{

/**//*

* RunWorkerCompletedEventArgs.Error - DoWork 时产生的错误

* RunWorkerCompletedEventArgs.Cancelled - 后台 *** 作是否已被取消

* RunWorkerCompletedEventArgs.Result - DoWork 的结果

if (e.Error != null)

{

txtMsg.Text += e.Error.ToString() + "/r/n";

}

else if (e.Cancelled)

{

txtMsg.Text += " *** 作被取消/r/n";

}

else

{

txtMsg.Text += e.Result.ToString() + "/r/n";

}

4、ThreadPool.xaml

< UserControl x:Class ="Silverlight20.Thread.ThreadPool"

xmlns ="http://schemas.microsoft.com/winfx/2006/xaml/presentation"

xmlns:x ="http://schemas.microsoft.com/winfx/2006/xaml" >

< StackPanel HorizontalAlignment ="left" margin ="5" >

< TextBlock x:name ="txtMsgQueueUserWorkItem" Text ="click here" MouseleftbuttonDown ="txtMsgQueueUserWorkItem_MouseleftbuttonDown" margin ="30" />

< TextBlock x:name ="txtRegisterWaitForSingleObject" Text ="click here" MouseleftbuttonDown ="txtRegisterWaitForSingleObject_MouseleftbuttonDown" margin ="30" />

</ StackPanel >

</ UserControl >

ThreadPool.xaml.cs

using System;

using System.Collections.Generic;

using System.linq;

using System.Net;

using System.windows;

using System.windows.Controls;

using System.windows.documents;

using System.windows.input;

using System.windows.Media;

using System.windows.Media.Animation;

using System.windows.Shapes;

namespace Silverlight20.Thread

{

public partial class ThreadPool : UserControl

{

public ThreadPool()

{

InitializeComponent();

}

private voID txtMsgQueueUserWorkItem_MouseleftbuttonDown(object sender, MousebuttonEventArgs e)

{

// ThreadPool - 线程池的管理类

// QueueUserWorkItem(WaitCallback callBack, Object state) - 将指定方法加入线程池队列

// WaitCallback callBack - 需要在新开线程里执行的方法

// Object state - 传递给指定方法的参数

System.Threading.ThreadPool.QueueUserWorkItem(DoWork, DateTime.Now);

}

private voID DoWork(object state)

{

// 作为线程管理策略的一部分，线程池在创建线程前会有一定的延迟

// 也就是说线程入队列的时间和线程启动的时间之间有一定的间隔

DateTime dtJoin = (DateTime)state;

DateTime dtStart = DateTime.Now;

System.Threading.Thread.Sleep(3000);

DateTime dtEnd = DateTime.Now;

// dispatcher.BeginInvoke() - 在与 dispatcher 相关联的线程上执行指定的 *** 作。自动线程同步

this.dispatcher.BeginInvoke(() =>

{

txtMsgQueueUserWorkItem.Text += string.Format("/r/n入队列时间{0} 启动时间{1} 完成时间{2}",

dtJoin.ToString(), dtStart.ToString(), dtEnd.ToString());

});

}

private voID txtRegisterWaitForSingleObject_MouseleftbuttonDown(object sender, MousebuttonEventArgs e)

@H_502_3627@

{

System.Threading.autoresetEvent done = new System.Threading.autoresetEvent(false);

// 为了传递 RegistereDWaitHandle 对象，要将其做一个封装

RegistereDWaitHandlePacket packet = new RegistereDWaitHandlePacket();

// RegisterWaitForSingleObject - 注册一个 WaitHandle 。在超时或发信号的情况下对指定的回调方法做调用

// 第一个参数：需要注册的 WaitHandle

// 第二个参数：需要回调的方法（此处省略掉了委托类型）

// 第三个参数：传递给回调方法的参数

// 第四个参数：超时时间（到超时时间则调用指定的方法）

// 第五个参数：是否为一次调用（是到超时时间一次性调用指定的方法，还是每次超时时间后都调用指定的方法）

packet.Handle = System.Threading.ThreadPool.RegisterWaitForSingleObject

(

done,

WaitOrTimer,

packet,

100,

false

);

System.Threading.Thread.Sleep(555);

done.Set(); // 发出信号，调用 RegisterWaitForSingleObject 所指定的方法

}

public voID WaitOrTimer(object state, bool timedOut)

{

RegistereDWaitHandlePacket packet = state as RegistereDWaitHandlePacket;

// bool timedOut - 是否是因为超时而执行到这里

if (!timedOut)

{

// 如果不是因为超时而执行到这里（即因为 autoresetEvent 发出了信号而执行到这里），则注销指定的 RegistereDWaitHandle

packet.Handle.Unregister(null);

}

this.dispatcher.BeginInvoke(() =>

{

txtRegisterWaitForSingleObject.Text +=

String.Format("/r/n是否收到信号：{0}", (!timedOut).ToString());

});

}

/**//// <summary>

/// 封装了 RegistereDWaitHandle 的类

/// </summary>

public class RegistereDWaitHandlePacket

{

public System.Threading.RegistereDWaitHandle Handle

{ get; set; }

}

OK
[源码下载] 总结

以上是内存溢出为你收集整理的稳扎稳打Silverlight(25) - 2.0线程之Thread, Timer, BackgroundWorker, ThreadPool全部内容，希望文章能够帮你解决稳扎稳打Silverlight(25) - 2.0线程之Thread, Timer, BackgroundWorker, ThreadPool所遇到的程序开发问题。

如果觉得内存溢出网站内容还不错，欢迎将内存溢出网站推荐给程序员好友。

欢迎分享，转载请注明来源：内存溢出

原文地址: http://outofmemory.cn/web/1052291.html