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）才能运行，在唤醒前可以调整线程的优先级

昨天从无锡回来了，
工程的图搞的差不多了，从没接触过CAD，现在要用它做图，
现在没有时间让你去学了，要马上用，
而且还得做出图来，真是力不从心，感觉自己透不过气了，
觉得自己开始迷茫了，是接着干，还是去别的地方发展？迷茫，太迷茫了....

每天，每天都是累，
不过想想朋友，大家都是在奋斗，都有在努力，
所以不管怎样还是坚持着往下走，

***我不是一个人在奋斗***