结构体 Ref 

pub struct Ref<'a, T> { /* private fields */ }

返回内部值的引用。

未完成的借用 会对内部值 持有读锁。 这意味着 长时间存活的借用 可能会 导致生产者一半阻塞。 建议 尽可能 保持借用 短暂存在。 此外， 如果你在 允许 !Send future 的环境中运行， 则必须确保 返回的 Ref 类型 永远 不会在 .await 点之间 保持存活， 否则 可能会 导致死锁。

锁的优先级策略 取决于 底层锁实现， 此类型 不保证 将使用 任何特定的策略。 特别的， 在 send 中 等待获取锁的生产者 可能会 也可能不会 阻塞 对 borrow 的并发调用， 例如：

Potential deadlock example

// Task 1 (on thread A)    |  // Task 2 (on thread B)
let _ref1 = rx.borrow();   |
                           |  // will block
                           |  let _ = tx.send(());
// may deadlock            |
let _ref2 = rx.borrow();   |

实现

impl<'a, T> Ref<'a, T>

pub fn has_changed(&self) -> bool

指示借用的值自上次被标记为已读以来是否被视为已更改。

与 Receiver::has_changed() 不同，如果通道已关闭，此方法不会失败。

从 Sender 借用时，此函数将始终返回 false。

示例

use tokio::sync::watch;

let (tx, mut rx) = watch::channel("hello");

tx.send("goodbye").unwrap();
// The sender does never consider the value as changed.
assert!(!tx.borrow().has_changed());

// Drop the sender immediately, just for testing purposes.
drop(tx);

// Even if the sender has already been dropped...
assert!(rx.has_changed().is_err());
// ...the modified value is still readable and detected as changed.
assert_eq!(*rx.borrow(), "goodbye");
assert!(rx.borrow().has_changed());

// Read the changed value and mark it as seen.
{
    let received = rx.borrow_and_update();
    assert_eq!(*received, "goodbye");
    assert!(received.has_changed());
    // Release the read lock when leaving this scope.
}

// Now the value has already been marked as seen and could
// never be modified again (after the sender has been dropped).
assert!(!rx.borrow().has_changed());

Trait 实现

impl<'a, T: Debug> Debug for Ref<'a, T>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

使用给定的格式化器格式化此值。 更多信息

impl<T> Deref for Ref<'_, T>

type Target = T

解引用后得到的类型。

fn deref(&self) -> &T

解引用此值。