【Java&Go并发编程系列】11.条件变量——Condition VS sync.Cond

最新推荐文章于 2025-01-17 10:36:03 发布
原创 最新推荐文章于 2025-01-17 10:36:03 发布 · 368 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#java #go #并发编程 #golang

本文通过自动售卖机实例，对比分析Java和Go语言中条件变量的使用，演示如何优化锁操作，减少资源浪费。

说明：Java & Go 并发编程序列的文章，根据每篇文章的主题或细分标题，分别演示 Java 和 Go 语言当中的相关实现。更多该系列文章请查看：Java & Go 并发编程系列

在前文讲《互斥锁》的时候，使用了自动售卖机作为例子进行了代码的演示。先回顾之前的代码场景。

代码场景：假设有一台自动售卖机，售卖和补货操作不能同一时间进行。即：

  • 当用户在购物时，就不能执行补货操作；
  • 当执行补货操作时，用户也不能购物；
  • 如果有多个用户需要购物，也只能依次执行。

本文接着用这个例子演示条件变量。并增加如下代码场景：

  • 售卖机初始可售量为5
  • 售卖机最大可售量为5，当售卖机的可售量小于5时，会通知后台（补货员）售卖机的货架有空余，但是补货员只有在可售量为0的时候才进行补货，一次补货数量为5
  • 当补货操作完成时，会通知用户已有货物可卖
  • 期间有10个用户购物和一次补货操作

假设没有条件变量这个工具，我们看下只基于锁如何实现上述需求（暂时忽略通知，只实现当满足特定条件的时候进行特定的操作）。

首先，为了演示执行锁的动作的次数，自定义一个锁工具类 MyLock，继承 ReentrantLock，扩展了 lock() 方法增加了计数功能，即每执行一次 lock() 操作计数器就加1。MyLock 还提供了 getLockTimes() 方法执行 lock() 操作的次数：

static class MyLock extends ReentrantLock {
    private final LongAdder counter;

    public MyLock() {
        super();
        counter = new LongAdder();
    }

    @Override
    public void lock() {
        super.lock();
        counter.increment();
    }

    private long getLockTimes() {
        return counter.sum();
    }
}

修改前文中介绍的自动售卖机 VendingMachine ，基于自定义的锁 MyLock。提供一个打印执行锁动作次数的方法 printLockTimes()。再看 sale() 和 stock() 方法，由于必须要分别满足以下条件才能执行对应的操作，所以会在一个循环里面不断去尝试：

  • sale()：剩余可售量大于0
  • stock()：剩余可售量等于0
    修改后的代码如下：
// VendingMachine 表示自动售卖机
static class VendingMachine {

    // 使用锁来保证，售卖和补货不能同时进行
    private final MyLock lock;
    private final int maxSize;// 最大可售量
    private int remainder;// 剩余可售量

    public VendingMachine() {
        lock = new MyLock();
        maxSize = 5;
        remainder = maxSize;// 初始可售量为5
    }

    // 售卖
    public void sale() {
        while (true) {
            lock.lock();// 获得锁之后才能往下执行
            try {
                if (remainder == 0) {
                    continue;
                }
                System.out.printf("[%s] 开始购物...\n",
                        Thread.currentThread().getName());
                TimeUnit.MILLISECONDS.sleep(200);
                remainder--;// 可售量减1
                System.out.printf("[%s] 购物完成，剩余可售量: %d\n",
                        Thread.currentThread().getName(), remainder);
                break;
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                lock.unlock();// 解锁
            }
        }
    }

    // 补货
    public void stock() {
        while (true) {
            lock.lock();// 获得锁之后才能往下执行
            try {
                if (remainder > 0) {
                    continue;
                }
                // 当可售量为0时，结束 while 循环，进入补货流程
                System.out.printf("[%s] 开始进货...\n",
                        Thread.currentThread().getName());
                TimeUnit.MILLISECONDS.sleep(500);
                remainder = maxSize;// 一次性补满货
                System.out.printf("[%s] 进货完成，可售量: %d\n",
                        Thread.currentThread().getName(), remainder);
                break;
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                lock.unlock();// 解锁
            }
        }

    }

    public void printLockTimes() {
        System.out.printf("锁的次数：%d\n", lock.getLockTimes());
    }
}

运行程序执行10个用户购物和一次补货的操作。

public static void main(String[] args) throws InterruptedException {

    // 创建一个自动售卖机
    VendingMachine machine = new VendingMachine();

    // 为了演示所有新创建的线程执行完毕之后再退出主线程
    CountDownLatch latch = new CountDownLatch(11);

    List<Thread> threadList = new ArrayList<>();

    // 使用10个线程模拟10名用户执行购物动作
    for (int i = 0; i < 10; i++) {
        Thread t = new Thread(() -> {
            machine.sale();
            latch.countDown();
        });
        t.setName("Customer-" + i);
        threadList.add(t);
    }

    // 创建一个线程模拟补货员执行一次补货动作
    Thread deliverymanThread = new Thread(() -> {
        machine.stock();
        latch.countDown();
    });
    deliverymanThread.setName("Deliveryman");
    threadList.add(deliverymanThread);

    // 借用 parallel 方法并行地去启动线程
    threadList.stream().parallel().forEach(t -> t.start());

    latch.await();// 等待以上线程执行完成
    machine.printLockTimes();
    System.out.println("End.");

}

运行结果：

[Customer-2] 开始购物...
[Customer-2] 购物完成，剩余可售量: 4
[Customer-1] 开始购物...
[Customer-1] 购物完成，剩余可售量: 3
[Customer-4] 开始购物...
[Customer-4] 购物完成，剩余可售量: 2
[Customer-0] 开始购物...
[Customer-0] 购物完成，剩余可售量: 1
[Customer-9] 开始购物...
[Customer-9] 购物完成，剩余可售量: 0
[Deliveryman] 开始进货...
[Deliveryman] 进货完成，可售量: 5
[Customer-8] 开始购物...
[Customer-8] 购物完成，剩余可售量: 4
[Customer-5] 开始购物...
[Customer-5] 购物完成，剩余可售量: 3
[Customer-7] 开始购物...
[Customer-7] 购物完成，剩余可售量: 2
[Customer-6] 开始购物...
[Customer-6] 购物完成，剩余可售量: 1
[Customer-3] 开始购物...
[Customer-3] 购物完成，剩余可售量: 0
锁的次数：36
End.

从运行结果来看，程序正确的执行了购物和入货操作，即购物的前提条件是可售量大于0，入货的前提条件是可售量为0。再看最后执行加锁的次数为36，重新运行了几次程序，这个数字是几十到几百不等，实际上这个次数只要大于等于11都是正常的结果，最小为11是因为有10个购物动作和1个入货动作。

这里重复执行锁操作实际上是一种资源的浪费。 这个时候条件变量就派上用场了。使用条件变量先让不满足条件的线程挂起，由另外的线程在满足一定条件时通知并唤醒该线程。用在本文的例子，就是说：

  • 当用户购物的时候，如果可售量为0，则挂起该线程。等待入货操作之后（可售量不为0），唤醒购物线程。
  • 当入货线程进来时，如果可售量不为0，则挂起。用户购物后（货架有空余）则会通知后台（补货员）补货，但是这里做了一个假设，补货员不需要货架一有空余就补货，而是只有在可售量为0的时候才进行补货。

由于条件变量只能单向的通知，这里需要购物线程通知入货线程，入货线程通知购物线程，双向的通知需要两个条件变量。

「Java」 Condition

以下为基于条件变量的实现：

新增 Condition 类型的成员变量 notEmpty，notFull。
修改 sale()、stock()，将外层 while 循环去掉，将 if 条件语句修改为 while 语句，并在 while 循环里面添加相关条件变量的 await() 方法（至于这里为什么要用 while 循环，看完代码再补充说明）。表示当不满足指定条件时执行等待操作。


// VendingMachine 表示自动售卖机
static class VendingMachine {

    // 使用锁来保证，售卖和补货不能同时进行
    private final MyLock lock;
    private final Condition notEmpty;// 表示货架不为空
    private final Condition notFull;// 表示货架不满，有空位
    private final int maxSize;// 最大可售量
    private int remainder;// 剩余可售量


    public VendingMachine() {
        lock = new MyLock();
        notEmpty = lock.newCondition();// 需要基于锁来创建条件变量
        notFull = lock.newCondition();// 需要基于锁来创建条件变量
        maxSize = 5;
        remainder = maxSize;// 初始可售量为5
    }

    // 售卖
    public void sale() {
        lock.lock();// 获得锁之后才能往下执行
        try {
            while (remainder == 0) {
                notEmpty.await();// 剩余可售量为0，等待有货可售
            }
            System.out.printf("[%s] 开始购物...\n",
                    Thread.currentThread().getName());
            TimeUnit.MILLISECONDS.sleep(200);
            remainder--;// 可售量减1
            System.out.printf("[%s] 购物完成，剩余可售量: %d\n",
                    Thread.currentThread().getName(), remainder);
            // 购买之后可售量是未满的状态，通知补货员进行补货
            // 这里只有一个补货员，所以可以使用 signal 单发通知
            notFull.signal();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();// 解锁
        }
    }

    // 补货
    public void stock() {
        lock.lock();// 获得锁之后才能往下执行
        try {
            while (remainder > 0) {
                notFull.await();// 剩余可售量大于0，继续等待
            }
            // 当可售量为0时，结束 while 循环，进入补货流程
            System.out.printf("[%s] 开始进货...\n",
                    Thread.currentThread().getName());
            TimeUnit.MILLISECONDS.sleep(500);
            remainder = maxSize;// 一次性补满货
            System.out.printf("[%s] 进货完成，可售量: %d\n",
                    Thread.currentThread().getName(), remainder);
            notEmpty.signalAll();// 通知所有等待的用户补货完成，有货可售
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();// 解锁
        }
    }

    public void printLockTimes() {
        System.out.printf("锁的次数：%d\n", lock.getLockTimes());
    }

}

运行结果：

[Customer-2] 开始购物...
[Customer-2] 购物完成，剩余可售量: 4
[Customer-0] 开始购物...
[Customer-0] 购物完成，剩余可售量: 3
[Customer-3] 开始购物...
[Customer-3] 购物完成，剩余可售量: 2
[Customer-9] 开始购物...
[Customer-9] 购物完成，剩余可售量: 1
[Customer-8] 开始购物...
[Customer-8] 购物完成，剩余可售量: 0
[Deliveryman] 开始进货...
[Deliveryman] 进货完成，可售量: 5
[Customer-5] 开始购物...
[Customer-5] 购物完成，剩余可售量: 4
[Customer-7] 开始购物...
[Customer-7] 购物完成，剩余可售量: 3
[Customer-6] 开始购物...
[Customer-6] 购物完成，剩余可售量: 2
[Customer-4] 开始购物...
[Customer-4] 购物完成，剩余可售量: 1
[Customer-1] 开始购物...
[Customer-1] 购物完成，剩余可售量: 0
锁的次数：11
End.

从运行结果来看，符合预期。跟之前没有基于条件变量的实现相比，只有一处有差异，就是执行加锁动作的次数，这里无论运行多少次都是11。这是因为条件变量在这里，实际上是起到了“协调”的作用，避免了无谓的锁的争抢。
再来说说在执行条件变量的 await() 方法时，为什么要在一个循环里面。这里是为了保证，当一个线程被唤醒时，相关的条件不一定成立。比如说，条件变量 notFull 需要满足可售量为0时才进行补货，当线程被唤醒时，不一定满足该条件，可能是在可售量为[0,4]之间被唤醒。再比如说，如果补货完成之后，给10个用户发起了通知，这时只有5个可以购买成功，另外5个无货可买。所以，这里的循环非常有必要。

「Go」sync.Cond

以下代码是基于 Go 语言条件变量 sync.Cond 的实现：

// VendingMachine 自动售卖机
type VendingMachine struct {
	lock      sync.Mutex //  互斥锁，开箱即用的类型
	notEmpty  sync.Cond  // 表示货架不为空
	notFull   sync.Cond  // 表示货架不满，有空位
	maxSize   uint8      // 最大可售量
	remainder uint8      // 剩余可售量
}

// 售卖，参数 name 为用户名称
func (vm *VendingMachine) sale(name string) {
	vm.lock.Lock() // 获得锁之后才能往下执行
	for vm.remainder == 0 {
		vm.notEmpty.Wait() // 剩余可售量为0，等待有货可售
	}
	fmt.Printf("[%s] 开始购物...\n", name)
	time.Sleep(time.Millisecond * 200)
	vm.remainder-- // 可售量减1
	fmt.Printf("[%s] 购物完成，剩余货物数量: %d\n", name, vm.remainder)
	vm.lock.Unlock() // 解锁
	// 购买之后可售量是未满的状态，通知补货员进行补货
	// 这里只有一个补货员，所以可以使用 signal 单发通知
	vm.notFull.Signal()
}

// 补货，参数 name 为补货员名称
func (vm *VendingMachine) stock(name string) {
	vm.lock.Lock() // 获得锁之后才能往下执行
	for vm.remainder > 0 {
		vm.notFull.Wait() // 剩余可售量大于0，继续等待
	}
	// 当可售量为0时，结束 for 循环，进入补货流程
	fmt.Printf("[%s] 开始进货...\n", name)
	time.Sleep(time.Millisecond * 500)
	vm.remainder = vm.maxSize
	fmt.Printf("[%s] 进货完成，剩余货物数量: %d\n", name, vm.remainder)
	vm.lock.Unlock()        // 解锁
	vm.notEmpty.Broadcast() // 通知所有等待的用户补货完成，有货可售
}

// NewVendingMachine 新建一个自动售卖机
func NewVendingMachine() *VendingMachine {
	vm := &VendingMachine{}
	vm.notEmpty.L = &vm.lock // 需要基于锁来创建条件变量
	vm.notFull.L = &vm.lock  // 需要基于锁来创建条件变量
	vm.maxSize = 5
	vm.remainder = vm.maxSize // 初始可售量为5
	return vm
}

func main() {
	// 创建一个自动售卖机
	vm := NewVendingMachine()

	// 为了演示所有新启用的 goroutine 执行完毕之后再退出主 goroutine
	var wg sync.WaitGroup
	wg.Add(11) // 11表示一共启用了11个 goroutine 需要等待结束

	// 启用10个 goroutine 模拟5名用户执行购物动作
	for i := 0; i < 10; i++ {
		go func(i int) {
			defer wg.Done()
			vm.sale(fmt.Sprintf("Customer-%d", i))
		}(i)
	}

	// 启用1个 goroutine 模拟补货员执行一次补货动作
	go func() {
		defer wg.Done()
		vm.stock("Deliveryman")
	}()

	wg.Wait() // 等待以上 gorountine 执行完成
	fmt.Println("End.")

}

运行结果：

[Customer-4] 开始购物...
[Customer-4] 购物完成，剩余货物数量: 4
[Customer-3] 开始购物...
[Customer-3] 购物完成，剩余货物数量: 3
[Customer-0] 开始购物...
[Customer-0] 购物完成，剩余货物数量: 2
[Customer-1] 开始购物...
[Customer-1] 购物完成，剩余货物数量: 1
[Customer-7] 开始购物...
[Customer-7] 购物完成，剩余货物数量: 0
[Deliveryman] 开始进货...
[Deliveryman] 进货完成，剩余货物数量: 5
[Customer-5] 开始购物...
[Customer-5] 购物完成，剩余货物数量: 4
[Customer-8] 开始购物...
[Customer-8] 购物完成，剩余货物数量: 3
[Customer-6] 开始购物...
[Customer-6] 购物完成，剩余货物数量: 2
[Customer-2] 开始购物...
[Customer-2] 购物完成，剩余货物数量: 1
[Customer-9] 开始购物...
[Customer-9] 购物完成，剩余货物数量: 0
End.

运行结果也是符合预期。

拓展

比对 Java 和 Go 语言的两种基于条件变量的实现方式，有一个最大的区别：Go 语言里面条件变量的通知 Signal() 和 Broadcast()，并没有在锁的保护下执行，而是在 Unlock() 之后执行。
具体的原因首先我们需要看一下 sync.Cond 的 Wait() 方法，代码如下。从第4行可以看到，Wait() 首先会执行一次解锁的操作（这个时候其他 Goroutine 就有机会执行锁定操作了），然后让当前的 Goroutine 处于等待状态，等待相关条件变量的通知。如果当前的 Gorountie 被唤醒，则会进行锁定操作。

func (c *Cond) Wait() {
	c.checker.check()
	t := runtime_notifyListAdd(&c.notify)
	c.L.Unlock()
	runtime_notifyListWait(&c.notify, t)
	c.L.Lock()
}

总结来说，就是处于等待状态的 Goroutine，在被其他 Goroutine 唤醒时会尝试解锁，所以执行唤醒操作的通知方法 Signal() 和 Broadcast()，总是应该在解锁之后才执行，这样被唤醒的 Goroutine 可以更顺利的执行锁定操作。
而 Java 的实现方式与此不同，实际上是参考了 MESA 模型，由于篇幅有限，后续有机会再介绍。

更多该系列文章请查看：Java & Go 并发编程系列

33 多线程同步之Condition
Jian Sun_的博客
08-16 427
条件对象Condition能让一个线程A停下来，等待其他线程B， 线程B满足了某个条件后通知（notify）线程A继续运行。线程首先获取一个条件变量锁，如果条件不足，则该线程等待（wait）并释放条件变量锁； 如果条件满足，就继续执行线程，执行完成后可以通知（notify）其他状态为wait的线程执行。其他处于wait状态的线程接到通知后会重新判断条件以确定是否继续执行。 【示例 1】使用条件对象Condition同步多线程。 运行结果如下： 程序实例化了一个Condition对象cond .
【Go】被遗忘的并发原语——sync.Cond
TomCN0803的博客
02-17 1420
本文介绍了 Go 语言标准库提供的条件变量并发原语`sync.Cond`的一般使用方法，并对比其与 Go 原生的 channel 在不同场景时的优劣。然后我们浅析了`sync.Cond`的源码实现，有助于我们对`sync.Cond`使用方式的理解。
又见队列同步器——Condition接口的实现
Hopefully Sky的博客
03-22 874
Condition接口与Object监视器方法 任意一个Java对象，都拥有一组监视器方法（定义在java.lang.Object上），主要包括wait()、wait(long timeout)、nofity()以及notifyAll()方法，这些方法与synchronized同步关键字配合，可以实现等待/通知模式。Condition接口也提供了类似Object的监视器方法，与Lock配合也可以实...
线程同步工具Condition详解
qq_34800986的博客
05-15 358
Condition可以代替Object监视器方法（ wait ， notify和notifyAll ），必须和Lock配合使用， Lock替换synchronized方法和语句的使用， Condition取代了对象监视器方法的使用。可以使某个线程挂起，直到其他线程唤醒，就像Object.wait（）方法，一个Condition实例本质上绑定到一个锁。 要获得特定Condition实例，请使用lLock的newCondition()方法。
并发编程 — Condition 使用及原理详解
small_love的专栏
12-19 1085
一、概述 Condition本身也是一个接口，其功能和Object类中 wait/notify类似。Object中的 wait 和 notify方法需要与synchronized关键字配合使用，可实现线程间的等待/通知功能。Condition 接口也是提供了类似的功能，但是需要与Lock配合使用，可实现等待/通知模式。 二、Condition 接口与示例 Condition 定义了等待 / 通知两种类型的方法，当前线程调用这些方法时，需要提前获取Condition 对象关联的锁。Condition .
怎么理解Condition
lxgwm2008的专栏
02-14 1060
转自：http://www.liuinsect.com/2014/01/27/%E6%80%8E%E4%B9%88%E7%90%86%E8%A7%A3condition/ 在java.util.concurrent包中，有两个很特殊的工具类，Condition和ReentrantLock,使用过的人都知道，ReentrantLock（重入锁）是jdk的concurrent包提供的一种
72、Go语言并发秘籍：掌握sync.Cond实现条件变量
silenceallat的博客
06-25 973
本文深入介绍了Go语言中的并发原语——`sync.Cond`，通过生动的例子和实用的技巧，让读者轻松理解条件变量的概念和使用场景。从基础的等待和通知，到复杂的生产者-消费者问题和共享资源访问控制，本文展示了`sync.Cond`在多goroutine编程中的强大作用。无论你是Go语言初学者，还是有一定经验的开发者，本文都能帮助你更上一层楼，让你的Go语言并发编程更加得心应手。
Golang——常用库sync
分享包括但不限于计算机基础知识、数据结构与算法、Golang技术栈。年与时驰，意与日去，遂成枯落，多不接世，悲守穷庐，将复何及！
01-17 1680
本文详细介绍Golang的常用库sync，提供了一系列工具来处理 **并发编程** 中的同步问题。
go语言同步教程之条件变量
09-20
在Go语言中，同步是并发编程中至关重要的一个环节，确保多个goroutine之间的协作和数据一致性。条件变量（`sync.Cond`）是Go标准库提供的一种高级同步原语，它允许goroutine在满足特定条件时暂停执行，并在条件变化...
JAVA并发编程——源码原理全面剖析与重点梳理
lianghongliang66的博客
05-25 1376
帧与帧栈 每个线程有一块栈内存 每个栈由多个栈帧组成，每个栈帧对应每次方法调用占用的内存 每个线程只能有一个活动栈帧，对应当前正在执行的那个方法 线程上下文切换 线程的CPU时间片用完 垃圾回收 有更高优先级的线程需要运行 线程自己调用了sleep、yield、wait、join、park、synchronized、lock等方法 其中程序计数器的作用 操作系统保存当前线程的状态，记住下一条jvm指令的执行地址，用于恢复线程的状态 PS：状态：程序计数器、栈中每个帧栈的信息 线程状态
16、Condition和Synchronized的区别
u011603018的博客
03-18 651
###区别 Codition必须拿到锁 Lock lock=new ReentactLock(); Codition cod1=lock.newCodition(); Codition cod2=lock.newCodition(); Lock 和Synchronized 都是加1把锁，但是codition是条件锁，可以设置多个条件 codition 内部实现了1个等待队列。等待的条件，就排在等待...
synchronized和lock的区别总结;用新的LOCK的有什么好处?,Condition用法,condition精确唤醒
sinat_36572927的博客
05-20 745
1.synchronized是jvm层面,属于java关键字, sync底层指令, monitorenter(底层是通过monitor对象来完成,其实wait/notify等方法也是依赖于monitor对象,所以只有在同步块或方法中才能调用notify/wait等方法); monitorexit(退出同步代码块),这个sync有两次退出,一种是正常退出,第二种异常退出,总之,synchro...
Java线程同步synchronized,Lock,Condition
u014412719的博客
04-19 324
参考 http://www.infoq.com/cn/articles/java-memory-model-5 深入理解Java内存模型（五）——锁 http://www.ibm.com/developerworks/cn/java/j-jtp10264/ Java 理论与实践: JDK 5.0 中更灵活、更具可伸缩性的锁定机制 http://blog.csdn.net/ghsau/ar
Condition接口实现
weixin_39590058的博客
09-17 233
概述 Object 方法 Condition 方法 区别 void wait() void await() void wait(long timeout) long awaitNanos(long nanosTimeout) 时间单位，返回值 void wait(long timeout, int nanos) boolean await(long time, TimeU...
【Java&Go并发编程系列】1.阻塞队列与通道——BlockingQueue VS channel（上篇）
PlainTech的博客
08-26 1337
channel（通道）是 Go 语言非常具有代表性的数据类型，相当于一个先进先出的队列。通道支持发送和接收操作，用<-表示，箭头的方向代表数据的传输方向，并且发送操作之间是互斥的，接收操作之间也是互斥的。使用 channel 可以很方便的在多个 Goroutine（用户级线程，也称协程）之间进行通信。 channel 分为缓冲通道和非缓冲通道（容量为0）。本文将非缓冲通道、缓冲通道和 Java 中的阻塞队列 SynchronousQueue、LinkedBlockingDeque 做一个类比。
【Java&Go并发编程系列】2.阻塞队列与通道——BlockingQueue VS channel（下篇）
PlainTech的博客
08-26 674
上一篇将非缓冲通道、缓冲通道和 Java 中的阻塞队列 SynchronousQueue、LinkedBlockingDeque 做一个类比。本篇将进一步介绍有限容量的 buffered channel 和 LinkedBlockingQueue 的基本操作。然后再单独说明零容量的工具与有限容量在操作上的主要差异。
Java & Go 并发编程系列
PlainTech的博客
08-26 666
该系列的文章，根据每篇文章的主题，分别用示例代码介绍 Java 和 Go 语言中的相关实现。涉及到 Java 中的 BlockingQueue、Future、CountDownLatch、invokeAny、invokeAll、Semaphore、Lock、ReadWriteLock、Condition等，涉及到 Go 中到 channel、sync.WaitGroup、sync.Mutex、sync.RWMutex、sync.Cond 等。
golang sync.Cond 详解
最新发布
08-16
<think>首先，用户的问题是关于深入理解Golang中sync.Cond的使用和原理。我需要提供详细解析，包括使用方法和原理说明。 系统级指令要求： - 所有行内数学表达式用$...$格式，但这个问题是关于Golang的，可能不涉及数学表达式。所以，我应该避免不必要的数学，除非有相关。 - 独立公式用$$...$$，但同样，可能不适用。 - LaTeX语法正确：确保任何公式正确。 - 使用中文回答：整个回答用中文。 - 生成相关问题：在回答末尾添加相关问题。 - 引用段落末尾添加引用标识：如[^1]，但用户没有提供引用源，所以我需要基于一般知识。用户说“参考站内引用:”，但没指定，所以我假设没有具体引用，但要自然地添加标识。指令说“引用的段落末尾”，意思是如果引用外部内容，添加标识。既然没有提供，我应该避免虚构引用，或者基于常识添加。 用户可见层要求： - 回答结构清晰，帮助用户逐步解决问题。 - 保证回答真实可靠：基于我的知识，sync.Cond是Golang的同步原语。 关键点： - sync.Cond是什么：条件变量，用于goroutine间的同步。 - 使用方法：如何创建、使用、等待和通知。 - 原理说明：内部机制，如何与互斥锁工作。 结构化回答： 1. 介绍sync.Cond：定义和用途。 2. 使用方法：代码示例。 3. 原理：内部工作原理。 4. 注意事项：常见错误和最佳实践。 5. 生成相关问题。 使用中文回答。 生成相关问题：在末尾添加相关问题。 引用标识：如果引用外部内容，添加。但用户没提供，所以我需要基于标准文档或知识。或许在解释原理时，提到Golang文档或相关资源。 大纲： - 引言：简述sync.Cond。 - 使用方法：步骤和代码。 - 原理：底层实现。 - 总结。 - 相关问题。 代码示例：用代码块展示。 确保LaTeX：如果涉及公式，如时间复杂性，但可能不必要。 最后，添加相关问题。</think>### Golang sync.Cond 详细解析 在 Golang 中，`sync.Cond` 是一个条件变量（Condition Variable），用于实现 goroutine 间的同步通信。它通常与互斥锁（如 `sync.Mutex`）结合使用，解决生产者-消费者问题或等待特定条件的场景。条件变量允许 goroutine 在条件不满足时挂起等待，并在条件变化时被唤醒。下面我将从使用方法、原理说明等方面进行详细解析，帮助您深入理解。本解析基于 Golang 官方文档和标准库实现[^1]。 #### 1. sync.Cond 的使用方法 `sync.Cond` 的核心方法包括 `Wait()`、`Signal()` 和 `Broadcast()`。使用前必须先创建一个 `sync.Cond` 实例，通常需要一个互斥锁作为参数。以下是使用步骤和代码示例： **步骤：** 1. **创建条件变量**：通过 `sync.NewCond(l Locker)` 创建，其中 `l` 是实现了 `Locker` 接口的对象（如 `sync.Mutex`）。 2. **等待条件**：在 goroutine 中调用 `Wait()` 方法挂起当前 goroutine，直到条件满足。`Wait()` 会自动释放锁，并在唤醒后重新获取锁。 3. **通知唤醒**：使用 `Signal()` 唤醒一个等待的 goroutine，或 `Broadcast()` 唤醒所有等待的 goroutine。 4. **保护共享资源**：在操作共享变量时，必须使用互斥锁加锁和解锁。 **代码示例：** 以下是一个生产者-消费者模型的简单实现。生产者向队列添加数据，消费者在队列非空时消费数据。 ```go package main import ( "fmt" "sync" "time" ) func main() { var mu sync.Mutex cond := sync.NewCond(&mu) // 创建条件变量，基于互斥锁 queue := []int{} // 共享队列 // 消费者 goroutine go func() { for { mu.Lock() // 加锁保护共享资源 for len(queue) == 0 { cond.Wait() // 队列为空时挂起等待 } item := queue[0] queue = queue[1:] fmt.Printf("消费者消费: %d\n", item) mu.Unlock() // 解锁 } }() // 生产者 goroutine go func() { for i := 1; i <= 5; i++ { mu.Lock() // 加锁 queue = append(queue, i) fmt.Printf("生产者生产: %d\n", i) cond.Signal() // 唤醒一个等待的消费者 mu.Unlock() // 解锁 time.Sleep(1 * time.Second) } }() time.Sleep(6 * time.Second) // 等待所有操作完成 } ``` **代码说明：** - **`cond.Wait()`**：消费者在队列为空时调用，挂起自身。`Wait()` 内部会自动释放锁（`mu`），允许生产者获取锁；当被唤醒时，它会重新获取锁。 - **`cond.Signal()`**：生产者添加数据后调用，唤醒一个等待的消费者。如果需要唤醒所有等待者，使用 `cond.Broadcast()`。 - **互斥锁保护**：所有对 `queue` 的操作都在 `mu.Lock()` 和 `mu.Unlock()` 之间，确保共享资源安全。 - **注意事项**： - 在调用 `Wait()` 前，必须持有锁，否则可能导致竞态条件。 - `Wait()` 方法应放在循环中检查条件（如 `for len(queue) == 0`），避免虚假唤醒（spurious wakeup）。 - 使用 `Signal()` 或 `Broadcast()` 后，应尽快解锁，以减少锁竞争。 #### 2. sync.Cond 的原理说明 `sync.Cond` 的底层实现基于 Golang 的运行时调度器（scheduler）和等待队列（wait queue）。以下是关键原理： **内部结构：** `sync.Cond` 的结构体包含一个互斥锁引用和一个等待队列（存储等待的 goroutine）： ```go type Cond struct { L Locker // 关联的互斥锁 notify notifyList // 等待队列，链表结构 } ``` 其中 `notifyList` 是一个链表，记录所有调用 `Wait()` 的 goroutine。 **工作流程：** 1. **`Wait()` 方法原理**： - 当 goroutine 调用 `Wait()` 时，它先释放锁（`c.L.Unlock()`），然后将自身加入等待队列（`notifyList`）。 - 随后，goroutine 被挂起（进入阻塞状态），由调度器切换到其他 goroutine。 - 当被 `Signal()` 或 `Broadcast()` 唤醒时，goroutine 重新尝试获取锁（`c.L.Lock()`），并继续执行。 2. **`Signal()` 和 `Broadcast()` 原理**： - **`Signal()`**：从等待队列头部取出一个 goroutine 并唤醒它。唤醒操作通过运行时函数 `runtime_Semrelease` 实现，本质是发送一个信号量。 - **`Broadcast()`**：唤醒等待队列中所有 goroutine，内部遍历链表并逐个唤醒。 - 唤醒后，goroutine 会从 `Wait()` 返回，并重新检查条件（如队列是否非空）。 **与互斥锁的协作：** - 条件变量必须与互斥锁配合使用，因为共享资源（如示例中的 `queue`）需要锁保护。 - `Wait()` 的原子操作：释放锁和加入等待队列是原子的，避免了竞态。 - **性能特点**：`Signal()` 的时间复杂度为 $O(1)$（唤醒一个等待者），`Broadcast()` 为 $O(n)$（n 为等待者数量）。`Wait()` 操作涉及调度，可能导致上下文切换开销。 **设计哲学：** - **避免忙等待**：相比轮询检查条件，`sync.Cond` 让 goroutine 挂起，减少 CPU 浪费。 - **公平性**：Golang 的等待队列通常是 FIFO（先进先出），但唤醒顺序不保证严格公平，取决于调度器。 - **虚假唤醒处理**：Golang 的 `sync.Cond` 可能因系统原因发生虚假唤醒（即没有通知时被唤醒），因此必须在循环中检查条件。 #### 3. 最佳实践和常见问题 - **适用场景**：适合等待特定事件（如任务完成、资源可用），常见于并发控制、任务协调等。 - **常见错误**： - 忘记在 `Wait()` 前加锁：导致数据竞争。 - 未使用循环检查条件：虚假唤醒可能引发逻辑错误。 - 过度使用 `Broadcast()`：如果只唤醒一个等待者足够，优先用 `Signal()` 以减少开销。 - **优化建议**： - 将条件变量封装在结构体中，提高代码可读性。 - 使用 `context.Context` 结合超时控制，避免死锁。 #### 总结 `sync.Cond` 是 Golang 中强大的同步原语，通过等待队列和互斥锁实现高效 goroutine 通信。正确使用时，它能显著提升并发程序的性能和可靠性。记住：始终在锁保护下操作共享变量，并在循环中调用 `Wait()`。如需更多细节，参考 Golang 官方文档[^1]。
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符  | 博主筛选后可见
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值