經典同步問題及其僞代碼實現

1、生產者消費者問題

信號量版本：

// 定義緩衝區大小
bufferSize = 10
// 定義互斥鎖和信號量
mutex = Semaphore(1)
full = Semaphore(0)
empty = Semaphore(bufferSize)

// 定義生產者函數
def producer():
    while true:
        // 生成數據
        data = generateData()
        
        // 等待緩衝區不滿
        empty.P()
        mutex.P()
        // 將數據放入緩衝區
        putDataIntoBuffer(data)
        mutex.V()
        full.V()

// 定義消費者函數
def consumer():
    while true:
        // 等待緩衝區不空
        full.P()
        mutex.P()
        // 從緩衝區取出數據
        data = getDataFromBuffer()
        mutex.V()
        empty.V()
        
        // 處理數據
        processData(data)

條件變量版本：

// 定義緩衝區大小
bufferSize = 10

// 定義互斥鎖和條件變量
mutex = Mutex()
notEmpty = Condition(mutex)
notFull = Condition(mutex)

// 定義緩衝區和指針
buffer = []
inIndex = 0
outIndex = 0

// 定義生產者函數
def producer():
    while true:
        // 生成數據
        data = generateData()
        
        // 獲取互斥鎖
        mutex.lock()
        
        // 等待緩衝區不滿
        while buffer.length == bufferSize:
            notFull.wait()
        
        // 將數據放入緩衝區
        buffer[inIndex] = data
        inIndex = (inIndex + 1) % bufferSize
        
        // 通知消費者緩衝區不爲空
        notEmpty.signal()
        // 釋放互斥鎖
        mutex.unlock()

// 定義消費者函數
def consumer():
    while true:
        // 獲取互斥鎖
        mutex.lock()
        
        // 等待緩衝區不爲空
        while buffer.length == 0:
            notEmpty.wait()
        
        // 從緩衝區取出數據
        data = buffer[outIndex]
        outIndex = (outIndex + 1) % bufferSize
        
        // 通知生產者緩衝區不滿
        notFull.signal()
        
        // 釋放互斥鎖
        mutex.unlock()
        
        // 處理數據
        processData(data)

2、讀者寫者問題

信號量版本

// 定義讀者數量和寫者數量
numReaders = 0
numWriters = 0

// 定義互斥鎖和信號量
mutex = Semaphore(1)
writeLock = Semaphore(1)

// 定義讀者函數
def reader():
    while true:
        mutex.P() // 獲取互斥鎖
            numReaders += 1
            if numReaders == 1: // 如果是第一個讀者，獲取寫者鎖
                writeLock.P()
        mutex.V()
        
        readResource()
        
        mutex.P() // 獲取互斥鎖
            numReaders -= 1 
            if numReaders == 0: // 如果是最後一個讀者，釋放寫者鎖
                writeLock.V()
        mutex.V()

// 定義寫者函數
def writer():
    while true:
        writeLock.P()
        	write()
        writeLock.V()

條件變量版本

// 定義互斥鎖和條件變量
mutex = Mutex()
readersCond = Condition(mutex)
writersCond = Condition(mutex)

// 定義讀者函數
def reader():
    while true:
        // 獲取互斥鎖
        mutex.lock()
            // 等待寫者釋放資源
            while numWriters > 0:
                readersCond.wait()

            numReaders += 1
            readersCond.signal()
        mutex.unlock()
        
        readResource()
        
        // 獲取互斥鎖
        mutex.lock()
            numReaders -= 1
            if numReaders == 0:
                writersCond.signal()
        mutex.unlock()

// 定義寫者函數
def writer():
    while true:
        mutex.lock()       
            // 等待其他讀者和寫者釋放資源
            while numReaders > 0:
                writersCond.wait()

            // 寫入資源
            writeResource()

            // 通知其他讀者和寫者
            readersCond.signal()
            writersCond.signal()
        mutex.unlock()

3、哲學家就餐問題

可能有死鎖的寫法：每個哲學家都拿着左邊的筷子，永遠都在等右邊的筷子。至少一個哲學家的獲取筷子的順序要與其他人不同，以打破環路等待條件：

def getforks() :
  	if(p == 4):
      	right[p].P
        left[p].P
    else:
      	left[p].P
        right[p].P
   	eat()
    left[p].V
    right[p].V