Golang基于软件事务内存(STM)的并发控制插件库stl的使用

软件事务锁

stl包提供了基于软件事务内存(STM)并发控制机制的多重原子动态共享/排他锁。此外，stl锁可以接受context.Context，允许取消或设置锁定操作的截止时间。

锁快速且轻量级。实现只需要每个vault(包含任意数量资源的锁集合)一个mutex和一个channel。

安装

使用以下命令安装包：

go get github.com/ssgreg/stl

快速入门

stl可以原子地锁定任意数量的资源而不会死锁。每个资源可以以exclusive方式锁定(同一时间只有一个锁持有者可以锁定该资源)或以shared方式锁定(所有’shared’锁持有者可以同时锁定该资源，想要以’exclusive’方式锁定该资源的锁持有者将等待它们完成)。

您还可以在构建事务或事务锁时组合shared和exclusive资源：

// 一个包含所有锁定资源的vault
v := stl.NewVault()

// ...

locker := stl.New().Exclusive("terminal").Shared("network").ToLocker(v)
locker.Lock()
defer locker.Unlock()

如果您想能够取消或设置锁定操作的截止时间，还可以调用locker.LockWithContext(ctx)。这将为您的应用程序增加额外的灵活性。

示例：哲学家就餐问题

在计算机科学中，哲学家就餐问题是一个常用于并发算法设计中的示例问题，用于说明同步问题及其解决技术。值得注意的是，使用stl，与任何其他"裸"解决方案相比，可以优雅地解决该任务。以下是问题的简要描述：

五位哲学家围坐在圆形餐桌旁。桌上有五盘意大利面和五把叉子，排列方式使每位哲学家可以用双手拿起离他最近的两把叉子。哲学家要么思考他们的哲学问题，要么吃意大利面。思想家们必须使用两把叉子才能进食。如果一位哲学家只拿着一把叉子，他就不能吃饭或思考。需要组织他们的存在方式，使每位哲学家可以轮流吃饭和思考，永远如此。

首先我们需要在我们的并发模型中表示叉子(资源)。为了区分不同的叉子，我们将为每个叉子分配一些标签。使用stl不需要创建和保留资源本身。标签(或名称)就足够了。

// 五位哲学家每人两把叉子
resources := [][]string{
    {"fork_1", "fork_2"},
    {"fork_2", "fork_3"},
    {"fork_3", "fork_4"},
    {"fork_4", "fork_5"},
    {"fork_5", "fork_1"},
}

让我们继续构建一个事务(或在这种情况下的事务锁)。当哲学家将他的活动从thinking更改为eating时，他试图以exclusive方式拿起左右叉子。如果他成功获取(锁定)两者，他会花一些时间吃他的意大利面。如果任何叉子被邻居拿走，我们的哲学家应该等待任何其他哲学家完成进食(解锁)。

这是如何为每位哲学家创建事务锁的。

// 一个包含所有锁定资源的vault
v := stl.NewVault()

// ...

for n := 0; n < 5; n++ {
    // ...
    // 可以原子地独占锁定/解锁两把叉子的锁
    locker := stl.New().Exclusive(resources[n][0]).Exclusive(resources[n][1]).ToLocker(v)
    // ...
}

要更改哲学家的活动(独占锁定两个指定的资源)，我们需要调用locker.Lock()并在最后调用locker.Unlock()。如果我们想能够取消或设置锁定操作的截止时间，因为等待其他参与者解锁使用的资源可能需要一些时间，也可以调用locker.LockWithContext(ctx)。

// 哲学家在这里思考...
// ...

// 现在他决定拿起叉子吃一点意大利面
locker.Lock()
defer locker.Unlock()

// 哲学家在这里吃饭...
// ...

但现在我们必须停下来理解这个事务锁会做什么。假设两把叉子都是空闲的，那么锁将成功锁定它们所代表的两个资源。然而更有可能的是其中一把叉子已经被其他人拿走了。“全有或全无”，这个原则在STM机制中运作良好。如果两把叉子中的任何一把已经被拿走，事务将重新启动，直到锁成功锁定两个资源。我们可以认为，当且仅当锁的所有资源都被成功锁定时，事务才会成功。换句话说，如果某些叉子处于不希望的状态，事务锁将不会继续。

我们即将完成我们的解决方案。思考-进食函数：

do := func(locker Locker) {
    // 思考300毫秒
    time.Sleep(time.Millisecond * 300)

    // 等待空闲的叉子
    locker.Lock()
    defer locker.Unlock()

    // 进食100毫秒
    time.Sleep(time.Millisecond * 100)
}

评估：

for n := 0; n < 5; n++ {
    // 五位哲学家各自在自己的goroutine中生活
    go func(n int) {
        // 可以原子地独占锁定/解锁两把叉子的锁
        locker := New().Exclusive(resources[n][0]).Exclusive(resources[n][1]).ToLocker(v)

        // 思考-进食五次
        for i := 0; i < 5; i++ {
            do(locker)
        }
    }(n)
}

结论

stl为您提供了一种方便的方式来构建可靠的无死锁应用程序。

完整示例代码

package main

import (
	"fmt"
	"time"

	"github.com/ssgreg/stl"
)

func main() {
	// 五位哲学家每人两把叉子
	resources := [][]string{
		{"fork_1", "fork_2"},
		{"fork_2", "fork_3"},
		{"fork_3", "fork_4"},
		{"fork_4", "fork_5"},
		{"fork_5", "fork_1"},
	}

	// 一个包含所有锁定资源的vault
	v := stl.NewVault()

	do := func(name string, locker stl.Locker, i int) {
		// 思考300毫秒
		fmt.Printf("%s is thinking %dth time\n", name, i+1)
		time.Sleep(time.Millisecond * 300)

		// 等待空闲的叉子
		start := time.Now()
		locker.Lock()
		defer locker.Unlock()
		starving := time.Since(start)

		// 进食100毫秒
		fmt.Printf("%s is eating %dth time, was starving for %v\n", name, i+1, starving)
		time.Sleep(time.Millisecond * 100)
	}

	for n := 0; n < 5; n++ {
		name := fmt.Sprintf("Philosopher %d", n+1)
		// 可以原子地独占锁定/解锁两把叉子的锁
		locker := stl.New().Exclusive(resources[n][0]).Exclusive(resources[n][1]).ToLocker(v)

		// 每位哲学家在自己的goroutine中
		go func(name string, locker stl.Locker) {
			// 思考-进食五次
			for i := 0; i < 5; i++ {
				do(name, locker, i)
			}
		}(name, locker)
	}

	// 让哲学家们有时间完成他们的思考-进食循环
	time.Sleep(3 * time.Second)
}