正念是什么

与事物的现实性达成一致，我们可以通过拥抱它们来接受它们，在一刻一刻的觉知里。

正念不是一个概念，而是一种与生命保持明智关系的方式，在生命唯一的当下展开。

正念的态度因素

如果想要长期地实践正念，并将正念融入到生活当中，那么我们需要关注一些正念的态度因素。对于这些正念的态度因素，最主要的是让这些概念融入到脑内，心里，而并非是强制遵守它。记住即可。

不做评判

不做评判并不意味着我们不去对事件品头论足，而是说==意识到在做评判，并且有目的地不陷入到评判中，这本身就是一种美丽而又温柔的修习。==从某种意义上来说，这种修习的目的是让我们==足够关心自己以及我们所处的环境，从而不会有那种瞬间崩溃，也不会拘泥于喜欢或者不喜欢，想要或者不想要。==归根结底，当我们做出一个评判时，实际上我们就成为了它的囚徒。因为当事情发生时，评判降低了我们应对挑战的可能性。我们会困在一个观点中，而这个观点可能并不是一个完整地故事，完整地视角（盲人摸象）。

==关键点：不被自己地喜欢和厌恶所禁锢。把自己从下意识去评判“好”与“恶”这个习惯中解救出来，从自己的欲望和恐惧中解救出来。==

耐心

当我们失去耐心时，受害者往往是与我们生活在一起的人，我们最爱的人，还有和我们一起工作的人。

我们都希望朝着一个真正变化的、有益的方向前进。但如禅语所说，==“you can’t push the river”==，不能逆势而为。为了到达某个地方而逼自己加快脚步是不明智的，因为这样往往会让自己忘记了真正的目的。

耐心是我们可以培养的一种非常可贵的品质。特别是在我们当下这个时代，它显得愈发重要。在这个电子信息时代，我们被电子产品吸引，甚至对其上瘾。我们的社会变成了一个点击型社会，所有在手机或者电脑上呈现的东西，逐步变得愈来愈“快餐”和“标题党”。它们通过社交媒体分发给我们，给我们想要的东西。这些“快餐”或者朋友圈的“点赞”实际上触发了我们大脑中神经元的连接，刺激多巴胺的释放，在这一瞬间会给人你一种非常非常满足的感觉。我们会因为朋友圈的一个“点赞”获得极大的满足感，但是这只持续了不到一秒，然后呢？我们会想要更多。我们开始观察社交媒体的生态，然后变得愈发不耐烦，这就是上瘾的一种表现，而我们甚至对此都毫无觉察。

所以耐心实际上培养了对这种事情的免疫力。因为当我们意识到有那种想要得到什么的冲动时，我们可以让自己慢下来（延迟满足）。==所以在一整天里，不断地觉察到自己有多么不耐烦，这便能帮助我们培养耐心。==

我们不必强迫自己变得耐心，而是去关注那些真的陷进去的时刻，强烈地想要去得到某个结果，然后引发出一系列蝴蝶效应般的结果，最后我们再也无法被满足（成瘾）。

初学者心态

In the beginner’s mind there are many possibilities, in the expert’s mind, there are few.

—— Suzuki Roshi（铃木俊隆）

==在某种意义上，我们所知道地一切都会妨碍我们看到那里的一些东西。因为我们是在透过我们的有色眼镜看面前的东西。==原有的知识结构，可能会演变为严重的问题。因为它会限定你，让你在已知的领域中对那些新兴未知的苗头视而不见，而那才是你想要发现的，全新的，前所未见的东西。

信任

将信任带入修习实际上是在提醒自己有很多我们可以信任的东西，就比如我们可以相信我们的呼吸正在i体内穿梭，我们的脚将带着我们前行，我们的心脏仍会在今晚继续跳动。这些都是在提醒我们在当下这个时刻发生的事情中，有多少是可信的，是真正值得信任的。 最重要的是，我们的心是否值得信赖。==唯一能让自己的新值得信赖的方法就是相信自己，相信自己值得信赖，即便是我们把注意力放在了可能辜负自己或者他人信任的事情上==。

信任是深刻的，象征洞察力的源泉。它包括如何将内在与外在的经历发散开，使其保持良好的关联。

不争

不争不是反对积极。**不争可能会要你去做更多的事情——不依附于结果，不去拼命让结果显得更好，而是确保当下正在做的每一件都具有完整性，然后水到渠成。**现实中我们会有DDL，会有一些杂七杂八的事情，看起来和不争的概念相悖。但是当把不争带到我们的意识前，让我们专注于当下，实际上可以帮助我们更快地完成工作。

当你的目标非常明确的时候，不争是很有效的。当我们太执着于胜利的结果时，可能会得不到很好的结果，因为心浮气躁。不争是将我们对胜利的渴望剥离出来，这并不意味着我们会成为一个消极的人，总是一事无成。

接纳

接纳意味着看到事物的现实，承认并接受它们就是这样的。 接纳并不意味着我们不能努力去改变它们，接纳意味着看清现实，意味着你有时会意识到一些不可接受的事情。然后的问题是，我们该如何与这些不可容忍的事情，需要改变的事情保持明智的关系？这和消极的顺从一点关系都没有。

==我们需要看到真实的现实，正在发生的一切，看到它的复杂性以及简洁性。看得清楚，然后开始行动。接纳意味着对事物的现状有深刻洞察的认识，如果你是唯一一个看清这件事情走向的人，相信自己。==

Go的Channel在runtime里面是一个hchan的结构体，每次我们make一个新的channel时，runtime从heap内分配一个hchan结构体管理channel。

type hchan struct {
    qcount   uint           // total data in the queue
    dataqsiz uint           // size of the circular queue
    buf      unsafe.Pointer // points to an array of dataqsiz elements
    elemsize uint16
    closed   uint32
    elemtype *_type // element type
    sendx    uint   // send index
    recvx    uint   // receive index
    recvq    waitq  // list of recv waiters
    sendq    waitq  // list of send waiters

    // lock protects all fields in hchan, as well as several
    // fields in sudogs blocked on this channel.
    //
    // Do not change another G's status while holding this lock
    // (in particular, do not ready a G), as this can deadlock
    // with stack shrinking.
    lock mutex
}

• qcount：当前channel queue内的element数目，当qcount等于dataqsiz时，表示channel buffer已经满了，send channel会被阻塞；
• dataqsiz：channel的buffer大小，也就是我们在make时设定的值。dataqsiz在channel创建后不会再变动，因此channel的buffer是不会动态扩容的；
• buf：buffered channel缓存elements的内存地址。是一个数组实现的环形队列；
• elemsize：element类型大小；
• closed：channel是否已经被关闭，防止关闭已经关闭的channel；
• elemtype：channel element 类型；
• sendx：buffer中下一个生产的element的index；
• recvx：buffer中下一个消费的element的index；
• recvq：阻塞的接收channel，是一个sudog的链表
• sendq：阻塞的发送channel，是一个sudog的链表

当buffer没有满时，send channel发送elements时直接把elements放在buf内，增加sendx和qcount；当buffer满时，send channel被阻塞，并加入到sendq链表内，等待被唤醒；

为什么Rust不做green threading

• remove-runtime rfcs

• remove-runtime pull request

Send 和 Sync

Rust中几乎所有的并发特性都是标准库或者第三方库提供的，真正由Rust语言本身提供的很少。而std::marker中的traits Send和Sync算是其中一个。

**实现Send的类型值的所有权可以在线程间传递。**Rust中绝大多数类型都实现了Send，但也有些例外，如Rc<T>：因为如果将Rc<T>的拷贝值的所有权在多个线程中传递，Rust无法保证Rc<T>引用值的正确性。

实现Sync的类型表示该类型值可以在多个线程中被引用。也就是说，如果&T实现了Send，那么类型T就是Sync。

Send和Sync markers其实就是将其他语言中的一些潜规则显式地标明出来，让编译器提前检查出代码中的隐患。

线程原语

use std::thread;

fn main() {
    let v = vec![1, 2, 3];

    let handle = thread::spawn(move || {
        println!("Here's a vector: {:?}", v);
    });

    handle.join().unwrap();
}

thread::spawn新建一个线程，执行传递的闭包函数，返回一个JoinHandler，可以在主线程中调用join等待子线程结束。move用于强制闭包获取它使用的变量的所有权。

我们可以看看thread::spawn的实现：

#[stable(feature = "rust1", since = "1.0.0")]
pub fn spawn<F, T>(f: F) -> JoinHandle<T>
where
    F: FnOnce() -> T,
    F: Send + 'static,
    T: Send + 'static,
{
    Builder::new().spawn(f).expect("failed to spawn thread")
}

spawn的入参和返回值都实现Send，同时其生命周期为'static。这是因为在多线程中，每个线程的执行周期不是同步的。父线程或者子线程的结束都会导致入参或者返回值的生命周期不满足Rust的约束条件。

泛型

Rust 泛型会在编译时根据参数将泛型单态化（Monomorphization ），因此，Rust 泛型在运行时是没有任何损耗的。

泛型在函数定义

fn largest<T: std::cmp::PartialOrd + Copy>(list: &[T]) -> T {
    let mut largest = list[0];

    for &item in list {
        if item > largest {
            largest = item;
        }
    }

    largest
}

fn main() {
    let number_list = vec![34, 50, 43, 15];
    println!("the largest number is {}", largest(&number_list));

    let char_list = vec!['y', 'm', 'c', 'd'];
    println!("the largest char is {}", largest(&char_list));
}

泛型在结构体定义

struct Point<T> {
    x: T,
    y: T,
}

fn main() {
    let p = Point{x: 5, y: 3};
    println!("x is {}, y is {}", p.x, p.y);

    let p = Point{x: 5.0, y: 3.0};
    println!("x is {}, y is {}", p.x, p.y)
}

需要注意，这里表示结构体内x和y是同一种类型，如果需要x和y类型不同，需要定义两个泛型参数。

所有权（Ownership）是Rust中最独特的特性之一。正是因为所有权，Rust才能够在不需要GC的情况下保证内存安全。

我们常用的语言中，内存管理一般分为两种：

• 自管理，谁分配的谁负责回收，如果没有回收，就会导致内存泄漏。如C、C++。
• 由统一的垃圾回收器管理，GC负责追踪和管理已分配内存，如果内存不再被使用，则由GC进行回收。

Rust选择了第三种，内存会在拥有它的变量离开作用域时回收。因此，理解Rust的内存管理，就需要理解Rust中的所有权、借用规则、生命周期等概念。Rust会在编译过程中校验变量是否符合借用规则，从而保证运行时的内存安全，而且没有GC的额外开销。

在C++中，这种模式也被称作Resource Acquisition Is Initialization (RAII)。

所有权基本规则

所有权有三条基本规则：

• Rust中每个值都有一个对应的变量称之为所有者（owner）；
• 同一时刻，一个值只能存在一个所有者；
• 当所有者离开作用域时，其拥有的值会被丢弃。

copy和move

因为同一时刻，一个值只能存在一个所有者，对于所有权的转让，Rust根据对象类型分为两种。

一种是Copy。即将值做拷贝，拷贝后，原变量拥有原值的所有权，新变量拥有新值的所有权，没有所有权的转移，两者可以同时使用。

let x = 5;
let y = x;
println!("x is {}, y is {}", x, y); // valid

支持Copy操作常见的类型通常是只存储在栈上的数据类型，如：

• 所有的integer类型，如u32；
• bool值；
• char值；
• 所有的float类型，如f64；
• 元组，如果其包含的类型也都是支持Copy的。

这些类型都实现了Copy特型。如果一种类型实现了Copy特型，在分配新变量后，原变量仍是可用的。

另外一种是Move。对于类似String这种在栈上存储了元数据，实际数据存储在堆上的数据类型来说，将原变量赋给新变量实际上是将堆上数据的所有权转移给新变量，原变量在赋值后不再使用。

let s1 = String::from("hello!!!");
let s2 = s1;
println!("s2 is {}, s1 is {}", s2, s1); // invalid, s1 is no longer valid any more.