一般的队列通常用数组实现，队头出队，队尾入队，入队在数组头部插入元素，然后把头部空出来插进去，头部以后的元素都需要向后移动，时间复杂度是O(n),出队删除队尾部元素，时间复杂度是O(1)。

循环队列其实是在普通队列基础上加了指向头部和尾部的指针，入队时候，尾指针+1，因为可能出现头部以前有空位，需要对队列的长度求余，即tail=(tail+1)/array.length,队列长度+1， 出队时候,头指针向后移动一个位置，同理，头指针也需要对队列长度求余，即front=(front+1)/array.length,队列长度-1，为了节省空间，一般会对循环队列的数组进行动态扩容和缩容，其实就是新建个数组，把原来数组的引用指向新的数组就好了，具体实现如下。

队列的抽象定义

1
2
3
4
5
6
7
8
9
10
11

public interface Queue<E> {
    int getSize();

    boolean isEmpty();

    void enqueue(E e);

    E dequeue();

    E getFront();
}

循环队列实现队列的接口的方式实现循环队列

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118

public class LoopQueue<E> implements Queue<E> {
    private E[] data;
    private int front, tail; // 指向队首和队尾部
    private int size;

    public LoopQueue(int capacity) {
        data = (E[]) new Object[capacity + 1];
        front = 0;
        tail = 0;
        size = 0;
    }
	// 默认分配10个空间的数组
    public LoopQueue() {
        this(10);
    }

    public int getCapacity() {
        return data.length - 1;
    }

    @Override
    public boolean isEmpty() {
        return front == tail;
    }

    @Override
    public int getSize() {
        return size;
    }

    @Override
    public void enqueue(E e) {
        if ((tail + 1) % data.length == front) {
            resize(getCapacity() * 2);
        }
        data[tail] = e;
        tail = (tail + 1) % data.length;
        size++;
    }

    /**
     * 出队
     *
     * @return
     */
    @Override
    public E dequeue() {
        if (isEmpty()) {
            throw new IllegalArgumentException("Can not dequeue from a empty queue .");
        }
        E temp = data[front];
        data[front] = null;
        front = (front + 1) % data.length;
        size--;
        // 出队后进行缩容
        if (size == getCapacity() / 4 && getCapacity() / 2 != 0) {
            resize(getCapacity() / 2);
        }
        return temp;
    }

    /**
     * 获取队首
     *
     * @return
     */
    @Override
    public E getFront() {
        if (isEmpty()) {
            throw new IllegalArgumentException("Can not dequeue from a empty queue .");
        }
        return data[front];
    }

    /**
     * 扩容数组
     *
     * @param newCapacity
     */
    private void resize(int newCapacity) {
        E[] newData = (E[]) new Object[newCapacity + 1];
        for (int i = 0; i < size; i++) {
            newData[i] = data[(i + front) % data.length]; //这里注意，旧数组的队首是front,第i个元素就是 i+front
        }
        data = newData;
        front = 0;
        tail = size;
    }

    @Override
    public String toString() {
        StringBuilder res = new StringBuilder();
        res.append(String.format("LoopQueue : size = %d , capacity = %d \n",
                getSize(), getCapacity()));
        res.append("front [");
        for (int i = front; i != tail; i = (i + 1) % data.length) {
            res.append(data[i]);
            if ((i + 1) % data.length != tail) {
                res.append(", ");
            }
        }
        res.append(" ] tail");
        return res.toString();
    }

    public static void main(String[] args) {
        LoopQueue<Integer> queue = new LoopQueue<>();
        for (int i = 0; i < 10; i++) {
            queue.enqueue(i);
            System.out.println(queue);
            if (i % 3 == 2) {
                queue.dequeue();
                System.out.println(queue);
            }
        }

    }
}

测试下结果

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

LoopQueue : size = 1 , capacity = 10 
front [0 ] tail
LoopQueue : size = 2 , capacity = 10 
front [0, 1 ] tail
LoopQueue : size = 3 , capacity = 10 
front [0, 1, 2 ] tail
LoopQueue : size = 2 , capacity = 5 
front [1, 2 ] tail
LoopQueue : size = 3 , capacity = 5 
front [1, 2, 3 ] tail
LoopQueue : size = 4 , capacity = 5 
front [1, 2, 3, 4 ] tail
LoopQueue : size = 5 , capacity = 5 
front [1, 2, 3, 4, 5 ] tail
LoopQueue : size = 4 , capacity = 5 
front [2, 3, 4, 5 ] tail
LoopQueue : size = 5 , capacity = 5 
front [2, 3, 4, 5, 6 ] tail
LoopQueue : size = 6 , capacity = 10 
front [2, 3, 4, 5, 6, 7 ] tail
LoopQueue : size = 7 , capacity = 10 
front [2, 3, 4, 5, 6, 7, 8 ] tail
LoopQueue : size = 6 , capacity = 10 
front [3, 4, 5, 6, 7, 8 ] tail
LoopQueue : size = 7 , capacity = 10 
front [3, 4, 5, 6, 7, 8, 9 ] tail

Process finished with exit code 0

linux 文件系统 与 常用命令

•Filesystem Hierarchy Standard（文件系统层次化标准）

–/boot: 系统启动相关的文件，如内核、initrd，以及grub(bootloader)

–/dev: 设备文件

–/etc：配置文件

–/home：用户的家目录，每一个用户的家目录通常默认为/home/USERNAME

–/root：管理员的家目录；

–/lib：库文件

–/media：挂载点目录，移动设备

–/mnt：挂载点目录，额外的临时文件系统

–/opt：可选目录，第三方程序的安装目录

–/proc：伪文件系统，内核映射文件

–/sys：伪文件系统，跟硬件设备相关的属性映射文件

–/tmp：临时文件, /var/tmp

–/var：可变化的文件

–/bin: 可执行文件, 用户命令

–/sbin：管理命令

1. 背景介绍

这篇文章介绍一下 Linux 中 swap 与 memory。memory 就是机器的物理内存ram，读写速度低于 cpu 一个量级，但是高于磁盘不止一个量级。所以，程序和数据如果在内存的话，会有非常快的读写速度。但是，内存的造价是要高于磁盘的，虽然相对来说价格一直在降低。除此之外，内存的断电丢失数据也是一个原因，因此不能把所有数据和程序都保存在内存中。既然不能全部使用内存，那数据还有程序肯定不可能一直霸占在内存中。当内存没有可用的，就必须要把内存中不经常运行的程序给踢出去。但是踢到哪里去，这时候 swap 就出现了。swap 全称为 swap place，即交换区，当内存不够的时候，被踢出的进程数据被暂时存储到交换区。当需要这条被踢出的进程的时候，就从交换区重新加载到内存，否则它不会主动交换到真实内存中。

Redis 简介

Redis 是一个高性能的key-value形式的内存数据库
Redis 支持数据的持久化，可以将内存中的数据保持在磁盘中，重启的时候可以再次加载进行使用。
Redis 不仅仅支持简单的 key-value 类型的数据，同时还提供 list，set，zset，hash 等数据结构的存储。
Redis 支持数据的备份，即 master-slave 模式的数据备份。
Redis 优势
性能极高 – Redis 能读的速度是 110000 次 /s, 写的速度是 81000 次 /s 。
丰富的数据类型 – Redis 支持二进制案例的 Strings, Lists, Hashes, Sets 及 Ordered Sets 数据类型操作。
原子 – Redis 的所有操作都是原子性的，同时 Redis 还支持对几个操作全并后的原子性执行。
丰富的特性 – Redis 还支持 publish/subscribe, 通知，key 过期等等特性。
Redis 与其他 key-value 存储有什么不同？
Redis 有着更为复杂的数据结构并且提供对他们的原子性操作，这是一个不同于其他数据库的进化路径。
Redis 的数据类型都是基于基本数据结构的同时对程序员透明，无需进行额外的抽象。
Redis 运行在内存中但是可以持久化到磁盘，所以在对不同数据集进行高速读写时需要权衡内存，
应为数据量不能大于硬件内存。在内存数据库方面的另一个优点是， 相比在磁盘上相同的复杂的数据结构，在内存中操作起来非常简单，
这样 Redis 可以做很多内部复杂性很强的事情。 同时，在磁盘格式方面他们是紧凑的以追加的方式产生的，因为他们并不需要进行随机访问。

​ 在互联网业务中，有很多场景，都需要向用户推送消息，例如，一个论坛系统中，当用户发帖后，其他用户进行回复，需要对发帖者进行消息通知，在电商业务中，当用户下单后，管理后台需要通知用户下单成功；在一些秒杀和购物场景中，当用户提交订单未付款时候，一般会有一个截止时间，当即将到达截止时间时候，需要通知用户及时付款，在这些场景中，如何对用户实现消息通知呢?

简单消息推送

传统的开发模式，一般是前端轮询，例如在论坛系统中，在用户个人页面，前端轮询后端接口，后端返回对应的消息数据，这种方式需要每隔几秒就向后台发请求，对于实时性要求比较高的系统，轮询频率会更高，之前参与维护迭代的pc端消息推送，采用的是这种方式，前端轮询后端接口，后端通过查询数据库，判断是否有新消息，有的话就将数据返回给前端，前端进行弹窗或者其它方式进行展示，数据库设计大概如下：

当需要对某个用户，或者某些业务进行消息推送时候，在消息记录表，插入一条数据，以及消息的阅读状态，已读和未读，然后根据前端需求，返回该用户的全部消息，或者全部未读消息，当用户点击消息后，前端发请求，后端修改消息的阅读状态。

这种方式的实现比较简单无脑，基本上只需要查询修改下基本上就可以完成，适合用户量较少，对于实时性要求不高的业务场景，当用户量较大时候，查询和插入效率很低，需要加缓存或者对数据库进行分库分表，从而提高业务的稳定性和可用性，目前在一些小公司和简单的论坛一类的业务，该方式的消息推送可能还在使用，在未来的开发中，这种方式不推荐使用，因为效率低下，前端频繁轮询查接口，会对后端数据库造成很大压力，而且当有多个场景的消息推送时候，这种方式会让用户客户端的网页异常卡顿，加载速度慢，用户体验很差。

多场景消息推送

在电商业务中，很多消息类型，需要向用户发送短信，例如用户下单，退款，下单未付款，快递配送进度等等，这一类消息，通常需要根据不同的业务场景，有些需要给客户发送短信通知，在小程序端，可能需要调用微信开发平台的接口，进行小程序或者公众号消息推送，这一类相对来说比较容易实现，在需要消息推送时候，直接调用发送短信接口，或者微信平台接口进行消息推送，当数据量比较大时候，可以暂时把这些推送服务加入一个异步队列，进行分批次推送，这些适用于对时效性较低的场景，例如微信的每日运动排行。

对于这类消息推送，一般需要在业务执行时候，添加到异步队列中，通过倒计时一类的方式进行触发，常用的有 Redis 的发布与订阅，WebSocket 全双工通信，服务器端可以向浏览器发送消息，或者通过 Celery 执行异步队列，从而实现消息推送，下面简单介绍下 Celery。

Celery 任务队列一般用于线程或计算机之间分配工作的一种机制。

任务队列的输入是一个称为任务的工作单元，有专门的工作进行不断的监视任务队列，进行执行新的任务工作。

Celery 通过消息机制进行通信，通常使用中间人（Broker）作为客户端和职程（Worker）调节。启动一个任务，客户端向消息队列发送一条消息，然后中间人（Broker）将消息传递给一个职程（Worker），最后由职程（Worker）进行执行中间人（Broker）分配的任务。

Celery 可以有多个职程（Worker）和中间人（Broker），用来提高 Celery 的高可用性以及横向扩展能力。

Celery 需要消息中间件来进行发送和接收消息。 RabbitMQ 和 Redis 中间人的功能比较齐全，但也支持其它的实验性的解决方案，其中包括 SQLite 进行本地开发。

Celery 可以在一台机器上运行，也可以在多台机器上运行，甚至可以跨数据中心运行。

首先我们创建一个简单的task。

1
2
3
4
5
6
7

from celery import Celery

app = Celery('tasks', broker='pyamqp://guest@localhost//')

@app.task
def add(x, y):
    return x + y

对于中间人，如果是Rabbitmq的话，可以使用 amqp://user:123456@localhost/test，Redis的话可以用 redis://localhost ，然后启动下任务队列:

1

celery -A tasks worker --loglevel=info

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

[root@aliyun amqp]# celery -A tasks worker --loglevel=info
/usr/local/lib/python3.6/site-packages/celery/platforms.py:801: RuntimeWarning: You're running the worker with superuser privileges: this is
absolutely not recommended!

Please specify a different user using the --uid option.

User information: uid=0 euid=0 gid=0 egid=0

  uid=uid, euid=euid, gid=gid, egid=egid,
 
 -------------- celery@aliyun v4.4.0 (cliffs)
--- ***** ----- 
-- ******* ---- Linux-4.18.0-147.5.1.el8_1.x86_64-x86_64-with-centos-8.1.1911-Core 2019-10-19 01:14:19
- *** --- * --- 
- ** ---------- [config]
- ** ---------- .> app:         tasks:0x7f12d36d5f28
- ** ---------- .> transport:   amqp://user:**@localhost:5672/test
- ** ---------- .> results:     redis://localhost/
- *** --- * --- .> concurrency: 2 (prefork)
-- ******* ---- .> task events: OFF (enable -E to monitor tasks in this worker)
--- ***** ----- 
 -------------- [queues]
                .> celery           exchange=celery(direct) key=celery
                

[tasks]
  . tasks.add
  . tasks.mul
  . tasks.xsum

[2019-10-19 01:14:20,027: INFO/MainProcess] Connected to amqp://user:**@127.0.0.1:5672/test
[2019-10-19 01:14:20,038: INFO/MainProcess] mingle: searching for neighbors
[2019-10-19 01:14:21,066: INFO/MainProcess] mingle: all alone
[2019-10-19 01:14:21,085: INFO/MainProcess] celery@aliyun ready.

可以看到 Celery 已经启动，通过 python shell 可以调用对应的任务，Celery默认的并发数为 CPU 核心数。

调用下试试。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

In [5]: add.delay(4, 4)                                                                                
Out[5]: <AsyncResult: 8b3818f8-ebd0-443f-bbf8-5dadb536fcaa>

In [6]: result = add.delay(1,1)                                                                        

In [7]: result.ready()                                                                                 
Out[7]: True

In [8]: result.get(timeout=1)                                                                          
Out[8]: 2

In [9]: result.get(propagate=False)                                                                    
Out[9]: 2

In [10]: result.traceback

1
2
3

Celery可以通过 rate_limit 方向进行频率限制，例如，以下方式限制每分钟不超过10次

celery -A tasks control rate_limit tasks.add 10/m

Celery 通过 EventLet 方式实现并发，使用 epoll 或 libevent 实现非阻塞 IO ,这样可以充分提高执行的任务数.

通过 celery worker -P 的方式可以指定工作方式

1

celery -A proj worker -P eventlet -c 1000 // 1000个线程并发执行

Celery 可以 通过配置backend 来保存任务执行结果，我这里使用 Redis 。

Celerys.py

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

#!/usr/bin/env python
# coding=utf-8
from __future__ import absolute_import, unicode_literals
from celery import Celery
app = Celery(
    broker = 'amqp://user:123456@localhost/test',
    backend='redis://localhost',
    include=[]
)

app.conf.update(
    result_expires=3600,
)

if __name__ == '__main__':
    app.start()

tasks.py

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

#!/usr/bin/env python
# coding=utf-8
from celery import Celery

app = Celery('tasks', broker='amqp://user:123456@localhost/test', backend='redis://localhost')

app.conf.task_serializer = 'json'

@app.task
def add(x, y):
        return x + y

@app.task
def mul(x,y):
    return x*y

@app.task
def xsum(numbers):
    return sum(numbers)




if __name__ == '__main__':
    add(1,2)

查看下 Redis 中是否有结果

可以查看到容器内的redis中已经有了 task的执行结果，我们可以查看下结果

1
2
3

127.0.0.1:6379> get celery-task-meta-8b3818f8-ebd0-443f-bbf8-5dadb536fcaa
"{\"status\": \"SUCCESS\", \"result\": 8, \"traceback\": null, \"children\": [], \"date_done\": \"2020-03-16T17:41:33.382702\", \"task_id\": \"8b3818f8-ebd0-443f-bbf8-5dadb536fcaa\"}"
127.0.0.1:6379>

可以看到配置 Redis 为backend后，task的执行结果已经保存到 Redis中，以后开发中，可以通过读取 对应的task_id为 key的 数据，就可以得到每个任务的最终执行结果。

概念

数据库是一个以某种方式有组织的形式存储的数据集合

数据库(database) 保存有组织的数据的容器。（一个文件或者一组文件）

数据库表特性: 定义数据如何存储，存储什么数据，数据如何分解。

模式(scheme): 关于数据库和表布局以及特性的信息

列(column): 表中一个字段

行(row): 表中的一个记录

主键(primary key) : 一列(或者一组列 ，其值能够唯一区分表中每一行

成为主键条件：

1. 任意两行都不具有相同主键值

2. 每行都必须有一个主键值(主键列不允许NULL值)

什么是docker

docker包括一个命令行程序、一个后台守护进程、以及一组远程服务。它解决了常见的软件问题，并建华路安装、运行、发布和删除软件。这一切能够实现是使用一项Unix技术，称为容器。

容器不是虚拟化

在没有docker时代，使用硬件虚拟化(虚拟机),以提供隔离，虚拟机提供虚拟硬件，可安装一个os和其他程序，需要很长时间创建，资源开销打，因为除了要执行你需要的软件，还需要运行整个操作系统的副本。
docker容器不使用硬件虚拟化，运行在docker容器中的程序接口和逐渐的Linux内核直接打交道，容器中运行的程序与计算机操作系统直接没有额外的中间层，没有资源被冗余软件的运行或者虚拟硬件模拟而浪费掉，docker不是虚拟化技术，相反，它可以帮助使用已经内置到操作系统中的容器技术。

黄色的林子里有两条路，
很遗憾我无法同时选择两者
身在旅途的我久久站立
对着其中一条极目眺望
直到它蜿蜒拐进远处的树丛。
我选择了另外的一条，天经地义，
也许更为诱人
因为它充满荆棘，需要开拓；
然而这样的路过
并未引起太大的改变。
那天清晨这两条小路一起静卧在
无人踩过的树叶丛中
哦，我把另一条路留给了明天！
明知路连着路，
我不知是否该回头。
我将轻轻叹息，叙述这一切
许多许多年以后：
林子里有两条路，我——
选择了行人稀少的那一条
它改变了我的一生。

年前在boss上和实验室的小伙伴一起投简历找实习，拿到了深信服年后实习的offer，从2月一个人来到深圳这个陌生的城市实习，到慢慢认识一群可爱有趣的小伙伴，因为学校让回去搞毕业相关东西的原因，迫不得已要回学校，总结下在深信服这两个多月的实习工作经验。

1. 明确需求再编码，如果需求有疑问直接找产品经理确定。
2. 多学习项目的公共接口或方法，优先调用项目公共方法，没有的自己再编码，避免重复造轮子，提高开发效率。注意将重复性代码写作公共方法，提高代码复用性，减少冗余代码量。
3. 注意个人代码风格 ，与公司项目保持统一，每次定义常量时，先查看每个app的常量里面是否已经有定义，有的话直接使用，不要重复定义，尽量不要出现魔数，对于功能性常量，用const定义在本类中，最好加上注释方便理解，代码的可读性也非常重要，没有改动代码不要提交到git，常用快捷键格式化代码，代码风格统一。
4. 注意不要循环查数据库,降低循环次数，提高服务性能。

实习期间的点点滴滴

第一天，导师带领下去吃饭，装电脑，配置网络

实习时候还带着我婷婷姐之前送我的水杯，超级好用

公司大楼

秀一波公司的美食O(∩_∩)O哈哈~

西丽买的超实惠好吃的潮汕米粉

晚上下班，西丽街口跳广场舞的人们

在西丽买东西时候看的哦一个好看的小姐姐

工卡

公司内部交流打卡软件，口袋助理

张新兰姐姐哈哈，好可爱n(≧▽≦)n

实习证明

工资

公司全家福

公司安排的西丽的好美酒店，每天和陶世婷小姐姐一起上下班

清明节放假去后海浪

写代码

去寄快递的陶世婷小姐姐

跟陶世婷小姐姐一块回去

南科大，呜呜呜，就在公司旁边，可惜打卡才能进去，只能站在外面看看，难受(╯﹏╰)

你知道夜晚11点的南山智园吗

你是如何理解「她那时候还太年轻，不知道所有命运赠送的礼物，早已在暗中标好了价格」的？

1. 太年轻”是关键，年轻，很多事不会考虑后果，肆意妄为，以为世界都是自己的，很多人抱怨自己年轻人不懂事什么的，何谓懂事？无非是现实给予我们教训好让我们认清自己，只是这教训有时候特别沉重，你连重来的机会都没有了。

2. 在知名男性作家中，茨威格一直享有会写女人的盛誉。这本书基于真实历史，是为这位王后写的传记。在书中，作者如此评价这个女人：“她是所有漫不经心的人里最漫不经心的，所有奢靡浪费的人里最奢靡浪费的，所有风流轻浮的人里最风流轻浮的。”然后，作者又无比感慨：“那时候她太年轻，不知道命运所有的馈赠，都已暗中标好了价格。

3. 祸兮福之所倚，福兮祸之所福

4. 以至于玛丽·安托瓦内特的亲哥哥从奥地利专程来法国规劝自己的亲妹妹，请求她，对她说你现在是法兰西王后，你能不能每天读一小时书，这并不难。

5. 玛丽对哥哥说：我不喜欢读书，我喜欢享受生活。”

6. 公主不被世俗所扰，有自己的追求，即使最后她上断头台如果都未曾有一刻后悔这样过一生的话，公主是幸福的,就是幸灾乐祸的委婉表达

7. 少壮不努力，老大徒悲伤

8. 万般皆是命，半点不由人。

   这句话的出处是斯蒂芬茨威格给玛丽亚·斯图亚特写的专记《断头女王》

• 原文是这样的：“Lightly, caressingly, Marie Antoinette picked up the crown as a gift. She was still too young to know that life never gives anything for nothing, and that a price is always exacted for what fate bestows. She did not think she would have to pay a price. She simply accepted the rights of her royal position and performed no duties in exchange. She wanted to combine two things which are, in actual human experience, incompatible; she wanted to reign and at the same time to enjoy.”

• 确实不得不佩服翻译工作者的厉害，原本也不理解这句听起来很深奥的话，然后花了两天时间刚刚看完了这本书，我看的是这个版本：

• 在我看完这本书后我对这句话的理解是这样的：玛丽亚·斯图亚特的一切来的太容易，生下六天就成了苏格兰的女王，十六岁那年成为法国王妃，后成为王后，紧接着也成为了有权继承英国王位的到达权利巅峰的人。但是她的悲剧在于除了从一而终的热情和冒险外并无管理国家的能力。戴上王冠，未能承其重，反而一昧地把一切放在一个不爱她的博斯威尔身上，她那些十四行诗中的诗句也成了可怕的现实：
  为了他，我忘却了自己的荣誉——
我们生活中惟一的幸福，
为了他，我献出了权力与良心，
为了他，我被自己的祖国所唾弃。
自作孽，不可活，神不会垂怜于无意义的牺牲。
  其实这句话也挺有现实意义的。
  恐怕拿玛丽亚也可以去回答“一手好牌打烂”的那个问题，不过看完我想想，历史上没有完美的人，玛丽亚之所以成为一个传奇就是因为她那勇敢的性格，虽然那性格一步步带她走到了断头的结局。
  （另外，书中另外一个任务——伊丽莎白多疑、矛盾的性格也被刻画得入木三分。）
  他那时候还太年轻，不知道所有命运赠送的食物，早已在暗中标好了热量。
  任何的拥有都需要付出代价。
  你得到一样东西总要承担代价，或早或晚，或明或暗。
  比骄奢淫逸，慈禧呢？武则天呢？吕后呢？这三没被砍头吧？历史上大多数皇后也没被砍头吧？
  这句话的意思就是穷屌丝你们就该过穷日子，想大吃大喝？去死吧
  比如马云，他以为阿里巴巴是命运的馈赠，但价格是他再也回不到以前当穷老师的那种幸福了，很悲哀吧
  一些看似是免费的随手可得的东西，其实你在获取的同时已经付出了代价。换句话说，天下没有免费的午餐，有得必有舍。例如青春、年轻的身体、父母的馈赠……
  非常喜欢这句话，便借此在这里记录下这一年来我对这句话的一些浅薄理解。`

1. 一，在人际交往中，无论情感还是物质上，都存在着一定的礼尚往来。别人对你付出多少你心里还是要有数，不要一味地要求别人付出而自己无动于衷，还不起的感情和礼物请三思而后行。

   在谈恋爱时也是这么告诫自己，约会时积极买单，不向男友索要什么，收到礼物也会回礼，逛街购物也会尽量拒绝男友的慷慨。

   二，以平和的心态看待得失。一般情况下得与失都是平衡的，不要在得意时太忘乎所以，在失意也要稳住，示意自己一切总会好起来的。“不以物喜，不以己悲”，也是本人非常想达到的状态。
   三，在有能力的情况下回馈社会。上帝是不公平的，有时候就是会偏爱有些人多一些，他们不需要付出什么就能过上别人梦寐以求的生活，这无可厚非。就我现在的生活而言，很一般，却也健健康康衣食无忧，现实中看到情况比我差的人我是会去帮助他们的。“穷则独善其身，达则兼济天下”，这话是有些高了，却是我心之所向。
   这句话是一个警钟，不同场景对这句话都会新的更细致的理解，很受用。
   “天下就没有偶然，偶然不过是化了妆的、戴了面具的必然。”—— 钱钟书
   有什么好理解的，只是作者的叙述手法，对象只是书中的角色。叙述王后的能力不匹配她的地位却依旧颓废，最后的悲惨故事。
   现实中根本没有那么绝对，《道德经》说的很清楚，就是 “祸兮福所倚，福兮祸所伏”。
   所以说对于自己一定要乐观积极一些，面对他人无论是谁都尽量给他/她一份祝福。
   多反思自我，给自己定一些目标并制定相应的计划，充实而忙碌的生活总是更健康一些。
   苦难方面。身边有经历磨难面对不公自杀的，也有开公司被合伙人背叛勾搭媳妇欠下一身债多年后东山再起的。
   上天的赏赐无时不刻都在，每个人都有，有的赏赐给了某些人无论遇到任何事都能积极乐观的品质，这使得这类人在之后的苦难中不断成长，永远处于不败之地。这样的人我是没看出来是标了价而是上天给了她所向披靡的能力。
   其实我们评价一个人的人生都只能盖棺定论，所以对每个人都给予一份祝福。特别是能影响的人，哪怕自己消极悲观，也不该因为某些人接受了所谓的不该接受的“馈赠”而去攻击他/她们。
   欲戴皇冠，必承其重。
   不请自来
   那些靠出卖色相和肉体换得物质回报的女孩子 送给你们
   我认为这句话可以这么理解：
   你现在所享受的待遇并不是这个年纪应得的，如果自己没有及时醒悟，那么未来总会让你付出代价。

2. 特别适用于不思进取坐享其成白日做梦的无脑女孩儿
   1.凡事都有代价。
   2.待意识到这一点，却往往为时已晚，已无力支付和偿还。
   因为看到了这句话去看这本书
   大失所望 所以有些地方就跳着翻了 结果到了最后一面还没看到
   请问这句话到底是在哪啊。。
   只能用在特定的故事里，但是现在被滥用了，好多人动不动就用这句，然而我认为并不适合于大众。
   能量守恒，均值回归，宇宙真理，你不服有用？
   这么说吧
   (有一些)女人年轻时可以靠着勾引男人过上上层阶级的生活
   但是如果她不努力(误)
   那她年老色衰以后注定会被抛弃。
   过上凄惨的生活，堕落成妓女一类的(误 好像本来就是个鸡)
   除了勾引男人啪啪什么技能都不会，自然在没了男人后无法讨生活
   所以好好读书努力工作才是正路啦，男女都一样
   私以为，这个她换成他也同样适用

3. 人在年轻的时候，会因为各种因缘际会，会遇到各种困难与好运。遇到困难往往就觉得这辈子是不是就这样了，一点希望也没有，却不明白那是心的磨练，如果还能思考，那就会是价值无穷的经验。苦乐总是相对的，当人有失去的经验，才明白拥有有多么的快乐。反过来，人年轻的时候太过顺遂却不是好事，一路攀上高峰，但是谁又能一辈子都不失足。摔下来那天可能就再也没有勇气走下去。本以为自己就是被老天爷给了这么多的礼物，但其实那代价却要在之后慢慢偿还。所以，那个老故事，吃甘蔗，愿意先吃甜的还是先吃苦的？
   “Marie Antoinette：The Portrait of an Average Woman” by Stefan Zweig:
“Lightly,caressingly,Marie Antoinette picked up the crown as a gift.
She did not think she would have to pay a price.
She simply accepted the rights of her royal position and performed no duties in exchange.
She wanted to combine two things which are, in actual human experience, incompatible;
she wanted to reign and at the same time to enjoy.”
   就比如，相貌较好的女生，因为外貌得到了许多便利，她因此开心，别人努力很久的东西她生来就有，不用保养的皮肤不用运动就有的美腿不用费力讨好别人就有很多人喜欢她对她好。

4. 她不用独立不用自律不用看社交心理学的和别人保持良好的关系。但总是有点亏损的，人这一辈有些东西总要学会总要经历，如果早些时候你没有经历，到你老了也会经历的，无论好与坏
   生于贫穷人家的漂亮女孩是种不幸。大多不肯努力，靠美貌轻而易举得获得的都是暂时，命运早已标好了价格。

5. 我的理解是，一切都要付出代价。偷情，赌博，吸毒这类欲望爆棚的东西，背后有着所有的代价与枷锁。
   说得好像就算知道了，你就能做空“美貌”这类的“命运赠送的礼物”一样。
   大概就是说我活到现在二十来年，基本算是免费的。
感谢老天爷。
作为一男人，这个社会对他最大的恩惠是他始终掌握着主动权，只要他够聪明，他的下场便不会太惨。
想到了打“裸条”的姑娘……
自己通过努力获取的东西，都会比较珍惜；然而对于那些侥幸得到的东西或是别人赠予你的爱，虽然当下你好像并没有花钱或者做任何额外的事情，就得到了，也要珍惜。比如你由于漂亮，或者气质好，或者有文采，或者其他原因，吸引了一个男生认认真真追求你，对你好，事实上你是没有做额外的努力的就获得了这份爱的。就算不爱，至少不要滥用和肆意挥霍。否则，久而久之，没有人会一直毫无条件不求回报地对你好。当有一天他们突然撤回了对你的爱，你会感觉像失去了自己曾经努力获取的东西那样难受，尽管其实你当时没有做额外的努力就得到了它们。这就是所谓的失去了那些“早已暗中标记了价格”的东西吧。
命运即使对它最喜爱的宠儿也不是永远慷慨无度的。 ————茨威格
珍惜年轻时候对你死心塌地的初恋男

   我就想知道，人拥有的东西哪一样不是命运给的，只不过是给你鲜花和蛋糕、还是潘多拉魔盒的问题。
   意思是你得到的东西都是有代价的：不管是你努力得到，还是侥幸得到。若是努力靠自己得到，就是你配得上这些东西，不会向暴发户一样作。如果是侥幸得到的，比如偷得、骗得，还是什么手段，反正总有一天，你会得到应有的报应，因为你配不上这些东西，你驾驭不了，就要付出代价。这句话是说你得到的礼物是有代价的，你能付得起的就能好好享受，你付不起却通过不正当途径超前消费的，迟早要还。也就是说出来混社会迟早要还的。
   先说背景：玛丽·安托瓦内特原是奥地利公主，14岁的时候就成为法国的王太子妃，18岁成为法国王后，母仪法兰西，丈夫很爱她，由着她的性子建宫殿，办宴会，夜夜笙歌，以至于玛丽·安托瓦内特的亲哥哥从奥地利专程来法国规劝自己的亲妹妹，请求她，对她说你现在是法兰西王后，你能不能每天读一小时书，这并不难。
   玛丽对哥哥说：我不喜欢读书，我喜欢享受生活。
   20年后，玛丽·安托瓦内特上了断头台，被称为断头王后。茨威格给她写的传记中，提到她早年的奢侈生活，无比感慨，说：她那时候还太年轻，不知道所有命运赠送的礼物，早已在暗中标好了价格。
   意思就是，不要觉得自己可以轻易取得什么，生活中的一切都是需要你付出努力和代价的，就算你能轻易得取得什么生活中的馈赠，最终也要付出代价。可以理解为警戒别人不要贪婪，不要妄图不劳而获的意思，也有规劝人们不要恣意挥霍，觉得天上会掉馅饼，还是要踏踏实实付出，认认真真生活，否则，都是要为此付出代价的。

   我想到了最近看到的一句

   `并不是神圣的理由而使战争神圣，而是战争使理由神圣。往前往后看，也许和断头王后类似的人很多……`

   约炮约到最后没人要了。对婚姻和爱情不再抱希望，只留下怀念曾经的年轻。
   上帝赋予你美好的礼物时，就要承担被撒旦窃夺的风险。
   拥有是要付出的，是要牺牲的，年轻时却只想着拥有
   命运的馈赠，或是美貌、或是财富、或是天资，都会成为你闪耀于众人吸引于众人的原因。然而美貌会迟暮，财富会消耗，天资会凋零，如果你不加以努力和维护，不在其他方面精进，馈赠的礼物或折旧耗尽，或被歹人恶意觊觎，终将不复。身负珠玉，也要付出维护珠玉的代价。
   **天上不会掉馅饼，即使掉下来砸到你，总有一天你会为此买单。男人的极大幸运在于，他，不论在成年还是在小时候，必须踏上一条极为艰苦的道路，不过这是一条最可靠的道路；女人的不幸则在于被几乎不可抗拒的诱惑包围着；她不被要求奋发向上，只被鼓励滑下去到达极乐。当她发觉自己被海市蜃楼愚弄时，已经为时太晚，她的力量在失败的冒险中已被耗尽。`

   ------波伏娃《第二性》`**

   She will pay for it.【她终将为此付出代价】

   我觉得这是茨威格没说完的那句话，也很符合用独有的双关语为前面这些铺垫的话做出解答。
   原文中有一句：“她不知道，得到权利的同时意味着承担同等的义务，如果得不到相应的回报，再热忱的爱戴也会消退。”
   我觉得这就算是一个回答吧。
   看了上面答案才知道这是出自断头王后。
   那这句话正确的意思应该是不要贪图命运的眷顾，总有一天你会为此付出代价。
   但我打赌，肯定有些bitch拿这句话来揣测别人，洗白自己。
   这句话乍一看就像一个单纯的小姑娘，不懂世俗的险恶，开心的接受了别人的礼物，但其实每个礼物都包含这邪恶的欲望和恶意。
   女神婊啊，不用钞票推不倒。
   女神我没有超跑，但有个潮牌。
   一物一价
   没什么从天上掉下来
   福份是带有危机性的，所以要有聪明智慧和丰盛的生命才能承受。
   2、3、5、+、＝，这五个符号中没有错误存在。但如果你说2+5＝3，错误就存在了，本来不存在的变成存在了，为什么呢?因为你在排列时用了错误的自由，当错误的自由应用出来的时候，罪就出现了。但是，如果你把它重组，3+2＝5，错误就不存在了，为什么呢?

   上帝给人自由，而上帝为什么给他自由?因为自由是道德的基础。自由好吗，好。自由危险吗?很危险。女孩子漂亮好不好?好，至少在婚姻的事上比别人有更多的机会。危险不危险?很危险。多数太漂亮的女孩子功课都不好，因为从小就爱照镜子不爱看书。那么要女孩子很平安是不是要求主让你生出一个丑八怪?一个像母夜叉的女孩子，三更半夜出门不但没有人干扰她，还会把坏人吓退三舍。神把自由给人，里面隐藏着有危机性的福份，福份是借着与神同在产生出来，危机则是与神分开而产生出来。

   我拥有的都是侥幸，我失去的都是人生。
   哈哈 我表示，如果我能从14岁开始夜夜笙歌，过着奢靡浮华的日子，真心不需要等到38岁才上断头台~
   水能载舟，亦能覆舟。物极必反，这是历史的必然。
   我反而觉得是
   选择了就不能回头 无法后悔
   如果从另一个角度来看这句话，也很有意思: 那些人生前期经历的磨难或许也是命运所馈赠的礼物，年轻时的自己只会抱怨命运的不公。
   这句话形容当前（2016-8-14）新闻娱乐和八卦热点中的王宝强的老婆马蓉最好不过了。不知她能不能配的上这句话
   本不该属于你的，你拥有了，以后会付出昂贵的代价的，并不是表面上看上去那样光鲜。所以就算一开始的侥幸得意，却不知道日后要付出沉重的代价。
   人的福气是有限的。
   没有免费的午餐！一切都得靠自己！
   第一次看这句话的时候
   觉得是少女的年少无知 偷尝禁果
   之后要付出代价
   又或者出卖肉体 换取钱财
   几年后 落魄的代价
   普通人的自我安慰。
   很多人没有赢在起跑线上，因为他们直接生在终点，毫不费力的享受了一切也没遭不幸。
   至于断头王后，第一太傻，第二运气不好，命运看她不顺眼，身世除了显赫没什么特别牛逼的。虽然还是比我牛逼。
   想要得到多少，就要付出多少。
   如果自己所拥有的配不上自己所付出的，终究要付出代价。
   所有的偶然都是必然的。
   年轻时烟酒的放纵，年长时病痛的根源。
   一时的冲动爽快，可能是永恒的悲伤内疚。
   你享受到的生活，是因为有人在背后默默坚持。
   生活有苦有乐，一直享乐不会明白生活来之不易。
   癌症治愈吸烟。
   生活不止诗和远方，还有眼前的苟且。
   根据万物守恒定律，有多少收获就有多少付出，只是看谁在付出。
   你們曉得不曉得，斷頭王后年輕時不盡情享受，革命黨一來還是要斷頭。
   不要老聽風就是雨，還是要提高姿勢水平。
   另外多享受生活。
   普通芸芸众生没必要琢磨这句话。说什么“颜值高”“身材好”也算命运的礼物的，这个显然不是茨威格的本意——当然我们不能否认这是命运的偏爱。
   我以为这道理很简单，在普通人身上，只要这个如你所愿的时代继续维持，根本没有什么否定他继续存在的力量。但是在涉身政治太深的人，这显然不适用：他不前进，便要死亡。因为有人盼着他的死。
   皇后坐上了飞速前进的火车，她以为这个火车会永远前进。她不知道火车也有停下的一天，火车停了，车票就是她的生命。“她那时候还太年轻，不知道所有命运赠送的礼物，早已在暗中标好了价格”。
   配得上才能拿，配不上拿了就得还。
   作的紧，死的快。

• 就是以前很傻很天真，以为一切都很美好，但发现最后却不是
  侥幸得到，也要不断努力
  德不配位，必有余殃 。
  出来混，迟早要还的。
  我觉得劝诫意义很主要，换个思路想想也很有意思。
  有选择就难免错过。
  世事无常，眼看短暂的岁月就要流散成悔意。
  猜不透价格，人才做蠢事。
  也正因为做遍蠢事，我们的存在才如此真实。
  小时候，过年收红包，是礼物；长大发红包，是价格。
  不过想到养老保险，感觉这句话说的不完全，有时候还要为别人的礼物付钱。