C#多线程编程入门指南

需积分: 8 117 浏览量更新于2024-07-21 收藏 570KB PDF 举报

"《C#线程编程入门》是一篇由Andrew Birrell撰写的文章，旨在为有经验的程序员提供编写并发程序的实用技巧。文章首先概述了C#中的线程机制，它允许程序同时执行多个任务，通过共享内存进行同步。作者深入介绍了基本的线程和同步原语，并针对每个原语提供了详尽的教程，指导如何有效地利用它们。教程部分着重于最佳实践，警告可能遇到的问题，并给出避免这些问题的建议。虽然本文主要以C#作为编程语言，但许多教学内容同样适用于其他支持多线程的语言，如Java。文章涉及的主题包括编程技术的并发编程（D.1.3），编程语言特性中的并发编程结构（D.3.3），以及操作系统管理中的进程管理（D.4.1）。学习者将从中了解到设计并优化多线程程序的关键要素，如线程创建、互斥锁（Mutex）、信号量（Semaphore）、事件（Event）和任务（Task）的使用，以及如何处理线程安全问题、死锁和资源争用等。性能优化也是探讨的重要方面，包括如何根据应用场景选择合适的同步机制，以及如何避免由于并发带来的性能瓶颈。《C#线程编程入门》是一份实用指南，适合希望在并发编程领域深化理解的开发者，无论是在C#还是其他类似环境中，都能从中获益匪浅。通过阅读这篇文章，读者不仅能掌握C#语言中的线程工具，还能提升编写高效、可维护的并发代码的能力。"

An Introduction to Programming with C# Threads

The argument of the “lock” statement can be any object: in C# every object

inherently implements a mutual exclusion lock. At any moment, an object is

either “locked” or “unlocked”, initially unlocked. The “

lock” statement locks the

given object, then executes the contained statements, then unlocks the object. A

thread executing inside the “

lock” statement is said to “hold” the given object’s

lock. If another thread attempts to lock the object when it is already locked, the

second thread blocks (enqueued on the object’s lock) until the object is unlocked.

The most common use of the “

lock” statement is to protect the instance fields

of an object by locking that object whenever the program is accessing the fields.

For example, the following program fragment arranges that only one thread at a

time can be executing the pair of assignment statements in the “

SetKV” method.

class KV {

string k, v;

public void SetKV(string nk, string nv) {

lock (this) { this.k = nk; this.v = nv; }

}

…

}

However, there are other patterns for choosing which object’s lock protects

which variables. In general, you achieve mutual exclusion on a set of variables by

associating them (mentally) with a particular object. You then write your

program so that it accesses those variables only from a thread which holds that

object’s lock (i.e., from a thread executing inside a “

lock” statement that locked

the object). This is the basis of the notion of monitors, first described by Tony

Hoare [9]. The C# language and its runtime make no restrictions on your choice

of which object to lock, but to retain your sanity you should choose an obvious

one. When the variables are instance fields of an object, that object is the obvious

one to use for the lock (as in the “

SetKV” method, above. When the variables are

static fields of a class, a convenient object to use is the one provided by the C#

runtime to represent the type of the class. For example, in the following fragment

of the “KV” class the static field “head” is protected by the object “typeof(KV)”.

The “lock” statement inside the “AddToList” instance method provides mutual

exclusion for adding a “KV” object to the linked list whose head is “head”: only

one thread at a time can be executing the statements that use “head”. In this code

the instance field “next” is also protected by “typeof(KV)”.

static KV head = null;

KV next = null;

public void AddToList() {

lock (typeof(KV)) {

System.Diagnostics.Debug.Assert(this.next == null);

this.next = head; head = this;

}

An Introduction to Programming with C# Threads

3.3. Waiting for a condition

You can view an object’s lock as a simple kind of resource scheduling

mechanism. The resource being scheduled is the shared memory accessed inside

the “lock” statement, and the scheduling policy is one thread at a time. But often

the programmer needs to express more complicated scheduling policies. This

requires use of a mechanism that allows a thread to block until some condition is

true. In thread systems pre-dating Java, this mechanism was generally called

“condition variables” and corresponded to a separately allocated object [4,11]. In

Java and C# there is no separate type for this mechanism. Instead every object

inherently implements one condition variable, and the “

Monitor” class provides

static “Wait”, “Pulse” and “PulseAll” methods to manipulate an object’s condition

variable.

public sealed class Monitor {

public static bool Wait(Object obj) { … }

public static void Pulse(Object obj) { … }

public static void PulseAll(Object obj) { … }

...

}

A thread that calls “Wait” must already hold the object’s lock (otherwise, the call

of “Wait” will throw an exception). The “Wait” operation atomically unlocks the

object and blocks the thread

. A thread that is blocked in this way is said to be

“waiting on the object”. The “Pulse” method does nothing unless there is at least

one thread waiting on the object, in which case it awakens at least one such

waiting thread (but possibly more than one). The “

PulseAll” method is like

“Pulse”, except that it awakens all the threads currently waiting on the object.

When a thread is awoken inside “Wait” after blocking, it re-locks the object, then

returns. Note that the object’s lock might not be immediately available, in which

case the newly awoken thread will block until the lock is available.

If a thread calls “

Wait” when it has acquired the object’s lock multiple times,

the “

Wait” method releases (and later re-acquires) the lock that number of times.

It’s important to be aware that the newly awoken thread might not be the

next thread to acquire the lock: some other thread can intervene. This means that

the state of the variables protected by the lock could change between your call of

“

Pulse” and the thread returning from “Wait”. This has consequences that I’ll

discuss in section 5.

In systems pre-dating Java, the “

Wait” procedure or method took two

arguments: a lock and a condition variable; in Java and C#, these are combined

into a single argument, which is simultaneously the lock and the wait queue. In

terms of the earlier systems, this means that the “

Monitor” class supports only one

condition variable per lock

†

This atomicity guarantee avoids the problem known in the literature as the “wake-up

waiting” race [14].

†

However, as we’ll see in section 5.2, it’s not very difficult to add the extra semantics

yourself, by defining your own “Condition Variable” class.

剩余39页未读，继续阅读

iamhh

粉丝: 1
资源: 17

C#多线程编程入门指南

Introduction to C#

An Introduction to Programming with C# Threads - Andrew D. Barrel - Revised May, 2005

Concurrency in C# Cookbook 原版（pdf+mobi）

programming with threads pdf

List the three common ways of mapping user threads to kernel threads.

C# memorycache

filter threads

最新资源