ylbtech-LanguageSamples-Threading(线程处理)

ylbtech-Microsoft-CSharpSamples:ylbtech-LanguageSamples-Threading(线程处理)

1.A，示例(Sample) 返回顶部

“线程处理”示例

本示例演示了下面的线程处理技术。有关更多信息，请参见线程处理（C# 编程指南）。

创建、启动和终止线程
使用线程池
线程同步和互交

安全说明
提供此代码示例是为了阐释一个概念，它并不代表最安全的编码实践，因此不应在应用程序或网站中使用此代码示例。对于因将此代码示例用于其他用途而出现的偶然或必然的损害，Microsoft 不承担任何责任。

在 Visual Studio 中生成并运行“线程处理”示例

在“解决方案资源管理器”中，右击“ThreadStartStop”项目并单击“设为启动项目”。
在“调试”菜单上，单击“开始执行(不调试)”。
对于 ThreadPool 和 ThreadSync，分别重复上述步骤。

从命令行生成并运行“线程”示例

使用“更改目录”命令转到“Threads”目录。

键入以下命令：

cd ThreadStartStop

csc ThreadStartStop.cs

ThreadStartStop

键入以下命令：

cd ..\ThreadPool

csc ThreadPool.cs

ThreadPool

键入以下命令：

cd ..\ThreadSync

csc ThreadSync.cs

ThreadSync

1.B，ThreadStartStop 示例代码(Sample Code)返回顶部

1.B.1, ThreadStartStop.cs

// 版权所有(C) Microsoft Corporation。保留所有权利。

// 此代码的发布遵从

// Microsoft 公共许可(MS-PL，http://opensource.org/licenses/ms-pl.html)的条款。

//

//版权所有(C) Microsoft Corporation。保留所有权利。

using System;

using System.Threading;

public class Worker

{

    // 启动线程时调用此方法。

    public void DoWork()

    {

        while (!_shouldStop)

        {

            Console.WriteLine("worker thread: working...");

        }

        Console.WriteLine("worker thread: terminating gracefully.");

    }

    public void RequestStop()

    {

        _shouldStop = true;

    }

    // Volatile 用于向编译器提示此数据

    // 成员将由多个线程访问。

    private volatile bool _shouldStop;

}

public class WorkerThreadExample

{

    static void Main()

    {

        // 创建线程对象。这不会启动该线程。

        Worker workerObject = new Worker();

        Thread workerThread = new Thread(workerObject.DoWork);

        // 启动辅助线程。

        workerThread.Start();

        Console.WriteLine("main thread: Starting worker thread...");

        // 循环直至辅助线程激活。

        while (!workerThread.IsAlive);

        // 为主线程设置 1 毫秒的休眠，

        // 以使辅助线程完成某项工作。

        Thread.Sleep();

        // 请求辅助线程自行停止：

        workerObject.RequestStop();

        // 使用 Join 方法阻塞当前线程，

        // 直至对象的线程终止。

        workerThread.Join();

        Console.WriteLine("main thread: Worker thread has terminated.");

    }

}

1.B.2,

1.B.EXE,

main thread: Starting worker thread...

worker thread: working...

worker thread: working...

worker thread: working...

worker thread: working...

worker thread: working...

worker thread: working...

worker thread: working...

worker thread: working...

worker thread: terminating gracefully.

main thread: Worker thread has terminated.

请按任意键继续. . .

1.B

1.B，ThreadPool 示例代码2(Sample Code)返回顶部

1.B.1, ThreadPool.cs

// 版权所有(C) Microsoft Corporation。保留所有权利。

// 此代码的发布遵从

// Microsoft 公共许可(MS-PL，http://opensource.org/licenses/ms-pl.html)的条款。

//

//版权所有(C) Microsoft Corporation。保留所有权利。

using System;

using System.Threading;

// Fibonacci 类为使用辅助

// 线程执行长时间的 Fibonacci(N) 计算提供了一个接口。

// N 是为 Fibonacci 构造函数提供的，此外还提供了

// 操作完成时对象发出的事件信号。

// 然后，可以使用 FibOfN 属性来检索结果。

public class Fibonacci

{

    public Fibonacci(int n, ManualResetEvent doneEvent)

    {

        _n = n;

        _doneEvent = doneEvent;

    }

    // 供线程池使用的包装方法。

    public void ThreadPoolCallback(Object threadContext)

    {

        int threadIndex = (int)threadContext;

        Console.WriteLine("thread {0} started...", threadIndex);

        _fibOfN = Calculate(_n);

        Console.WriteLine("thread {0} result calculated...", threadIndex);

        _doneEvent.Set();

    }

    // 计算第 N 个斐波纳契数的递归方法。

    public int Calculate(int n)

    {

        if (n <= )

        {

            return n;

        }

        else

        {

            return Calculate(n - ) + Calculate(n - );

        }

    }

    public int N { get { return _n; } }

    private int _n;

    public int FibOfN { get { return _fibOfN; } }

    private int _fibOfN;

    ManualResetEvent _doneEvent;

}

public class ThreadPoolExample

{

    static void Main()

    {

        const int FibonacciCalculations = ;

        // 每个 Fibonacci 对象使用一个事件

        ManualResetEvent[] doneEvents = new ManualResetEvent[FibonacciCalculations];

        Fibonacci[] fibArray = new Fibonacci[FibonacciCalculations];

        Random r = new Random();

        // 使用 ThreadPool 配置和启动线程：

        Console.WriteLine("launching {0} tasks...", FibonacciCalculations);

        for (int i = ; i < FibonacciCalculations; i++)

        {

            doneEvents[i] = new ManualResetEvent(false);

            Fibonacci f = new Fibonacci(r.Next(,), doneEvents[i]);

            fibArray[i] = f;

            ThreadPool.QueueUserWorkItem(f.ThreadPoolCallback, i);

        }

        // 等待池中的所有线程执行计算...

        WaitHandle.WaitAll(doneEvents);

        Console.WriteLine("Calculations complete.");

        // 显示结果...

        for (int i= ; i<FibonacciCalculations; i++)

        {

            Fibonacci f = fibArray[i];

            Console.WriteLine("Fibonacci({0}) = {1}", f.N, f.FibOfN);

        }

    }

}

1.B.2,

1.B.EXE,

launching  tasks...

thread  started...

thread  started...

thread  result calculated...

thread  started...

thread  result calculated...

thread  started...

thread  result calculated...

thread  started...

thread  result calculated...

thread  started...

thread  result calculated...

thread  started...

thread  result calculated...

thread  started...

thread  result calculated...

thread  started...

thread  result calculated...

thread  started...

thread  result calculated...

thread  result calculated...

Calculations complete.

Fibonacci() =

Fibonacci() =

Fibonacci() =

Fibonacci() =

Fibonacci() =

Fibonacci() =

Fibonacci() =

Fibonacci() =

Fibonacci() =

Fibonacci() =

请按任意键继续. . .

1.B,

1.B，ThreadSync 示例代码3(Sample Code)返回顶部

1.B.1, ThreadSync.cs

// 版权所有(C) Microsoft Corporation。保留所有权利。

// 此代码的发布遵从

// Microsoft 公共许可(MS-PL，http://opensource.org/licenses/ms-pl.html)的条款。

//

//版权所有(C) Microsoft Corporation。保留所有权利。

using System;

using System.Threading;

using System.Collections;

using System.Collections.Generic;

// 将线程同步事件封装在此类中，

// 以便于将这些事件传递给 Consumer 和

// Producer 类。

public class SyncEvents

{

    public SyncEvents()

    {

        // AutoResetEvent 用于“新项”事件，因为

        // 我们希望每当使用者线程响应此事件时，

        // 此事件就会自动重置。

        _newItemEvent = new AutoResetEvent(false);

        // ManualResetEvent 用于“退出”事件，因为

        // 我们希望发出此事件的信号时有多个线程响应。

        // 如果使用 AutoResetEvent，事件

        // 对象将在单个线程作出响应之后恢复为

        // 未发信号的状态，而其他线程将

        // 无法终止。

        _exitThreadEvent = new ManualResetEvent(false);

        // 这两个事件也放在一个 WaitHandle 数组中，以便

        // 使用者线程可以使用 WaitAny 方法

        // 阻塞这两个事件。

        _eventArray = new WaitHandle[];

        _eventArray[] = _newItemEvent;

        _eventArray[] = _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;

}

// Producer 类（使用一个辅助线程）

// 将项异步添加到队列中，共添加 20 个项。

public class Producer

{

    public Producer(Queue<int> q, SyncEvents e)

    {

        _queue = q;

        _syncEvents = e;

    }

    public void ThreadRun()

    {

        int count = ;

        Random r = new Random();

        while (!_syncEvents.ExitThreadEvent.WaitOne(, false))

        {

            lock (((ICollection)_queue).SyncRoot)

            {

                while (_queue.Count < )

                {

                    _queue.Enqueue(r.Next(, ));

                    _syncEvents.NewItemEvent.Set();

                    count++;

                }

            }

        }

        Console.WriteLine("Producer thread: produced {0} items", count);

    }

    private Queue<int> _queue;

    private SyncEvents _syncEvents;

}

// Consumer 类通过自己的辅助线程使用队列

// 中的项。Producer 类使用 NewItemEvent

// 将新项通知 Consumer 类。

public class Consumer

{

    public Consumer(Queue<int> q, SyncEvents e)

    {

        _queue = q;

        _syncEvents = e;

    }

    public void ThreadRun()

    {

        int count = ;

        while (WaitHandle.WaitAny(_syncEvents.EventArray) != )

        {

            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 i in q)

            {

                Console.Write("{0} ", i);

            }

        }

        Console.WriteLine();

    }

    static void Main()

    {

        // 配置结构，该结构包含线程同步

        // 所需的事件信息。

        SyncEvents syncEvents = new SyncEvents();

        // 泛型队列集合用于存储要制造和使用的

        // 项。此例中使用的是“int”。

        Queue<int> queue = new Queue<int>();

        // 创建对象，一个用于制造项，一个用于

        // 使用项。将队列和线程同步事件传递给

        // 这两个对象。

        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();

        // 为制造者线程和使用者线程设置 10 秒的运行时间。

        // 使用主线程（执行此方法的线程）

        // 每隔 2.5 秒显示一次队列内容。

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

        {

            Thread.Sleep();

            ShowQueueContents(queue);

        }

        // 向使用者线程和制造者线程发出终止信号。

        // 这两个线程都会响应，由于 ExitThreadEvent 是

        // 手动重置的事件，因此除非显式重置，否则将保持“设置”。

        Console.WriteLine("Signaling threads to terminate...");

        syncEvents.ExitThreadEvent.Set();

        // 使用 Join 阻塞主线程，首先阻塞到制造者线程

        // 终止，然后阻塞到使用者线程终止。

        Console.WriteLine("main thread waiting for threads to finish...");

        producerThread.Join();

        consumerThread.Join();

    }

}

1.B.2,

1.B.EXE,

Configuring worker threads...

Launching producer and consumer threads...

Signaling threads to terminate...

main thread waiting for threads to finish...

Producer thread: produced  items

Consumer Thread: consumed  items

请按任意键继续. . .

1.B,

1.C，下载地址(Free Download)返回顶部

作者：ylbtech
出处：http://ylbtech.cnblogs.com/
本文版权归作者和博客园共有，欢迎转载，但未经作者同意必须保留此段声明，且在文章页面明显位置给出原文连接，否则保留追究法律责任的权利。