信号详解：理解操作系统同步原理

需积分: 9 48 浏览量更新于2024-07-20 收藏 1.1MB PDF 举报

《信号的讲解》是一本由Allen B. Downey撰写的著作，专注于介绍信号（semaphores）的概念和应用。在第二版的2.2.1版本中，作者提供了深入浅出的讲解，使读者能够理解和掌握这个操作系统核心概念。这本书旨在帮助学生和专业人士理解同步（synchronization）在计算机系统中的关键作用，尤其是在iOS、Android等移动平台的运行时环境中。通常，操作系统教材会将同步模块作为高级主题，涵盖诸如互斥锁（mutexes）、信号量（semaphores）、监视器（monitors）和条件变量（condition variables）等基本同步机制。作者提到，他个人在学习操作系统课程时，通过阅读教材上的这些内容，学会了处理经典问题，如读者-写者问题（readers-writers problem）和生产者-消费者问题（producers-consumers problem），这些问题在并发编程中经常遇到，用于解决多个线程或进程间的协调工作。《The Little Book of Semaphores》特别强调了信号量的实用性，它是一种计数信号，用来控制对共享资源的访问，防止多个进程同时占用同一资源。信号量的核心操作包括P（wait）和V（signal），前者会使等待信号量的进程暂停执行直到信号可用，后者则可以增加或减少信号量的计数值，从而释放或者阻塞其他进程。书中还介绍了信号量与其他同步机制的比较，如互斥锁（保证同一时间只有一个进程访问资源），以及条件变量（允许进程在特定条件满足时继续执行）。作者使用LaTeX源代码编排，使得本书不仅易于阅读，还便于转换成不同格式并打印，体现了开源和免费软件的支持。对于希望深入了解操作系统底层原理，特别是关注iOS和Android这类移动平台的开发者来说，这本书是极好的参考资料。通过阅读，读者不仅能掌握信号量的基础理论，还能学会如何在实际项目中有效地运用这些概念来避免数据竞争和死锁等问题，提高程序的稳定性和性能。

4 Introduction

1.4 Non-determinism

Concurrent programs are often non-deterministic, which mean s it is not pos-

sible to tell, by looking at the program, what will happen when it executes.

Here is a simple example of a non-deterministic program:

Thread A

1 print " yes "

Thread B

1 print " no "

Because the two threads run c oncu r r ently, the order of execution depends

on the scheduler. During any given run of this program, the output mi ght be

“yes no” or “no yes”.

Non-determinism is one of the things that makes concurrent programs hard

to debug. A p r ogram might work correctly 1000 times in a row, and then crash

on the 1001st run, depending on the particular decisions of the scheduler.

These kinds of bugs are almost impossible to ﬁnd by te st in g; they can only

be avoided by careful programming.

1.5 Shared variables

Most of the time, most variables in most threads are local, meaning that they

belong to a single thread and no other threads can access them. As long as

that’s true, t he r e tend to be few synchronization problems, because threads

just don’t interact.

But usually some variables are shared among two or more threads; this

is one of the ways threads interact with each other. For example, one way

to communicate information between threads is for one thr e ad to read a value

written by another thread.

If the threads are unsynchronized, then we cannot tell by looking at the

program whether the reader will see the value the write r writes or an old value

that was already there. Thus many applications enforce the constraint th at

the reader should not read until after the writer writes. This is exactly the

serialization problem in Section

1.3.

Other ways that threads interact are concurrent writes (two or more writ-

ers) and concurrent updates (two or more threads performing a read followed

by a write). The next two sections deal with these inter act ions . The other

possible use of a shared variable, concurrent reads, does not generally create a

synchronization problem.

1.5.1 Concurrent writes

In the following example, x is a shared variable accessed by two writer s .

6 Introduction

is only incremented once, which is probably not what the programmer had in

mind.

This kind of problem is subtle because it is not alway s possible to tell,

looking at a high-level program, which operations are p er for med in a single step

and which can be interrupted. In fact, some computers provide an increment

instruction that is implemented in hardware and cannot be interrupted. An

operation that cannot be interrupted is said to be atomic.

So how can we write concurrent programs if we don’t know which operations

are atomic? One possibility is to collect speciﬁc information about each opera-

tion on each hardware platform. The drawbacks of this approach are obvious.

The most common alternative is to make the conservative assumption that

all updates and all writes are not atomic, and to use synchronization constraints

to control concurrent access to shared variables.

The most common constraint is mutual ex cl us i on, or mutex, which I men-

tioned in Section

1.1. Mut ual exclusion guarantees that only one thread accesses

a shared variable at a time, eliminating the kinds of synchronization errors in

this section.

Puzzle: Suppose that 100 th r eads run the following program concurrently

(if you are not familiar with Python, the for loop runs the update 100 times.):

1 for i in range (100):

2 temp = count

3 count = temp + 1

What is the largest possible value of count after all threads have completed?

What is the smallest possible value?

Hint: the ﬁrst question is easy; the second is not.

1.5.3 Mutual exclusion with messages

Like serialization, mutual exclusion can be implemented using message passing.

For example, imagine that you and Bob operate a nuclear reactor that you

monitor from remote stations. Most of the time, both of you ar e watching for

warning lights, but you are both allowed to take a br e ak for lunch. It doesn’t

matter who eats lunch ﬁrst, but it is very important that you don’t eat lunch

at the same time, leaving the reactor unwatched!

Puzzle: Figure out a system of message passing (phone calls) that enforces

these restraints. Assume there are n o clocks, and you cannot predict when lunch

will start or how long it will last. What is the minimum number of messages

that is required?

剩余290页未读，继续阅读

Look_At

粉丝: 0
资源: 5

信号详解：理解操作系统同步原理

一些很好的Linux 信号讲解

数字信号处理核心知识讲解 csdn

帮我解释一下如何看信号系统图，给出一个信号系统图案例并详细讲解

抽样定理与信号恢复multisim仿真实验讲解

python多线程信号机制讲解

结合理论课讲解基于matlab仿真ofdm信号,绘制ofdm符号星座图,时域、频域曲线;

xilinx伪双口ram具体如何使用，请给出ip核中各个信号详细讲解以及详细verliog代码

讲解下linux中的信号、中断和系统调用

基于STM32标准库的周期信号等效采样原理代码及讲解

对LCD1602忙信号的定义与作用进行讲解

最新资源