#include <stdio.h>
#include <time.h>
#include <sys/time.h>
#include <pthread.h>

pthread_key_t g_thread_key;//数据键

typedef struct tagThreadTime
{
	pthread_t tid;
	pthread_mutex_t mutex;
	pthread_cond_t read;
	pthread_cond_t write;
	long i;
	clock_t t_start;//sleep will not count
	clock_t t_end;
	struct timeval ts;//more accurate
	struct timeval te;
	struct timeval tc;
	double t_used;
	struct timespec tts;//not used
}ThreadTime;

int Thread_SetTid()
{
	ThreadTime *pStruct = (ThreadTime*)pthread_getspecific(g_thread_key);
	//lock
	pStruct->tid = pthread_self();
	//unlock
}

int Thread_SetStartTime()
{
	ThreadTime *pStruct = (ThreadTime*)pthread_getspecific(g_thread_key);
	//lock
	pStruct->t_start = clock();
	gettimeofday(&pStruct->ts,NULL);
	//unlock
}

int Thread_Delay()
{
	ThreadTime *pStruct = (ThreadTime*)pthread_getspecific(g_thread_key);
	pStruct->i = 10000000L;
	while(pStruct->i--);
	sleep(1);
}

int Thread_SetEndTime()
{
	ThreadTime *pStruct = (ThreadTime*)pthread_getspecific(g_thread_key);
	//lock
	pStruct->t_end = clock();
	gettimeofday(&pStruct->te,NULL);
	//unlock
}

int Thread_CalcUsedTime()
{
	ThreadTime *pStruct = (ThreadTime*)pthread_getspecific(g_thread_key);
	//lock
	pStruct->t_used = (double)(pStruct->t_end - pStruct->t_start)/CLOCKS_PER_SEC;
	pStruct->t_used *= 1000;
	pStruct->tc.tv_sec = pStruct->te.tv_sec - pStruct->ts.tv_sec;
	pStruct->tc.tv_usec = pStruct->te.tv_usec - pStruct->ts.tv_usec;
	//unlock
}

int Thread_PrintUsedTime()
{
	ThreadTime *pStruct = (ThreadTime*)pthread_getspecific(g_thread_key);
	//lock
	printf("tid %lu used %.1f (ms) [%.2f ms] ts %lu te %lu gs %lu ge %lu [%lu %lu]\n",
		pStruct->tid,pStruct->t_used,pStruct->tc.tv_usec/1000.0,
		pStruct->t_start,pStruct->t_end,
		pStruct->ts.tv_usec,pStruct->te.tv_usec,
		pStruct->ts.tv_sec,pStruct->te.tv_sec);
	//unlock
}

void *Thread_Main(void *arg)
{
	ThreadTime m_ThreadTime;
	pthread_setspecific(g_thread_key,(void *)&m_ThreadTime);
	Thread_SetTid();
	Thread_SetStartTime();
	Thread_Delay();
	Thread_SetEndTime();
	Thread_CalcUsedTime();
	Thread_PrintUsedTime();
}

int main()
{
	int i;
	pthread_t tid[25];
	printf("Main Clock %lu\n",clock());
	pthread_key_create(&g_thread_key,NULL);

	for (i = 0; i < 25; i++)
		pthread_create (&tid[i], NULL, Thread_Main, NULL); //创建多线程

	for (i = 0; i < 25; i++)
		pthread_join (tid[i], NULL);  //等待各个线程结束

	printf("Main Clock %lu\n",clock());

	struct timespec ts;  

	clock_gettime(CLOCK_REALTIME, &ts);
	printf("CLOCK_REALTIME: %ld, %ld\n", ts.tv_sec, ts.tv_nsec);  

	clock_gettime(CLOCK_MONOTONIC, &ts);//打印出来的时间跟 cat /proc/uptime 第一个参数一样
	printf("CLOCK_MONOTONIC: %ld, %ld\n", ts.tv_sec, ts.tv_nsec);  

	clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &ts);
	printf("CLOCK_PROCESS_CPUTIME_ID: %ld, %ld\n", ts.tv_sec, ts.tv_nsec);  

	clock_gettime(CLOCK_THREAD_CPUTIME_ID, &ts);
	printf("CLOCK_THREAD_CPUTIME_ID: %ld, %ld\n", ts.tv_sec, ts.tv_nsec);  

	return 0;
}

需要链接 pthread 和 rt

/*******************************************************************************
*	模块名: 通用单链表头文件
*	文件名: std_list.h
*	功能说明: 通用单链表库,不允许添加相同数据(可在实现中修改)
*	作者: 唐文凯
*	版本: V0.1
--------------------------------------------------------------------------------
*	修改记录:
*	日期			版本		修改人		修改内容
*	20120425	0.1		  唐文凯		创建
*******************************************************************************/
#ifndef __STDLIST_H__
#define __STDLIST_H__

#ifdef __cplusplus
extern "C" {
#endif

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <pthread.h>

//回调函数模型定义,不用修改,需要保证传参个数和原函数一致
typedef int (*func)();

//数据结构定义,自行修改
typedef struct tagDataType
{
	int data;
}TDataType;

//结点结构定义
typedef struct tagListNode
{
	TDataType m_tData;
	struct tagListNode *pnext;
}TListNode;

//单链表
typedef struct tagList
{
	//数据结点
	TListNode *m_ptNode;
	//添加结点回调函数,原型 m_pfNodeNew(TCList *pList,TDataType *pData)
	func m_pfNodeNew;
	//删除结点回调函数,原型 m_pfNodeDel(TCList *pList,TListNode *pNode)
	func m_pfNodeDel;
	//打印结点回调函数,原型 m_pfPrint(TCList *pList)
	func m_pfPrint;
	//清空结点回调函数,退出时不调用会产生内存泄露,原型 m_pfQuit(TCList *pList)
	func m_pfQuit;
	//自定义回调函数,用于扩展
	//func m_pfSort;
	//互斥锁
	pthread_mutex_t m_tMutex;
}TCList;

//初始化单链表,	已定义回调函数可以在调用ListInit后重载
int ListInit(TCList *pList);

#ifdef __cplusplus
}
#endif

#endif //__STDLIST_H__

################################################################################
#std_list.c
################################################################################

/*******************************************************************************
*	模块名: 通用单链表头文件
*	文件名: std_list.c
*	功能说明: 通用单链表库
*	作者: 唐文凯
*	版本: V0.1
--------------------------------------------------------------------------------
*	修改记录:
*	日期			版本		修改人		修改内容
*	20120425	0.1		  唐文凯		创建
*******************************************************************************/
#include "std_list.h"

#define SAFE_FREE(p) \
do{\
	if((p) != NULL)\
	{\
		free(p);\
		(p) = NULL;\
	}\
} while(0);

//增加结点
int CreateNode(TCList *pList,TDataType *pData);
//删除结点
int DeleteNode(TCList *pList,TListNode *pNode);
//打印结点
int ListPrint(TCList *pList);
//释放结点
int ListDestroy(TCList *pList);

//初始化单链表,创建互斥锁,注册回调函数
int ListInit(TCList *pList)
{
	int nRet;

	nRet = pthread_mutex_init( &pList->m_tMutex, NULL );

	pList->m_pfNodeNew = CreateNode;
	pList->m_pfNodeDel = DeleteNode;
	pList->m_pfPrint = ListPrint;
	pList->m_pfQuit = ListDestroy;

	return nRet;
}

//申请结点
TListNode *MallocNode()
{
	TListNode *pNode = (TListNode*)malloc(sizeof(TListNode));
	if(pNode)
	{
		memset(pNode,0,sizeof(TListNode));
		pNode->pnext = NULL;
	}

	return pNode;
}

//添加结点
int CreateNode(TCList *pList,TDataType *pData)
{
	pthread_mutex_lock( &pList->m_tMutex );

	TListNode *pTemp = pList->m_ptNode;
	TListNode *pNew = MallocNode();

	if(pNew&&pData)
	{
		//数据拷贝!
		//pNew->m_tData.data = pData->data;
		memcpy(&pNew->m_tData,pData,sizeof(TDataType));
	}

	if(pTemp)
	{
		while(pTemp)
		{
			//是否允许添加相同数据!
			if(CompareNode(pTemp,pNew))
			{
				SAFE_FREE(pNew);
				break;
			}
			if(pTemp->pnext)
			{
				pTemp=pTemp->pnext;
			}
			else
			{
				pTemp->pnext = pNew;
				break;
			}
		}
	}
	else
	{
		pList->m_ptNode = pNew;
	}

	pthread_mutex_unlock( &pList->m_tMutex );

	return 0;
}

//比较结点
int CompareNode(TListNode *pNode1,TListNode *pNode2)
{
	if(pNode1&&pNode2)
	{
		//比较数据!
		//if(pNode1->m_tData.data==pNode2->m_tData.data)
		if(0 == memcmp(&pNode1->m_tData,&pNode2->m_tData,sizeof(TDataType)))
		{
			return 1;
		}
	}

	return 0;
}

//删除结点
int DeleteNode(TCList *pList,TListNode *pNode)
{
	pthread_mutex_lock( &pList->m_tMutex );

	TListNode *pTemp = pList->m_ptNode;
	TListNode *pDel = NULL;

	if(CompareNode(pTemp,pNode))
	{
		pList->m_ptNode = pList->m_ptNode->pnext;
		SAFE_FREE(pTemp);
	}
	else
	{
		while(pTemp&&pTemp->pnext)
		{
			if(CompareNode(pTemp->pnext,pNode))
			{
				pDel = pTemp->pnext;
				pTemp->pnext = pTemp->pnext->pnext;
				SAFE_FREE(pDel);
			}
			else
			{
				pTemp=pTemp->pnext;
			}
		}
	}

	pthread_mutex_unlock( &pList->m_tMutex );

	return 0;
}

//打印结点
int ListPrint(TCList *pList)
{
	pthread_mutex_lock( &pList->m_tMutex );

	TListNode *pTemp = pList->m_ptNode;
	while(pTemp)
	{
		//打印数据!
		printf("Node 0x%x Data %d\n",pTemp,pTemp->m_tData.data);
		pTemp=pTemp->pnext;
	}

	pthread_mutex_unlock( &pList->m_tMutex );

	return 0;
}

//销毁结点
int ListDestroy(TCList *pList)
{
	while(pList->m_ptNode)
	{
		pList->m_pfNodeDel(pList,pList->m_ptNode);
	}

	return 0;
}

#ifdef LIST_TEST
void *printlist(void *arg)
{
	TCList *pList = (TCList *)arg;

	printf("thread print\n");

	pList->m_pfPrint(pList);
}

int main(int argc,char *argv[])
{
	pthread_t tid;

	TCList m_tList;
	TListNode m_tNode;
	TDataType m_tData;

	memset(&m_tList,0,sizeof(TCList));
	memset(&m_tNode,0,sizeof(TListNode));
	memset(&m_tData,0,sizeof(TDataType));

	//初始化List
	ListInit(&m_tList);

	//添加数据
	m_tData.data = 1;
	m_tList.m_pfNodeNew(&m_tList,&m_tData);
	m_tData.data = 2;
	m_tList.m_pfNodeNew(&m_tList,&m_tData);
	m_tData.data = 3;
	m_tList.m_pfNodeNew(&m_tList,&m_tData);
	m_tData.data = 4;
	m_tList.m_pfNodeNew(&m_tList,&m_tData);
	m_tData.data = 5;
	m_tList.m_pfNodeNew(&m_tList,&m_tData);

	//打印
	pthread_create(&tid,NULL,printlist,(void *)&m_tList);
	pthread_join(tid,NULL);

	printf("test print\n");
	m_tList.m_pfPrint(&m_tList);

	//删除
	printf("test del\n");
	m_tNode.m_tData.data=3;
	m_tList.m_pfNodeDel(&m_tList,&m_tNode);
	m_tList.m_pfPrint(&m_tList);

	//测试添加相同元素
	printf("test add same\n");
	m_tData.data = 5;
	m_tList.m_pfNodeNew(&m_tList,&m_tData);
	m_tList.m_pfPrint(&m_tList);

	printf("test quit\n");
	m_tList.m_pfQuit(&m_tList);//释放内存
	m_tList.m_pfPrint(&m_tList);

	return 0;
}
#endif //LIST_TEST

################################################################################
#gcc -g -o list_test -DLIST_TEST -I. -lpthread
################################################################################

目前最低可成交价 58300 出价范围 58000~58600

如果是一场公开的拍卖,为什么出价范围可以比最低成交价低?

最低价58300,均价58600,为何离散程度如此之低?

今天拍牌再次失败!!

上次总结了一下上海牌照高价的成分,今天看来还是不够充分.

现在看来一切皆是浮云…

目前最低可成交价 58300 出价范围 58000~58600

以上价格只是打个比方,如果是一场公开的拍卖,为什么出价范围可以比最低成交价低?

今天看了KDS,一句话惊醒了我,这个低价是给黄先生留的后路啊…

只能说我愚钝,拍了2次才看透.

上海牌照的价格只是在一部分力量的推动下稳步上升,还按照了经济发展的规律有条件的稳步上升…

本以为这次软件更新可以造成一定的影响,谁知道还能登陆老客户端?这算向下兼容?

换个角度说吧,最低价58300,发放8000张牌照,按照拍卖的规律就是有8000个价格是在58300以上,但是均价为何能稳定在58600呢?

个人觉得按照离散数学的分析,这种情况发生的概率在μ=0.05的情况下为0.05%,真相只有一个,黄先生只是哄抬了最低价格,然后通过低于最低可成交价的价格撤离了…

所以结果就是吾等平民眼睁睁看着上海牌照的价格稳步上升…

悲哀啊…

上海牌照真心贵啊!

首先百元联盟的思想是准确无误的,首轮出价100元(加价幅度亦为100元),只要出价就能进入第二轮,不但没有任何损失而且可以平抑最低价.

这么分析吧,想要拍牌照的大致分为四类人:

1A.富贾–他们可以不管市场价格,只要砸钱就可以拍到上海牌照.

2B.黄先生–他们为谋求高额利润,不惜代价把价格抬高.

3C.平民–像我们这样的广大人民,买车已经累的半死,牌照还让我们吐血.

4D.神秘人–我不确定是否存在黑手的操纵,但是价格依旧很高.

假设本次投放8000张牌照,参与投标人数为25000人

去除2500个1A,2500个2B,还剩3000个名额有3C和4D掌控

如果去除3000个1A,3000个2B,还剩2000个名额

我真不想说真有这么多富贾?有钱的早就买好车啊牌啊的了吧

难道还会有这么多黄先生?估计有,但还是有3C和4D的名额

结论:只要有1000个3C,最低价就由我们说了算!

在3C中,可能还存在着一些思想上有误区的人,只要把百元联盟的思想普及,我就不信拍不到低价,毕竟3C是底层,占着绝大部分的名额.

观察:

第一次拍牌,看着飞涨的价格心有不甘!

百元联盟的100元坚持了将近45分钟,后续就是黄先生的哄抬物价,和小部分3C的漫无目的的乱出价…涨幅基本就是千、万级的…何必呢?第一轮出多少根本没有任何意思,它只产生一个最低价!!

操作:

首轮出价:当前人数除以2000乘以100,所以组织2千人100元,2千人200元,2千人300元…当有大于总人数减去投放量的时候…

(论证:当有足够多人出价100元时,加价幅度依然会陡升)

时间:10:00:00~10:59:59

3C们,三思吧,象征性的出个一两百元就够了

第二轮出价:

看3C们的RP了…

上海牌照真心贵啊!大家帮转吧,不管是已经拍到的还是即将要拍牌的!

引导语：不知道十年的时间究竟有多长。

十年前，在我们的脑海中；

十年后，却在深深的心底。

时光煮雨，我们在时间上行走。

我们是拥有情感的人类，我们在亲情、爱情、生活、信念、友情的岁月冲洗下，

十年前，十年后，我们的情感有了什么变化……

父母
十年前我们是父母的孩子，十年后我们是孩子的父母；
十年前我不知道家的温馨，十年后我才体会家的温暖；
十年前我渴望离家去远方，十年后我渴望从远方回家；
十年前我对父母大吵大嚷，十年后我希望父母再骂我一次。

爱情
十年前你是我的同桌，十年后你成了别人的妻子；
十年前我唱着同桌的你，十年后我想着同桌的你；
十年前我们面对的唯一问题是考试，十年后我们除了考试所有的问题都要面对；
十年前我在你家楼下记住了你嫣然的回眸一笑，十年后我在你家楼下看到你训斥孩子的严厉面孔；
十年前我渴望马上结婚，十年后我渴望再谈一次恋爱；
十年前我们谈及爱情，总是羞涩，十年后我们谈及爱情，却是生涩；
十年前我渴望爱情，但不知道什么是爱情，十年后我知道了什么是爱情，却不再拥有爱情。

生活
十年前我骑着自行车，吹着欢快的口哨，走在回家的路上，
十年后我开着私家车，接着不断的电话，走在应酬的路上；
十年前我渴望住进五星饭店，十年后我住进五星饭店，却想回家；
十年前我渴望坐一次飞机，十年后我最害怕的就是坐飞机；
十年前我踢完球，走过咖啡屋的窗前，希望女生对面的男生是我，
十年后我望见咖啡屋外走过的刚刚踢过球的孩子，希望我是其中一个；
十年前我们被父母和老师逼到课桌前，认真听讲，
十年后我想再次听讲，却找不到课桌；
十年前我鄙视饭店门前的酒鬼，发誓一辈子也不喝酒，
十年后我就是饭店门前的那个酒鬼；
十年前我渴望有朝一日坐上自己的私家车，不再走路，
十年后我渴望走路，不再开私家车；
十年前我希望显露出的是成熟，十年后我去美容，希望青春永驻；
十年前我顿顿想着吃肉，十年后我顿顿想着吃青菜。

校园
十年前看到班主任的大眼镜便倍感恐惧又心生忌恨，
十年后梦到班主任的音容笑貌倍感亲切又黯然神伤。
十年前一边表扬把外语老师气哭的同学，一边说“这老师不行”，
十年后一边安慰被学生气哭的女同事，一边说“现在的学生真差”。
十年前还有几分“卫朗清瘦”的我，讥笑老九太胖，
十年后只剩一片“宋玉情怀”的我，被老九讥笑‘后来者居上’。
十年前在寒冷的冬夜翻过一丈高的围墙，去打摇杆游戏兴致盎然，
十年后在温暖的家里堆座床上喝着热咖啡，打网络游戏倍感无聊。
十年前在篮球场上我可以一口气得三十分，
十年后我负责防守的家伙可以得三十分！
十年前向往军校的我，和同学们表达我的从军理想，
十年后转业一年的我，和战友们回顾军营的酸甜苦辣。
十年前有做不完的复习资料需要完成，
十年后有理不清的人际关系需要打理。
十年前只有考试是唯一的负担，
十年后除了考试有太多的负担。
十年前总爱翻看高考简章，想着自己如何上个名牌学校；
十年后总爱关注招聘启事，想着自己怎么找到一份兼职。
十年前对班里的桃色新闻倍加关注，
十年后漠然接过请帖去参加同学婚礼，管他新娘是谁。
十年前向家里人保证“王八蛋才谈爱情”，
十年后倍受伤害的我对着朋友大喊“爱情是王八蛋”！
十年前见小混子欺负人，我能“路见不平一声吼，不畏头破血又流”，
十年后见路边行乞的老人却舍不得兜里的两块硬币！
十年前我“为赋新词强说愁”，
十年后我“为说愁强赋新词”！

工作
十年前我们为打一个电话四处寻找公用电话，十年后我们有了手机，依然四处奔波；
十年前我月薪的目标是1000，十年后我月薪6000元，依然无法快乐；
十年前我最怕的就是批评，十年后我最难得的却是批评；
十年前200元钱我可以花一个月，十年后2000元钱我才可以吃一顿饭；
十年前我们穿着统一的校服，朴素中透出的是阳光般的灿烂，
十年后我们穿着名牌的服装，华贵中流露出的是淡淡的忧郁；
十年前我们可以蓬头垢面，满脸汗渍的去上课，
十年后我们必须衣冠楚楚，面带微笑的去上班；
十年前我痛恨F·B（腐败），十年后我F·B了。

信念
十年前我以为自己是一棵大树，十年后我才明白自己只不过是一棵小草；
十年前我唯一可以浪费的就是时间，十年后我除了时间什么我都可以浪费；
十年前我们可以说青春无悔，十年后我们只能说青春不在；
十年前我们可以游戏人生，十年后我们却处在人生的游戏中。

编后语：十年前总是计划着十年后，十年后总是怀念着十年前。

我们细数心底的那些，温暖而又美好的事情，我们憧憬未来，拥有现在，我们的情感总是那么丰富，记得要乐观，记得好好爱自己，爱父母，爱他人。

十年会过得很快，一转眼就过去了……

地点：上海世博园区 白莲泾路（世博大道与浦东南路间，原世博园4号入口）

2011上海国际嘉年华游乐项目价格表

2 小狐狸偷偷喜欢上了一只小兔子，它每天傍晚都要跑到一个无人的山谷大喊一声‘小兔子，我喜欢你！’然后山谷里就会传来‘我喜欢你’的回音。小狐狸就那么喊了九十九天，等到一百天时它已经决定要放弃了。它最后一次来到山谷大声地几乎是绝望地喊道‘我喜欢你’。‘我也喜欢你’，山谷的某处传来了回应。

3 入冬了，怕冷的小狐狸去小兔子开的森林杂货铺买了一件温暖牌的毛衣，一条温暖牌的围巾，还有一个温暖牌的水杯。小狐狸呆在家里穿着毛衣戴着围巾喝着杯子里的热水，可还是觉得有点冷，‘到底还缺些什么呢？’小狐狸想了想那家森林杂货铺还有铺子里那只可爱的小兔子，‘大概我还缺一个温暖牌的拥抱。’

4 森林小学这个星期的作文题目是《我最喜欢的XXX》，小老虎写了我最喜欢的森林得了最高分九十九分，小浣熊写了我最喜欢的老师得了八十五分，小狐狸写的我最喜欢的小兔子却因为涉及早恋老师只给了十分。‘对不起，’放学后小狐狸对小兔子说，‘我对你的喜欢才得了十分。’‘那是因为你十分喜欢我啊。’小兔子微笑着说。

5 ‘请你驯服我吧。’小狐狸对小兔子说。‘什么是驯服？’小兔子不解地问。‘这是我们狐狸家族的一个传统….’小狐狸对小兔子解释起驯服的涵义来。‘那么你愿意驯服我吗？’小狐狸问。小兔子轻轻点了点头。但有件事是小狐狸没有告诉小兔子的，那就是当你用心驯服了一样事物时，往往你也已经被它驯服了。

6 最近胡萝卜大丰收。小兔子吃了好多好多胡萝卜结果把自己吃成了一个小胖子。这天傍晚它和小狐狸一起在森林里散步时，突然像它从前常常做的那样一下子跳到了小狐狸的背上想要小狐狸背着它走。可小狐狸却一下被压倒在了地上，‘我是不是该减肥了？’小兔子哭着对小狐狸说，似乎第一次意识到现在的自己究竟有多重，‘不是的，’小狐狸趴在地上说，‘是我该锻炼身体了。’

7 “小狐狸，如果我和你妈妈同时掉进水里面了，你会先救谁呢？”小兔子问小狐狸。“当然是先救你啊。”小狐狸想都没想就回答。小兔子心里很开心，但表面还是假装生气地问道：“为什么要先救我呢？那你妈妈该怎么办啊？”“我妈妈才不会和我计较这种傻问题呢。”小狐狸在心里想道。

8 被小兔子问了那个‘你会先救谁’的问题之后，小狐狸当时虽然不在意，可后来还是去了游泳学校一边学习游泳一边在心里思索着这个问题。在被水呛到了好几次之后小狐狸慢慢学会了游泳，可那个问题依旧没有答案。于是有天小狐狸就不再去学游泳了，‘还是不会游泳的好，’小狐狸心想，‘这样如果我妈妈和小兔子都掉河里了，我也跳下去陪它们好了。’

9 小狐狸最喜欢做的事就是吹泡泡糖了。而且最厉害的是它能把泡泡糖吹成不同的形状。‘你能吹出一个胡萝卜来吗？’小兔子有天对小狐狸说。‘当然！’小狐狸脑海中想象着胡萝卜的样子然后就把泡泡吹了出来。果然是一根胡萝卜的形状。‘小狐狸，你简直是个魔法师！’小兔子尖叫道，‘那你能吹出一个和我长得一模一样的泡泡来吗？”小兔子问。“这有什么难的？’小狐狸一边看着小兔子一边吹起了泡泡糖。可它吹出来的泡泡却是一颗心的模样。

10 ‘我能亲亲你吗？’小狐狸问身边正在吃爆米花的小兔子。‘嗯…’小兔子歪着脑袋想了想，‘我们一人吃一口爆米花吧，如果这袋爆米花最后一个是你吃到的我就让你亲我。’小兔子说。结果是小兔子吃到了最后一个。小狐狸沮丧地低下了头，小兔子却迅速亲了一下它的脸庞。‘如果是我吃到，就换我来亲你。’小兔子补充道。

11 ‘爱我、不爱我、爱我、不爱我…’小狐狸用玫瑰的花瓣占卜着自己的爱情。‘爱我！’揪掉最后一片花瓣时小狐狸兴奋地大叫道。它满怀信心地去找小兔子告白了。小狐狸刚刚走后，一只蝴蝶飞了过来。经过一天一夜地反复挣扎蝴蝶终于决定向它最爱的那朵玫瑰示爱了。可它看到的却是玫瑰凋零满地的尸身。

12 天空突然下起了大雨，小兔子被困在了一株大蘑菇底下。过了一会来了一只可爱的小松鼠，它看到在大蘑菇下面避雨的小兔子于是就问她：“我送你回家好吗？”“谢谢你小松鼠，不过我正在等人呢。”小兔子说。“那我把我的这把伞给你好了。”小松鼠说。“不用了，我想我不需要雨伞。”小兔子说。于是小松鼠有些失望地走了。过了好大一会小狐狸从大雨中冲了过来，“大笨蛋，你的伞呢？”小兔子看着浑身湿透的小狐狸心疼地问道，“我不是来给你送伞的，”小狐狸对小兔子说，‘我是来陪你一起淋雨的。

Restore: mysql -uUser -pPass

use DBName

source Path/Name.sql

当当当，他敲响了房门。

门开了，从里面探出一个人来。

“兄弟，需要台灯么？”他是个推销员。 　　

“你大爷！” 　　

他愣了一下，又说：“兄弟，新产品，你可以看看。” 　　

“你大爷！！” 　　

没有说错话啊，他想。“兄弟，不买台灯你也别骂人啊。”

“你大爷！你看看，我是兄弟么？” 　　

他仔细一看，哦，竟然是个姑娘。 　　

就这样，他们就算认识了。 　　

2 　　

周一。“姑娘，需要台灯么？”

“不需要。” 　　

周二。“姑娘，需要台灯么？”

“不需要！” 　　

周三。“姑娘，需要台……”

“不！需！要！” 　　

周四。“姑娘，需要什么？”

“除了台灯！！” 　　

周五。“姑娘，需要男朋友么？”

“……” 　　

就这样，他们就在一起了。 　　

3 　　

有人觉得他不靠谱，怎么那么快就喜欢上一个人。

有人觉得她草率，怎么那么快就答应了他。 　　

他说，这叫一见钟情。

她说，这叫意志不坚定。 　　

4 　　

那天，他带她去看电影。 　　

他想，到哪个感人的情节时，牵她的手；或者，到哪个感人的情节时，搂着她的肩膀。 　　

可是，电影结束了，他也没有得逞。 　　

他胆小？不是。他睡着了？也不是。 　　

原来，他们那天看的是——《孔子》。 　　

5 　　

电影结束了，他送她回家。 　　

她一边搓着双手，一边说：“我手冷。”

他听了之后，像个男人一样，把自己的手套给了她。 　　

这次，变成他手冷了。 　　

他说：“我手冷。”

她说：“放自己口袋里。” 　　

他窃笑，“我裤子口袋满了！” 　　

她也笑，“放在羽绒服口袋里。” 　　

他一边挡着口袋，一边说：“我羽绒服没有口袋！”

“那怎么办？”

“这样就不冷了。”说着，便拉过了她的手。

仅仅过了3秒，他就放开了。为啥？ 　　

她到家了。 　　

她上楼，他坐车回家。

一路上，高兴得不得了。

下了车，还疯了似的，不停地跑。 　　

后来，有人问他：“这么高兴啊？” 　　

“屁，”他说，“哥的手机丢车上了！” 　　

6 　　

一天，她给他打电话。“真的喜欢我啊？”

“嗯！”他坚定地说。 　　

“我不是个好姑娘。”

“没事，我不在乎。” 他坚定地说。 　　

“我之前搞过好几个对象。”

“没事，我不在乎。”他坚定地说。 　　

“其实，我不是姑娘，我是个男人。” 　　

“没事，我不在乎。”他坚定地说。 　　

过了三秒钟，他说：“等会儿，你刚刚说啥？” 　　

他知道，她爱恶作剧。 　　

她喜欢用别人的手机，给他打电话。“你猜我是谁？”

“你是我女朋友。”

“再猜。”

“你是我媳妇儿。” 　　

“乖。” 　　

时间长了，就形成习惯了。 　　

每当看到陌生的电话打来，他一接电话，就说：“你是我媳妇儿。” 　　

这天中午，又是个陌生电话。

他接了就说：“你是我媳妇儿！”

电话那头，传来个熟悉的声音。 　　

“我是你妈，儿子，妈妈的手机丢了。” 　　

“……阿姨你好，我是你儿子的同学，他出去了不在。” 　　

7 　　

每次出去玩，她总是问他去哪。

他说：“去看电影吧。”

她说：“不去，没好看的。” 　　

他说：“去打台球吧。”

她说：“不去，你打不过我。”

他说：“那你还问我？”

她说：“你可以帮我排除错误答案。” 　　

他说：“……” 　　

她说：“去逛街吧。”

他说：“走！” 　　

她喜欢他的民主，他喜欢她的专政。 　　

他们都乐此不疲。 　　

8 　　

他是个学生，她也是个学生，他们的大学离得很远，相距一个半小时的车程。 　　

电话和短信，成了他们联系的主要方式。 　　

一天晚上，他收到了一条短信：“亲爱的，快来。”

他疯了似地跑了出去，生怕她有什么危险。 　　

刚到她宿舍的楼下，又是一条短信：“快来你宿舍楼下，我找你来了。”

短信发送时间是一个半小时之前。

他的电话响了，他按下接听，还没来得及说话，就听：“我在你宿舍楼下，快下来！” 　　

他无辜地说了句：“……我也在你宿舍楼下。” 　　

“你大爷的中国移动！”两个人同时说。 　　

结果那天，两个人谁也没回宿舍，他们去了家快捷酒店。

他坚持睡沙发，并一再坚持“禁止婚前OOXX行为”原则。 　　

她说：“……我怕你感冒。” 　　

他说：“你早说，冻死我了。” 　　

9 　　

他是个有稀奇古怪点子的人。 　　

这天，他用磁带录了一段自己写的浪漫的诗，给她送去了。 　　

第二天，她说，歌曲挺好听的。

他认为，她不喜欢诗而喜欢歌曲。 　　

于是，他又用磁带录了一段自己唱的歌曲，给她送去了。 　　

第二天，她说，故事挺好的。 　　

他问她，你为什么没有听磁带？ 　　

她无奈地说：“我找了全宿舍楼也没有找到能放磁带的录音机！” 　　

“那你怎么敢说磁带里的内容的？” 　　

“我猜的。” 　　

“你怎么猜的？”

“你自己看！” 　　

录着他写的诗的磁带，是迈克尔·杰克逊的专辑；录着他唱的歌的磁带，是孙振爷爷讲鬼故事。 　　

10 　　

传说，在摩天轮最高的地方，亲吻你爱的人，你们就能天长地久。 　　

他问她，你知道摩天轮的传说么？她摇头。

他说，我带你去，你就知道了。 　　

到了摩天轮的最高点，他才知道，她有恐高症。

悲剧，悲剧，悲剧，他一边心里默念，一边扶着她，到附近的麦当劳休息。 　　

“对了，你还没告诉我摩天轮的传说。” 　　

“传说在摩天轮最高的地方，亲吻你爱的人，就能天长地久。” 　　

她沉默了几秒，问：“你听说过麦当劳的传说么？”

“没有，那是什……” 　　

他还没有说完，她就轻轻吻了上去。 　　

她问：“知道什么是麦当劳的传说了么？” 　　

他连连点头。 　　

11 　　

一天夜里，她哭着给他打电话，“我梦到你不要我了！” 　　

他想了想，说：“我梦到中国足球拿世界杯冠军了。” 　　

“不可能！！你的梦太假了。” 　　

“嗯，我觉得你的梦也是。” 　　

12 　　

他们闹别扭了。 　　

也没啥，就是她和别人玩QQ斗地主，一天没理他。

一天不是问题，只是，那个别人是她前对象。 　　

她是个不伤人的人，分手了，也能做朋友，他知道。 　　

但是他就是别扭。 　　

“下次别和‘别人’玩了，成不？”

“你吃醋了啊？”

“嗯。” 　　

“哈，活该，谁让你忘了昨天是什么日子！” 　　

他愣了一下，忽然想起来。昨天是他爸爸生日。 　　

他没有说什么，抱了她一下。 　　

拨了个电话，“喂，老爸，生日快乐。” 　　

挂电话之前，他说：“爸，我给你找了个孝顺的儿媳妇。” 　　

13 　　

“给，送你的。”

说着，他递给她一个精美的盒子。 　　

“今天什么日子哟？”“我们在一起一年半了。” 　　

“一年半还庆祝啊？”

“半年一小庆，一年一大庆。紧跟国家脚步！” 　　

“哈哈———” 　　

她打开包装，是一个台灯。 　　

“姑娘，需要台灯么？”

“不需要。” 　　

“姑娘，需要什么？”

“除了台灯！” 　　

“姑娘，需要男朋友么？”

“不需要！” 　　

“啊？” 　　

“需要个老公！” 　　

那个台灯很别致，是他手工做的。 　　

在按钮那，是按照她做的公仔；而灯泡，则是按照他做的公仔。 　　

她笑着问：“你愿意做灯泡啊？” 　　

他笑着答：“是啊，你就是开关。”

他顿了顿，“只要你动一动，我就为你发光。” 　　

“那我要是不动呢？”她要难为难为他。 　　

“嗯？……”他想了想：“我就来修理修理！” 　　

说着，使劲捏了捏她的小脸。 　　

14 　　

毕业了，他去了外地，而她，却留在了本地。 　　

“等我回来。”

“嗯！” 　　

“我每个月都能回来！” 　　

“嗯！” 　　

异地，折磨爱情；现实，摧残爱情。 　　

起初，她每天计算他回来的日子；而他，也在倒数。 　　

后来，短信渐渐少了，电话渐渐少了。他觉得。　　

每次他回来，她都像例行公事似的，很少开心，很少欢乐，很多沉默。 　　

15 　　

终于有天，她还是对他说了：“我们，分手吧。” 　　

那一刻，他愣住了：“为什么？” 　　

“我累了。” 　　

“休息之后呢？”

“我习惯了一个人的生活。” 　　

他直接冲到火车站。

票没了，他找票贩子，被骗了700多。 　　

最后，他花了身上仅剩的180元，买了张站票，站了23个小时。 　　

“你走吧，我不会见你。”这是她发给他的最后一条短信。 　　

他就这样，在她楼下等了一夜。 　　

那一刻，他才知道，如果一个人不爱了，就真的是不爱了。 　　

16 　　

两年后，他出国了，一个人去了希腊工作和生活。

而她，也找到了自己爱的人，结婚生子。 　　

每年，他和她在一起的那一天，她总是能收到他寄来的希腊的美丽风景照片。 　　

他记得，某年的某天，她曾经告诉他，她想去希腊。在他心里，他欠她一个希腊。 　　

她的丈夫总是问，这些东西是谁寄的？ 　　

她说，一个朋友，老朋友。 　　

17 　　

2011年10月23日，她看了看日历，又到了那天。

她习惯性地去邮箱，打开，却发现空空的，什么都没有。 　　

大概，是邮递员还没有送到吧？她想。 　　

那天晚上，她做了个梦，又回到那天，他们在一起的那一天。 　　

那一年，他20岁，她19岁。 　　

“兄弟，需要台灯么？”

“你大爷！” 　　

“姑娘，需要台灯么？”

“不需要！” 　　

“姑娘，需要男朋友么？” 　　

“……” 　　

忽然，她醒了，分不清刚刚是梦境，还是现实。

她好像听到门外有人说话，仔细一听，却又没有声音。 　　

看了看表，凌晨2点24分。 　　

大概，是太累了。她又睡了过去。 　　

（后记） 　　

第二天，她打开收音机，传来一条新闻。 　　

“本台报道，北京时间今日凌晨2点22分，在希腊北部发生强烈地震，目前已造成832名居民死亡，2万多居民受伤，这一数字还在增加。” 　　

此后，再也没有人，给她寄来照片。