继续学习memcached:（下面大部分是我从网上看来总结的）

A.一定要记着,memcached是缓存，所以不会永久保存在机器上，重启就没了

B. memcached会优先使用已超时的记录的空间，但即使如此，也会发生追加新记录时空间不足的情况，此时就要使用名为 Least Recently      Used（LRU）机制来分配空间。顾名思义，这是删除“最近最少使用”的记录的机制。因此，当memcached的内存空 间不足时，就从最近未被使用的记录中搜索，并将其空间分配给新的记录。从缓存的实用角度来看，该模型十分理想。
不过，有些情况下LRU机制反倒会造成麻烦。memcached启动时通过“-M”参数可以禁止LRU，如下所示：

$ memcached -M -m 1024

启动时必须注意的是，小写的“-m”选项是用来指定最大内存大小的。不指定具体数值则使用默认值64MB。

指定“-M”参数启动后，内存用尽时memcached会返回错误。话说回来，memcached毕竟不是存储器，而是缓存，所以推荐使用LRU。

C. 上面说的是memcached的一种缓存控制，另一种就是memcached内部不会监视记录是否过期，而是在get时查看记录的时间戳，检查记录是否过 期。这种技术被称为lazy（惰性）expiration。因此，memcached不会在过期监视上耗费CPU时间。就是以检查记录的时间戳来看数据是 否过期，这个过期时间是可以人为控制的

D.memcached的分布式
memcached虽然称为“分布式”缓存服务器，但服务器端并没有“分布式”功能。至于memcached的分布式，则是完全由客户端程序库实现的。这种分布式是memcached的最大特点。
memcached的分布式是什么意思？

这里多次使用了“分布式”这个词，但并未做详细解释。现在开始简单地介绍一下其原理，各个客户端的实现基本相同。

下面假设memcached服务器有node1～node3三台，应用程序要保存键名为“tokyo”“kanagawa”“chiba”“saitama”“gunma” 的数据。

首先向memcached中添加“tokyo”。将“tokyo”传给客户端程序库后，客户端实现的算法就会根据“键”来决定保存数据的memcached服务器。服务器选定后，即命令它保存“tokyo”及其值。

同样，“kanagawa”“chiba”“saitama”“gunma”都是先选择服务器再保存。

接下来获取保存的数据。获取时也要将要获取的键“tokyo”传递给函数库。函数库通过与数据保存时相同的算法，根据“键”选择服务器。使用的算法相同，就能选中与保存时相同的服务器，然后发送get命令。只要数据没有因为某些原因被删除，就能获得保存的值。

这样，将不同的键保存到不同的服务器上，就实现了memcached的分布式。 memcached服务器增多后，键就会分散，即使一台memcached服务器发生故障无法连接，也不会影响其他的缓存，系统依然能继续运行。

不通的客户端语言都有对应的分布式调用方法

E.下面放上一篇实际应用的文章，小日本的..应用

1.安装memcached
要求：我的测试平台为RHEL AS4U4, 安装钱要确认是否安装了libevent和libevent-devel rpm, 可以去DAG下载，平台的对应版本要正确。
memcached-1.2.6.tar.gz去官方下载
安装：安装为标准的编译安装方式，./configure; make; make install 即可

启动为memcached -p port -m 2048m -d; 指定端口和内存的占用，以后台的方式运行，详细的查看help

2.安装memcache-client gem
安 装前先要安装依赖的gem，有ZenTest, hoe, rubyforge, 其中rubyforge这个gem在rubyforge.org上没法搜索到，而且使用gem install rubyforge的安装方式也老是报错，在英文版的google里多搜搜就行了

现在在ruby下已经可以使用这个gem了，使用前要require 'memcache';, 可以查看ri MemCache

3.安装rails的插件
现 在rails结合memcached的插件有acts_as_cached, cache_fu, cache_model, 其中cache_fu是acts_as_cached的加强版，所以推荐使用cache_fu，安装使用ruby script/plugin就行了

cache_fu的使用比较简单，可以看下插件下的README，或者google下，具体的使用再慢慢研究....

开始搞rails的memcache的了，
几个概念：
1.memcached是一个开源项目，提供高性能的分布式缓存集群
2.大多数的开发语言都有对应的访问memcached的客户端接口
3.现在已经有了memcached结合数据库的工具，如memcachedb，memcache_engine;其中memcache_engine是专门对应MySQL的缓存引擎
4.memcache-client gem和memcache gem是两个对应ruby的memcached的接口，其中memcache gem是最新的，据说速度比memcache-client快150倍，但可能还不成熟
5.cache_fu(即acts_as_cached)是rails的结合memcached的插件，可以方便的控制数据库的查询缓存

好了几本的概念说完了，下面就贴一点网站找来的文章吧...

-----------------------------------------shitou的分割线-------------------------------------

       缘起: 在数据驱动的web开发中，经常要重复从数据库中取出相同的数据，这种重复极大的增加了数据库负载。缓存是解决这个问题的好办法。
Memcached是什么?
Memcached是由Danga Interactive开发的，高性能的，分布式的内存对象缓存系统，用于在动态应用中减少数据库负载，提升访问速度。

Memcached能缓存什么？
       通过在内存里维护一个统一的巨大的hash表，Memcached能够用来存储各种格式的数据，包括图像、视频、文件以及数据库检索的结果等。

Memcached快么？
非常快。Memcached使用了libevent（如果可以的话，在linux下使用epoll）来均衡任何数量的打开链接，使用非阻塞的网络I/O， 对内部对象实现引用计数(因此，针对多样的客户端，对象可以处在多样的状态)， 使用自己的页块分配器和哈希表， 因此虚拟内存不会产生碎片并且虚拟内存分配的时间复杂度可以保证为O(1).。
Danga Interactive为提升Danga Interactive的速度研发了Memcached。目前，LiveJournal.com每天已经在向一百万用户提供多达两千万次的页面访问。而这 些，是由一个由web服务器和数据库服务器组成的集群完成的。Memcached几乎完全放弃了任何数据都从数据库读取的方式，同时，它还缩短了用户查看 页面的速度、更好的资源分配方式，以及Memcache失效时对数据库的访问速度。

Memcached的特点
       Memcached的缓存是一种分布式的，可以让不同主机上的多个用户同时访问， 因此解决了共享内存只能单机应用的局限，更不会出现使用数据库做类似事情的时候，磁盘开销和阻塞的发生。

-----------------------------------------shitou的分割线-------------------------------------

libmemcached是一个基于C/C++实现的memcached client library，memcached gem给这个library提供了ruby封装，根据原作者的性能评测，它比目前常用的memcache-client gem最多要快150倍。

因为对memcache的操作在rails处理整个http请求中所占时间比例并不多，而且JavaEye网站大部分是做cache读取操作，于是做了2个试验测试一下2者对于提升整个网站的性能到底有多少帮助:
1. 测试访问JavaEye网站的首页，在这个请求中只有一个缓存读取操作，使用ab简单地跑单次请求10000次：
使用memcache-client，平均完成每个请求是9.247 ms
使用memcached，平均完成每个请求是8.982 ms

对于整体性能提升在3%左右

2. 测试访问某个论坛版面的页面，整个请求有超过60次的缓存读取操作，使用ab简单跑单次请求1000次：
使用memcache-client，平均完成每个请求是95.872 ms
使用memcached，平均完成每个请求是91.591 ms

对于整体性能提升在5%左右

从试验可以看出，对于整体性能还是有一定提高的。JavaEye用的cache插件是cache_fu，它只支持memcache-client，不过通过简单的修改就可以支持这个新gem，我提交了一个补丁，有兴趣的话可以从这里下载到补丁。

--分割线--
cache_fu的作者已经将这个补丁添加到代码树，可以从github checkout:  http://github.com/defunkt/cache_fu/tree/master

-----------------------------------------shitou的分割线-------------------------------------

memcachedb是 一个由新浪网的开发人员开放出来的开源项目，给memcached分布式缓存服务器添加了Berkeley DB的持久化存储机制和异步主辅复制机制，让memcached具备了事务恢复能力、持久化能力和分布式复制能力，非常适合于需要超高性能读写速度，但是 不需要严格事务约束，能够被持久化保存的应用场景，例如memcachedb被应用在新浪博客上面。

memcachedb给 memcached添加了一些数据库才具备的特性，但是我们还不能说memcachedb已经是一个数据库了，这是因为 memcached不支持内存对象的遍历操作，当然更加不能支持复杂的查询操作，只能支持根据已知的key去查询对应的value。因此如果想把 memcachedb当成一个高性能的分布式内存数据库来使用的话，查询的问题就没有办法解决，只能在应用程序里面配合其他方案做一些折衷。

然而memcached的另外一个开源项目完美的填补了这一个缺陷，就是memcache_engine。

memcache_engine 是一个MySQL数据库的存储引擎，目前只支持MySQL5.1数据库，他能够把memcachedb作为 MySQL数据库的一个存储引擎和MySQL集成起来，让用户通过标准的SQL查询语句访问memcachedb中存放的数据，请看如下示例：

Sql代码

1. CREATE TABLE `a` (  
2.     `a` int(11) NOT NULL DEFAULT '0',  
3.     `b` int(11) DEFAULT NULL,  
4.     `c` int(11) DEFAULT NULL,  
5.     PRIMARY KEY (`a`)  
6.     ) ENGINE=MEMCACHE DEFAULT CHARSET=latin1  
7. CONNECTION='localhost:6666\;localhost:6688';  

CREATE TABLE `a` (     `a` int(11) NOT NULL DEFAULT '0',     `b` int(11) DEFAULT NULL,     `c` int(11) DEFAULT NULL,     PRIMARY KEY (`a`)     ) ENGINE=MEMCACHE DEFAULT CHARSET=latin1 CONNECTION='localhost:6666\;localhost:6688';

创 建表a，存放在分布式memcached server：localhost:6666和localhost:6688当中。然后我们就可以使用标准的SQL语句随意的进行CRUD操作去使用 memcachedb了，这实在是太酷了！有了memcache_engine，我们就可以用SQL去访问memcached，有了 memcachedb，我们就不必担心数据丢失问题，事务恢复问题了，简直是绝配，让memcached真正成为了一个高性能的分布式数据库系统了。目前 memcache_engine项目还是早期试验阶段，让我们期待memcache_engine项目早日发布正式版本吧！

顺便多说几句：最近一年来，特别是最近一个月以来，围绕memcached的开源项目发展的非常非常活跃：

1、最近刚刚发布了memcached的新的高性能C客户端接口: libmemcached

2、由于有了libmemcached，该组织又发布了memcache_engine存储引擎，cool！

3、由于libmemcached的发布，不到一周时间，ruby的两个崭新的memcache client就问世了，他们是Caffeine和New memcache-client，让ruby访问memcached的速度大幅度提高，请看：libmemcached发布了，ruby访问memcached提速20倍

4、memcachedb发布了，这是中国的互联网公司贡献的开源项目

以 上几个项目都是在2008年1月发布的，真的不是一般的繁荣阿。再加上之前发布的新的支持异步访问的Java Memcached API和C#接口，可以说除了Python，其他主流非主流编程语言都可以使用memcached了。其实即便是Python还没有公布出来的开源接口， 我们也知道国内的web2.0网站豆瓣就是使用Python访问memcached，并且支持了极大的访问量，因此目前围绕memcached的开源项目 发展的情况非常的繁荣。

memcached最近两年这么受欢迎，其实和互联网web2.0的流行有很大的关系，web2.0网站通 常需要个性化页面，依赖于页面局部和数 据细颗粒度的缓存来提升性能，并且web2.0网站流量都很大，因此memcached这种高性能分布式缓存服务器就大行其道了。

当然我觉得最具有革命意义的还是memcache_engine和memcachedb这两个项目的发布，他们能够让memcached的用途不仅仅限于缓存服务器而已，而是能够真正充当分布式数据库来使用了，这无异是诸多大流量web2.0网站和开发人员的福音阿。

-----------------------------------------shitou的分割线-------------------------------------

放一个链接http://tech.idv2.com/2008/07/10/memcached-001/， 这个介绍的比较详细

下面再详细的说下子线程和主线程的问题

t1 = Thread.new { sleep 100 }
t2 = Thread.new do
  if Thread.current == Thread.main #不会输出
    puts 'this is main thread!'
  end
  1.upto(1000) { sleep 0.1 }
end

count = Thread.list.size #3， 当前有三个线程，一个是运行该脚本的主线程（main thread），一个是t1，还有t2，由于他们正在做循环操作所以没有结束退出，还在当前线程列表中
if Thread.list.include?(Thread.main) #当前就在主线程的环境下
  puts 'Main  thread is alive' #一直都会输出
end

if Thread.current == Thread.main #因为当前环境就在主线程下操作和运行的，所以为true
  puts 'I am main thread' #输出
end

上面用到了几个线程的方法，作用从字面上就可以看出来，主要是可以比较明确的理解下主线程和子线程的关系，在上一篇线程的讲解中已经提到了线程是进程的执行单元。当进程被初始化后，主线程就被创建了。
对于绝大多数的应用程式来说，通常仅需要有一个主线程。尽管如此进程也能够创建额外的线程。

在学习Thread,下面是一个例子

t1 = Thread.new do
  i = 1
  while i <= 100000 do
    i += 1
  end
  puts 'ok, end!'
end

puts 'main thread start..'

#如果没有下面的操作，将不会看到上面的任何输出，所以可以这样理解
# 改脚本运行时相当于ruby创建了一个进程，然后又派发出一个主线程来运行该脚本，
# 线程是进程的执行单元。当进程被初始化后，主线程就被创建了。
# 对于绝大多数的应用程式来说，通常仅需要有一个主线程。尽管如此进程也能够创建额外的线程。
# t1又创建了一个子线程执行循环的操作，此时主线程比t1的子线程早结束，所以强制
# 结束了子线程，即不会看到任何输出，
# 当执行下面的t1.join时，主线程将会等待子线程的结束才退出
t1.join

最近在看ruby的线程这块的东西，就找了些资料关于linux进程和线程的，因为ruby的线程是基于linux和unix的，所以机制也和linux一样，

Introduction to threads and processes
进程和线程简介
Programs consist of a number of processes, each of which contains one or more conceptually concurrent threads of execution.
程式包含了若干进程，每一个进程包含了一个或多个概念上知执行的线程。
A thread is the unit of execution within a process. Every time a process is initialised, a primary thread is created. For many applications the primary thread is the only one that the application requires; however, processes can create additional threads.
线程是进程的执行单元。当进程被初始化后，主线程就被创建了。对于绝大多数的应用程式来说，通常仅需要有一个主线程。尽管如此进程也能够创建额外的线程。
Each user process has its own private address space, i.e. a collection of memory regions which that process can access. A user process cannot directly address memory areas in the address space of another process. There is also a special process, the Kernel process, whose threads run at supervisor privilege level. This process normally contains two threads:
每一个用户进程拥有自己私有的地址空间，也就是说，进程拥有一定的可被其访问的内存区域。一个用户进程不能够直接访问其他进程的地址空间。另外更有一个特别的进程,内核进程，他运行在终极用户权限模式。这个进程通常包括两个线程：
the Kernel server thread, which is the initial thread whose execution begins at the reset vector, and which is used to implement all Kernel functions requiring allocation or deallocation on the Kernel heap. This is the highest priority thread in the system.
Kernel server （内核服务器）线程：是个初始的进程，在系统启动时就已存在。他能够在heap执行由核心函数请求的内存分配或内存的重分配。这是系统中具备最高权限的线程。
the null thread, which runs only when no other threads are ready to run. The null thread places the processor into idle mode to save power.
null （空）线程：当系统中没有其他可运行的线程时这个线程就开始运行，null 线程使处理器处于空闲状态，减少耗电。
Threads execute individually and are unaware of other threads in a process. The scheduling of threads is pre-emptive, i.e. a currently executing thread may be suspended at any time to allow another thread to run.
线程是单独运行的，他且并不知道进程中更有其他线程存在。线程的执行是抢占式的，也就是说，当前运行的线程在任何时候都可能被挂起，以便另外一个线程能够运行。
Each thread is assigned a priority; at any time, the thread running is the highest priority thread which is ready to run. Threads with equal priority are time-sliced on a round-robin basis. Context switching between threads involves saving and restoring the state of threads. This state includes not only the processor registers (the thread context) but also the address space accessible to the thread (the process context). The process context only needs switching if a reschedule is between threads in different processes.
每一个线程都配置了优先限权；在 任何时候，只要线程已准备就绪，具备高优先权的线程总是首先运行。假如线程具备相同的悠闲权，则根据时间片进行轮转调度。上下文的转换包括了保存和恢复线 程状态。这个状态不但仅包含了处理器寄存器（进程上下文）而且还包含了线程可访问的地址空间（进程上下文）。只有在重新调度是在两个进程间进行的时候，进 程上下文才被转换。
Compare this with active objects which allow non pre-emptive multi-tasking within a single thread.
把这个和活动对象比较，活动对象允许在一个线程中实现非强占式的多任务调度。
A thread can suspend, resume, panic and kill another thread.
一个线程能够被挂起，唤醒、异常抛出和结束其他线程。
When a thread is created it is put into a suspended state, it does not begin to run until that thread’s Resume() member function is called.
线程被创建以后，他处于挂起状态。他没有马上进入运行状态，直到他的Resume()成员函数被调用。
When a thread is created, it is given the priority EPriorityNormal by default. The fact that a thread is initially put into a suspended state means that the thread priority can be changed (RThread::SetPriority()) before the thread is started (RThread::Resume()).
线程创建以后，他具备EPriorityNormal的默认优选级。线程被初始化并处于挂起状态，这意味着在线程开始运行前，线程的运行优先级能够被改变（通过调用RThread::SetPriority())

就是线程被创建的时候默认是没有运行的，即处于挂起（suspend）状态，所以要进行唤醒（wakeup，或者是join）才能运行，在唤醒前可以调整线程的优先级