快乐的天空

时间来得快,去得也快

 

2017年5月10日

境界的提升

工程师:
不断地思考与锤炼自身对最佳实践方式的理解感悟
设计过的系统架构图、功能结构图、数据库模型,并能基于系统实际使用情况进行基于架构的系统结构优化、性能优化等。

苦行僧:
 追求于设计之道与艺术之道的

布道师:
有着广阔的见识与丰富的实战经验, 经过短暂的观察即可指出对于当前架构的优化意见,可以用最简单的办法解决技术上的难题,可以通过跨领域知识启迪你解决问题.
科学家与哲学家
 paper & spirit

posted @ 2017-05-10 18:15 探路者 阅读(1) | 评论 (0)编辑 收藏

2017年3月23日

shell 脚本

#数字段形式
for i in {1..100}
do
   echo $i
done

#详细列出(字符且项数不多)
for File in 1 2 3 4 5 
do 
    echo $File 
done

#对存在的文件进行循环

for name in 'ls *.log'
do 
          name=`echo "$name" | awk -F. '{print $1}'`           
          echo $name
done

#查找循环(ls数据量太大的时候也可以用这种方法)
for shname in `find . -type f -name "*.sh"`
do 
          name=`echo "$shname" | awk -F/ '{print $2}'`          
          echo $name
done

#((语法循环--有点像C语法,但记得双括号
for((i=1;i<100;i++))
do
    if((i%3==0))
    then
        echo $i
        continue
    fi
done

#seq形式 起始从1开始
for i in `seq 100`
do
    if((i%3==0))
    then
        echo $i
        continue
    fi
done

#while循环注意为方括号[],且注意空格
min=1
max=100
while [ $min -le $max ]
do
    echo $min
    min=`expr $min + 1`
done  

#双括号形式,内部结构有点像C的语法,注意赋值:i=$(($i+1))
i=1
while(($i<100))
do
    if(($i%4==0))
    then
        echo $i
    fi
    i=$(($i+1))
done

#从配置文件读取,并可以控制进程数量
MAX_RUN_NUM=8
cat cfg/res_card_partition.cfg |grep -v '^$'|grep -v "#" | grep -v grep |while read partition 
do        
                nohup sh inv_res_card_process.sh $partition >log/resCard$partition.log 2>&1 &               
                while [ 1 -eq 1 ]
                do
                                psNum=`ps -ef | grep "inv_res_card_process" | grep -v "grep" | wc -l`
                                if [ $psNum -ge $MAX_RUN_NUM ]
                                then
                                              sleep 5
                                else
                                              break
                                 fi                                        
                done                
done


 三.循环控制语句 
    break 命令不执行当前循环体内break下面的语句从当前循环退出. 
    continue 命令是程序在本循体内忽略下面的语句,从循环头开始执行

posted @ 2017-03-23 17:15 探路者 阅读(3) | 评论 (0)编辑 收藏

2017年1月11日

Oracle 学习进阶

学习盖总的文章总结如下

一、oracle 基础知识
1.Oracle Concept
2.Administrator's Guid
3.Reference 手册
4.Backup and Recovery User's Guid 
5.Data Guard Concepts and Administrator
6.Oracle Clusterware and RAC Administrator 手册
二、百科全书/手册
找 杨长老学习文档。
三、有点及面,深入思考的学习方案
《深入解析Oracle》由点到线再及面的学习, 需要专门的培训和系统的学习。 通过实践的学习和深入的思考 "不患寡,而患不深", 
遇到问题时,不断深入研究,直到问题的核心本质,这样通过一个案例或实际问题的诊断学习和研究,我们可以带动很多连带知识的学习,
这样从一个点深入下去就形成一条线,再横向扩展就可以形成知识网。
四、严谨与独立思考的素质
勤奋、严谨、具有钻研精神及独立思考能力。 
《Oracle 数据库性能优化》  兴趣 + 勤奋 + 坚持 + 方法 -> 成功
五、DBA生存四大守则
《深入浅出Oracle》
1.备份重于一切
2.三思而后行 think thrice before you act 
3.rm 是恶魔
4.制定规范(规范开发和系统人员),不规矩不成方圆。
可以规避有意和无意的错误操作,建设数据库的风险。

posted @ 2017-01-11 09:04 探路者 阅读(4) | 评论 (0)编辑 收藏

2015年8月16日

bjam 编译boost

 

link=static variant=debug,release threading=multi runtime-link=static --layout=versioned --toolset=msvc-9.0  --build-type=complete  stage
--build-dir=<builddir>  编译的临时文件会放在builddir里(这样比较好管理,编译完就可以把它删除了)
--stagedir=<stagedir>  存放编译后库文件的路径,默认是stage
--build-type=complete  编译所有版本,不然只会编译一小部分版本(确切地说是相当于:variant=release, threading=multi;link=shared|static;runtime-link=shared)
variant=debug|release  决定编译什么版本(Debug or Release?)
link=static|shared  决定使用静态库还是动态库。
threading=single|multi  决定使用单线程还是多线程库。
runtime-link=static|shared  决定是静态还是动态链接C/C++标准库。
--with-<library>  只编译指定的库,如输入--with-regex就只编译regex库了。
--show-libraries  显示需要编译的库名称

boost库的命名约定:
[lib]<boost模块名>-<toolset编译器>[-mt][-sgdyp]<-boost版本>.<扩展名>
    [lib]:所有模块均采用lib为前缀,除了windows+msvc环境。在windows+msvc环境下,只有静态库(.lib)才有lib前缀,动态库(.dll)没有lib前缀。windows+mingw环境也使用lib前缀。
    <boost模块名>:所有模块均以boost_开头,比如boost_date_time, boost_python等等
    <toolset编译器>:比如mgw45, vc90
    [-mt]:多线程支持,不指定则默认为仅支持单线程
    [-sgdyp]:ABI的详细情况
        s 静态链接到C++标准库和运行库
        g 使用debug版的标准库和运行库
        d 编译debug版
        y python相关的debug
        p 使用STLPort作为C++标准库而不是编译器默认提供的
    <-boost版本>:比如-1_45
    <扩展名>:
        windows+mingw:dll(动态库),dll.a(动态库的导入库)
        windows+msvc:dll(动态库),lib(无lib前缀的是动态库的导入库),lib(有lib前缀的是静态库)
        unix/linux:a(静态库),so(动态库)
        使用boost
    windows+msvc编译出来的boost库默认会打开auto-link功能,即在包含boost头文件的时候自动寻找并链接依赖库。这实际上是通过msvc特有的预处理指令#pragma comment(lib, "xxx.lib")来实现的,默认的实现为链接静态库。
        如果想要链接动态库,则需要使用预定义宏 -DBOOST_ALL_DYN_LINK
        如果想要完全手动控制链接方式,则需要使用预定义宏 -DBOOST_ALL_NO_LIB。
    windows+mingw编译出来的boost库不支持auto-link,因为gcc没有类似msvc的#pragma comment预处理指令,所以必须手动控制链接方式。
    asio:依赖Boost.system模块,并且如果用到特定功能还可能依赖Boost.regex, Boost.openssl, Boost.thread, Boost.date_time, Boost.serialization等等,可以使用预定义宏 -DBOOST_DATE_TIME_NO_LIB 以及 -DBOOST_REGEX_NO_LIB 关闭相应模块的自动链接。windows下asio最终使用的是windows系统的socket库:ws2_32.lib,Mswsock.lib.同理,msvc可以通过auto-link自动完成链接,mingw需要手动设置。
    使用msvc编译真是有些玄妙:
使用预定义宏BOOST_ALL_DYN_LINK,动态链接:则编译时需要动态链接库导入库system,date_time,regex,执行时需要system,date_time。
使用预定义宏BOOST_ALL_NO_LIB,动态链接:则编译时需要动态链接库导入库system,执行时也只需要system。
使用预定义宏BOOST_ALL_NO_LIB,静态链接:则编译时需要静态库system,执行时不需要system。
 
使用mingw编译,一切正常:
注意上述几个预定义宏只对msvc有用而对mingw是不起作用的
动态链接:则编译时需要动态链接库导入库system,执行时也只需要system
静态链接:则编译时需要静态库system,执行时不需要system
当然ws2_32, Mswsock总是要指定链接的。
Usage:
Bjam  [options]  [properties]  [install|stage]
 
 
install                 Install  headers and compiled library files to the
=======               configured locations (below).
                      在“--prefix=”指定的目录下生成所有头文件
           (boost源代码下boost文件夹下所有文件)和指定库文件
 
--prefix=<PREFIX>       Install architecture independent files here.
                     Default; C:\Boost on Win32
                     Default; /usr/local on Unix. Linux, etc.
 
--exec-prefix=<EPREFIX>  Install architecture dependent files here.
                     Default; <PREFIX>
 
--libdir=<DIR>          Install library files here.
                     Default; <EPREFIX>/lib
 
--includedir=<HDRDIR>   Install header files here.
                      Default; <PREFIX>/include
 
stage                 Build and install only compiled library files
======               to the stage directory.
                          在“--stagedir=”指定的目录下生成指定库文件
 
 
--stagedir=<STAGEDIR>   Install library files here
                      Default; ./stage
 
 
【Other Options】:
--build-type=<type>     Build the specified pre-defined set of variations
                     of the libraries. Note, that which variants get
                     built depends on what each library supports.
 
                     minimal (default) - Builds the single
                     "release" version of the libraries. This
                     release corresponds to specifying:
                     "release  <threading>multi  <link>shared
                     <link>static  <runtime-link>shared" as the
                     Build variant to build.
                     complete - Attempts to build all possible
                     variations.
 
--build-dir=DIR         Build in this location instead of building
                     within the distribution tree. Recommended!
 
--show-libraries        Displays the list of Boost libraries that require
                     build and installation steps, then exit.
 
--layout=<layout>       Determines whether to choose library names
                     and header locations such that multiple
                     versions of Boost or multiple compilers can
                     be used on the same system.
 
                     versioned (default) - Names of boost
                     binaries include the Boost version
                     number and the name and version of the
                     compiler. Boost headers are installed
                     in a subdirectory of <HDRDIR> whose
                     name contains the Boost version number.
 
                     system - Binaries names do not include
                     the Boost version number or the name
                     and version number of the compiler.
                     Boost headers are installed directly
                     into <HDRDIR>. This option is
                     intended for system integrators who
                     are building distribution packages.
 
--buildid=ID                    Adds the specified ID to the name of built
                        libraries. The default is to not add anything.
 
--help                     This message.
 
--with-<library>                Build and install the specified <library>
                            If this option is used, only libraries
                            specified using this option will be built.
 
--without-<library>              Do not build, stage, or install the specified
                             <library>. By default, all libraries are built.
 
 
【Properties】:
toolset=toolset            Indicates the toolset to build with.
                                                        msvc-6.0 :  VC6.0
msvc-7.0:  VS2003
                                                        msvc-8.0:  VS2005
                                                        msvc-9.0:  VS2008
                                                        msvc-10.0:  VS2010
 
variant=debug|release      Select the build variant
 
link=static|shared          Whether to build static or shared libraries
 
threading=single|multi      Whether to build single or multithreaded binaries
 
runtime-link=static|shared   Whether to link to static or shared C and C++ runtime.
                         决定是静态还是动态链接C/C++标准库


compile gce dependence lib

b2 --toolset=msvc-14.0  link=static variant=debug,release threading=multi runtime-link=static  asmflags=\safeseh --stagedir=../.. --with-thread --with-atomic  --with-coroutine --with-context --with-system --with-regex --with-date_time --with-chrono
[context] msvc /SAFESEH

http://comments.gmane.org/gmane.comp.lib.boost.devel/244402

posted @ 2015-08-16 23:26 探路者 阅读(201) | 评论 (2)编辑 收藏

github clone boost 库

 
1.工具gitsys for windows
2.git colne 参考
https://svn.boost.org/trac/boost/wiki/TryModBoost#InstallingModularBoost
http://dev.activebasic.com/egtra/2013/12/03/620/
>git clone https://github.com/boostorg/boost.git 
Cloning into 'modular-boost'...
Receiving objects:   0% (124/197355), 23
remote: Compressing objects: 100% (30/30), done.
error: RPC failed; result=56, HTTP code = 200
fatal: early EOF
fatal: The remote end hung up unexpectedly
fatal: index-pack failed
Git 遇到了 early EOF index-pack failed 问题
# 为 git 添加配置项,通过下面的命令可以简单完成
# 在这之前可以执行 git config -l 命令看看已有配置项有哪些
git config --add core.compression -1
上面是通过命令来完成的,很方便,当然可以直接修改 .gitconfig 文件(在用户目录下),如果你愿意的话。部分内容如下:
[user]
    name = Ggicci
    email = ...
[core]
    compression = -112345
在 [core] 这个 section 里面添加 compression 属性即可。至于它的取值可以参考 Git Config Manpage,
这个页面你可以通过 man git config(linux) 或者 git config --help(windows)来查看本地版本。
compression 是压缩的意思,从 clone 的终端输出就知道,服务器会压缩目标文件,然后传输到客户端,客户端再解压。取值为 [-1, 9],-1 以 zlib 为默认压缩库,0 表示不进行压缩,1..9 是压缩速度与最终获得文件大小的不同程度的权衡,数字越大,压缩越慢,当然得到的文件会越小。
$ cd boost
$ git submodule init
$ git submodule update
> bootstrap.bat
> b2 headers
或者
$ git clone --recursive https://github.com/boostorg/boost.git boost
> cd boost
> bootstrap.bat
> b2 headers
更换发行版本
$ cd boost
$ git checkout release-1.55.0
$ git submodule update

posted @ 2015-08-16 23:23 探路者 阅读(108) | 评论 (0)编辑 收藏

2014年8月27日

自动更新

auto update 
technology document list 
1. http://www.cnblogs.com/KnightsWarrior/archive/2010/10/20/1856255.html
2.https://ladyuki.wordpress.com/2011/04/04/%E5%AE%A2%E6%88%B7%E7%AB%AF%E8%87%AA%E5%8A%A8%E5%8D%87%E7%BA%A7/
http://pcajax.iteye.com/blog/1069476
issue 
1.http://qt-project.org/forums/viewthread/28600
software & solution 
 ms clickonce     http://msdn.microsoft.com/zh-cn/library/142dbbz4(v=vs.90).aspx
 winsparkle         https://github.com/vslavik/winsparkle 
                                http://winsparkle.org/
                                http://sparkle-project.org/
                                http://netsparkle.codeplex.com/documentation
google  omaha  http://code.google.com/p/omaha/
wyupdate            http://code.google.com/p/wyupdate/
autoupdate c#  https://autoupdater.codeplex.com/
others 
http://wpkg.org/Automatic_Updates
http://www.codeproject.com/Articles/19623/Adding-automatic-updates-to-your-program-Part
http://www.cnblogs.com/wangiqngpei557/archive/2011/05/13/2045434.html#2096102
Introduction
If you decide to build your enterprise applications through .NET, may be the deployment strategy is one of the most important jobs in your whole project. Failure of the deployment strategy may result in lower customer satisfaction and also increase maintenance costs. Through my experience of building enterprise applications for banks and securities companies, I'll suggest four very clear reasons why you should not use Clickonce as your deployment strategy for your enterprise applications.
Three reasons why you should not choose Clickonce
Reason 1. Clickonce does not support proxy networks
If your customer company uses proxy servers for their network security and if your application is deployed under Clickonce technology, simply, your application doesn't get deployed under the proxy network.
And also I found that almost every bank and securities company uses a proxy network (HSBC, City Bank, Goldman Sachs.. and so on..). So if your clients are companies like that, just don't try to use Clickonce deployment because it does not work at all (there is a way to run Clickonce under a proxy network, if you have the power to order every customer to fix the settings of the machine.config file which is located very deep inside the Windows folder).
Reason 2. Assembly verification time is too long
Even though your application has a moderate number of assemblies, your clients should wait more than minutes to be deployed.
Reason 3. Customization is not allowed.
If you have more than 50 assemblies to be deployed, a financial company's network security device may disconnect your deployment process forcibly with sync flooding failure. Even though you know the cause of that failure, you can not GZip your assemblies into lesser than five physical files because Clickonce does not support doing that.

posted @ 2014-08-27 10:38 探路者| 编辑 收藏

2014年7月12日

Ubuntu安装SublimeText2

一、环境

操作系统:ubuntu 14.04 x64
编辑器:Sublime Text v2.0.1 x64

二、下载并解压

下载SublimeText的地址:http://c758482.r82.cf2.rackcdn.com/Sublime%20Text%202.0.1%20x64.tar.bz2

$ sudo mv Sublime\ Text\ 2.0.1\ x64.tar.bz2 sublime.tar.bz2
$ sudo tar vxjf sublime.tar.bz2
$ sudo mv Sublime\ Text\ 2/ sublime

三、创建快捷方式

我们希望在终端下仅仅只需输入sublime就能打开SublimeText编辑器。那么,可以创建一个符号链接,它相当于Windows的快捷方式。

$ sudo ln -s /tool/sublime/sublime_text /usr/bin/sublime

四、进行统一配置

要让SublimeText每次运行都保持一致,需要为它创建配置文件,位置为"/usr/share/applications"

$ sudo sublime /usr/share/applications/sublime.desktop

并粘贴以下的内容:

  1. [Desktop Entry]  
  2. Version=1.0  
  3. Name=Sublime Text 2  
  4. # Only KDE 4 seems to use GenericName, so we reuse the KDE strings.  
  5. # From Ubuntu's language-pack-kde-XX-base packages, version 13.04-20130413.  
  6. GenericName=Text Editor  
  7.   
  8. Exec=sublime  
  9. Terminal=false  
  10. Icon=/tool/sublime/Icon/48x48/sublime_text.png  
  11. Type=Application  
  12. Categories=TextEditor;IDE;Development  
  13. X-Ayatana-Desktop-Shortcuts=NewWindow  
  14.   
  15. [NewWindow Shortcut Group]  
  16. Name=New Window  
  17. Exec=sublime -n  
  18. TargetEnvironment=Unity  
保存并退出。


五、配置所有的文本文件指定用SublimeText打开


$ sudo sublime /usr/share/applications/defaults.list
把所有的gedit.desktop用sublime.desktop代替。

最后记得把SublimeText锁定到启动器,这样就很完美了。

posted @ 2014-07-12 22:52 探路者 阅读(831) | 评论 (0)编辑 收藏

2014年7月8日

程序员的七个建议

如果你喜欢编程,那么你真是受到了上天的眷顾。你是非常幸运的少数人之一,能够以自己喜欢的事谋生。大多数人没有这么幸运。你认为理所当然的观念 “热爱你的工作”,其实是一个很现代的概念。通常的看法是,工作是一种让人很不开心的事,你为了拿工资才不得不去上班。你工作的目的是为了攒下钱去干那些 自己真正喜欢干的事,但是前提是你得等到65岁退休之后才行,而且还有不少条件。条件一,你的积蓄必须足够多;条件二,你没有老到走不动,你还有体力去干 那些事情;条件三,你喜欢的事情不需要用到脆弱的膝盖、昏花的视力,也不要求你走上一里地不喘气,等等。

  我刚才说到哪里了?对了,我要提建议。

  毕业前练好写作

   如果不是Linus Torvalds不断地散布福音,请问Linux操作系统会成功吗?虽然他是一个非常聪明的计算机天才,但是Linux吸引来全世界一大批志愿者的真正原 因却是Linus Torvalds的表达能力。他通过电子邮件和邮件列表用书面形式传播自己的想法,最终引起了所有人的注意。

  你听说过现在风靡一时的“极限编程[ ] ”(Extreme Programming)吗?我在这个地方不谈我对极限编程的看法,我只说如果你听过这个词,那么原因就是它的倡导者都是一些非常有才华的作家和演说家。

  即使我们缩小范围,将目光局限在任何一个软件开发团体中,你也会发现该团体中最有权势和影响力的程序员正是那些表达能力强的程序员,他们无论是做书面表达还是做口头表达,都能够清晰、自如、具有说服力地传达观点。此外,长得高也有助于提升影响力,不过这个不取决于你。

   一个普通程序员与一个优秀程序员的区别,不在于他们懂得的编程语言谁多谁少,也不在于他们喜欢用Python语言还是喜欢用Java语言,而在于他们能 否与他人交流思想。如果你能说服其他人,你的力量就可以得到放大。如果你能写出清晰的注释和技术规格说明书,其他程序员就能够理解你的代码,因此他们就能 在自己的代码中使用,而不必重写。如果你做不到这一点,你的代码对其他人就没有价值。如果你能为最终用户写出清晰的使用手册,其他人就能明白你的代码是用 来干什么的,这是唯一让别人明白你的代码有何价值的方法。SourceForge[ ]上有许多优美的、有用的代码,但是它们都像被埋葬了一样,根本没人来用,原因就是它们的作者没有写好使用说明(或者压根就没写)。这样一来就没有人知道 他们的成果,他们杰出的代码就衰亡了。

  如果一个程序员不会用英语写作、没有良好的写作能力,我就不会雇他。如果你能写,不管你去哪家公司工作,你很快就会发现写作技术文档的任务会落到你头上,这意味着你已经开始在放大自己的影响力了,管理层正在注意到你。

  大学里有些课程被公认为“写作密集型”(writing intensive)课程,这就是说为了拿到学分,你必须写作多得可怕的文字。一定要去上这样的课程!不要管学科,只要这门课每周甚至每天都要你写东西,你就去上。

  你还可以动手写日记或者网志。你写得越多,写作就会变得越容易。写起来越容易,你就会写得越多。这是一个良性循环。

  毕业前学好C语言

   第二点我要讲的是C语言。请注意,我说的是C语言,而不是C++。虽然在实际使用中C语言已经越来越罕见,但是它仍然是当前程序员的共同语言。C语言让 程序员互相沟通,更重要的是,它比你在大学中学到的“现代语言”(比如ML语言、Java语言、Python语言或者其它正在教授的流行垃圾语言)都更接 近机器。你至少需要花一个学期来了解机器原理,否则你永远不可能在高级语言的层次写出高效的代码。你也永远无法开发编译器和操作系统,而它们恰恰属于目前 程序员能够得到的最佳工作之列。别人也永远不会放心将大型项目的架构设计交给你。我不管你懂多少延续(continuation)、闭包 (closure)、异常处理(exception handling),只要你不能解释为什么while (*s++ = *t++);这句代码的作用是复制字符串,或者不觉得这是世界上对你来说再自然不过的事情,那么你就是在盲目无知的情况下编程。在我看来,这就好像一个医 生不懂得最基本的解剖学就在开处方,他看病的根据完全是因为那些娃娃脸的医药厂商销售代表说这种药有用。

  毕业前学好微观经济学

   如果你没有上过任何经济学课程,那么我首先来做一个超短的评论:经济学是这样的学科之一,刚开始学的时候轰轰烈烈,有许多有用的、言之有理的理论和可以 在真实世界中得到证明的事实,等等;但是,再学下去就每况愈下,有用的东西就不多了。经济学一开始那个有用的部分正是微观经济学,它是商业领域所有重要理 论的基础。跟在微观经济学后面的东西就不行了。你接下来学的是宏观经济学,如果你愿意,尽管跳过去,也不会有什么损失。宏观经济学开头的部分是利息理论, 内容比方说是利率与失业之间的关系,但是怎么说呢,看上去这部分里面还没有被证实的东西多于已经被证实的东西。学完这部分,后面的内容越来越糟糕,许多经 济学专业的学生实际上都变成在搞物理学,因为这样才能在华尔街上找到更好的工作。但是不管怎样,你一定要去学微观经济学,因为你必须搞懂供给和需求,你必 须明白竞争优势,你必须理解什么是净现值(NPV),什么是贴现,什么是边际效用。只有这样,你才会懂得为什么生意是现在这种做法。

  为 什么计算机系的学生也应该学经济学?因为,从经营一家公司的角度来看,比起那些不懂的程序员,一个理解基本商业规则的程序员将会更有价值。就是这么简单。 我无法告诉你有多少次我是那样地充满挫折感,因为我看到了太多的提出一些疯狂的想法的程序员,这些想法在代码上也许可行,但在资本主义世界中毫无意义。如 果你懂得商业规则,你就是一个更有价值的程序员,你会因此得到回报的,但是前提是你要去学习微观经济学。

  不要因为枯燥就不选修非计算机专业的课程。

   想提高GPA绩点的一个好方法就是多选修非计算机系的课程。请千万不要低估你的GPA的重大意义。千千万万的人事经理和招聘人员在拿到一份简历的时候, 第一眼就会去看GPA,包括我也是这样。我们不会为这种做法道歉。为什么?因为GPA不反映单个的成绩,而是代表了许多个教授在一段很长的时间中,在不同 的情况下,对你的表现的一个总的评估。SAT成绩难道不够吗?哈,那只不过是一场几个小时的测试罢了。GPA中包括了四年大学期间你的小论文、期中考试和 课堂表现,总数有几百次之多。当然,GPA也有自己的问题,不是百分之百准确。比如,这些年来,老师对学生的打分越来越宽松,学习成绩有通货膨胀的趋势。 再比如,GPA无法反映课程的难度,没人能够看出你的GPA是来自无名社区大学家政系的轻松课程还是来自加州理工学院针对研究生的量子力学课程。渐渐地, 我形成了一套自己的做法,首先我会过滤掉所有来自社区大学、GPA低于2.5的简历,然后我会要求剩下的人给我寄成绩单和推荐信。我再从中发现那些成绩一 贯优秀的人,而不是那些仅仅在计算机系课程中得到高分的人。

  为什么我要关心某人的“欧洲历史”课程成绩呢,毕竟作为雇主我要找的应该是 程序员啊?何况,历史是那么枯燥,不得高分很正常。哦,这么说来,你的意思是我应该雇用你,而不用考虑一旦工作变得枯燥你会不会努力工作?别忘了,在编程 工作中也有很枯燥的东西。每一项工作都有枯燥难耐的时刻。我不想雇用那些只想干有趣事情的人。

  选修有大量编程实践的课程

  我依然清楚记得我发誓绝不读研究生的那一刻。那是在一门叫做“动态逻辑”的课程上,教师是活力十足的耶鲁大学教授Lenore Zuck,她是计算机系那些聪明的老师中最聪明的人之一。

   如今, 由于记忆力糟糕, 我已经差不多把这门课的内容忘光了,但是不管怎么说,在这里我还是想要对付着说一下。大致上,形式逻辑的意思是说,如果条件成立,你就能证明结论也成立。 比如,根据形式逻辑,已知“只要成绩好,就能被雇用”,然后假定“Johnny的成绩好”,你就可以得到一个崭新的结论“Johnny会被雇用”。这完全 是经典方法。但是,一个解构主义者(deconstructionist)只需要10秒钟就能破坏形式逻辑中所有有用的东西。这样一来,留给你的只是一些 趣味性,而不是实用性。

  现在再来说动态逻辑。它与形式逻辑其实是一回事,但是必须再多考虑时间因素。比如,“你打开灯之后,就能看见自己的鞋子”,已知“灯以前是亮的”,那么这就意味着“你看见了自己的鞋子”。

   对于像Zuck教授那样聪明的理论家,动态逻辑充满了吸引力,因为它看上去很有希望让你在形式上证明一些计算机程序的相关理论问题。这样做说不定很有 用。比如,你可以用它在形式上证明,火星漫游车的闪存卡不会发生溢出(overflow)问题,不会因而整天一遍又一遍地重启,耽误了它在那颗赤红色的星 球上漫游寻找火星人马文(Marvin the Martian)。

  在第一堂课上,Zuck博士写满了整整两面黑板,甚至黑板旁边的墙上都写上了很多证明步骤。需要证明的问题是,有一个控制灯泡的开关,现在灯泡没有亮,这时你打开了开关,请证明灯泡将会点亮。

   整个证明过程复杂得不可思议,处处都是陷阱,必须十分小心。保证这个证明不出错太困难了,还不如直接相信打开开关灯就会亮。真的,虽然证明过程写满了许 多块黑板,但是还是有许多中间步骤被省略了,因为如果要从形式逻辑上完整证明所有步骤,那就琐碎得无法形容了。许多步骤是用各种经典的逻辑证明方法推导得 到的,包括归纳法、反证法等,甚至有些部分还是由旁听的研究生证明的。

  留给我们的课后作业是证明逆命题:如果灯原来是关着的,现在却亮了,那么请证明开关的状态一定同原来相反。

  我动手开始证明,我真的去证明了。

  我在图书馆里待了很长时间。

   我对照着Zuck博士的原始证明想依样画葫芦。研究了几个小时之后,我在其中发现了一个错误。可能我抄写的时候抄错了,但是这使得我想通了一件事。如果 花费3个小时,写满了一块又一块的黑板,每一秒钟都可能出错,最后能够证明的却只是一个很琐碎的结论,那么这种方式有多大的实用性呢?在活生生、充满趣味 的现实世界中,你永远都不会有机会使用它。

  但是,动态逻辑的理论家们对这一点不感兴趣。他们看上它不是因为它有用,而是因为它可以为他们带来终身教职。

  我放弃了这门课,并且发誓绝不会去读计算机科学的研究生。

   这个故事告诉我们,计算机科学与软件开发不是一回事。如果你真的非常幸运,你的学校可能会开设很像样的软件开发课程。但是另一种可能是,你的学校根本不 教你在现实中如何编程,因为精英学校都觉得,教授工作技能最好留给职业技术学校、犯人重返社会的培训项目去做。你到处都能学怎么写代码。别忘了,我们是耶 鲁大学,我们的使命是培养未来的世界领袖。你交了16万美元的学费,却在学循环语句的写法,这怎么可以?你以为这是什么地方,难道是机场沿途的酒店里临时 拼凑起来不靠谱的Java语言培训班?哼哼。

  麻烦在于我们没有一种真正教授软件开发的专门学校。你如果想成为一个程序员,你可能只能选 择计算机科学专业。这是一个不错的专业,但是它同软件开发不是一回事。在那些400等级的课程代号中,去寻找名称中带有“Practicum”这个词的课 程吧(编者注:指供人实习的课程)。不要被这个拉丁语单词吓倒,这些都是有用的课程,之所以起这种名字,只是为了让那些文绉绉、装腔作势、满嘴胡说八道的 公司经理们觉得高深莫测。

  别担心所有工作都被印度人抢走

  我首先要说的是,如果你本身就已经在印度了,或者你就是印度人,那么你真的毫无必要去想这件事,根本不用琢磨所有的工作机会是不是都跑到了印度。那些都是非常好的工作,好好地享受吧,祝你身体健康。

   但是,我不断听说计算机系的入学人数下降得很厉害,已经到了危险的程度。根据我听到的说法,其中的一个原因是“学生们不愿去学一个工作机会都流向印度的 专业”。这种担心大错特错,有很多理由可以反驳。首先,根据一时性的商业潮流决定个人的职业选择,这是愚蠢的。其次,即使编程工作无一幸存

posted @ 2014-07-08 21:38 探路者 阅读(194) | 评论 (0)编辑 收藏

2014年7月1日

lua的require机制

 为了方便代码管理,通常会把lua代码分成不同的模块,然后在通过require函数把它们加载进来。
现在看看lua的require的处理流程。

1、require机制相关的数据和函数
    package.path:保存加载外部模块(lua中"模块"和"文件"这两个概念的分界比较含糊,因为这个值在不同的时刻会扮演不同的角色)的搜索 路径,这种路径是"模板式的路径",它里面会包含可替代符号"?",这个符号会被替换,然后lua查找这个文件是否存在,如果存在就会调用其中特定的接 口。典型的值为:
    "./?.lua;./?.lc;/usr/local/?/init.lua"
    如果lua代码中调用:require("hello.world")
    那么lua会依次查找:
    ./hello/world.lua ==>这里"hello.world"变成了"hello/world",并替换了模型"./?.lua"
    ./hello/world.lc
    .....
    (这种处理方式和python类似,只不过不需要__init__.py,也有调用python中的__init__.py)
    package.path在虚拟机启动的时候设置,如果存在环境变量LUA_PATH,那么就用该环境变量作为
    它的值,并把这个环境变量中的";;"替换为luaconf.h中定义的默认值,如果不存在该变量就直接使用
    luaconf.h定义的默认值
    
    package.cpath:作用和packag.path一样,但它是用于加载第三方c库的。它的初始值可以通过环境变量
    LUA_CPATH来设置
    
    package.loadlib(libname, func):相当与手工打开c库libname, 并导出函数func返回,loadlib其实是ll_loadlib
    

2.require的处理流程:
   require(modelname)
   require(在lua中它是ll_require函数)的查找顺序如下:
       a.首先在package.loaded查找modelname,如果该模块已经存在,就直接返回它的值
       b.在package.preload查找modelname, 如果preload存在,那么就把它作为loader,调用loader(L)
       c.根据package.path的模式查找lua库modelname,这个库是通过module函数定义的,对于顶层的lua库,文件名和库名是一 样的而且不需要调用显式地在lua文件中调用module函数(在ll_require函数中可以看到处理方式),也就是说lua会根据lua文件直接完 成一个loader的初始化过程。
       d.根据package.cpath查找c库,这个库是符合lua的一些规范的(export具有一定特征的函数接口),lua先已动态的方式加载该c库,然后在库中查找并调用相应名字的接口,例如:luaopen_hello_world
       e.已第一个"."为分割,将模块名划分为:(main, sub)的形式,根据package.cpath查找main,如果存在,就加载该库并查询相应的接口:luaopen_main_sub,例如:先查找 hello库,并查询luaopen_hello_world接口
       f.得到loder后,用modname作为唯一的参数调用该loader函数。当然参数是通过lua的栈传递的,所以loader的原型必须符合lua的规范:int LUA_FUNC(lua_State *L)
         
       ll_require会将这个loader的返回值符给package.loaded[modelname],如果loader不返回值同时 package.loaded[modelname]不存在时, ll_require就会把package.loaded[modelname]设为true。最后ll_reuqire把package.loaded [modelname]返回给调用者。
    

3.module的处理流程
    module(name, cb1, cb2, ...)
    
    a.如果package.loaded[name]是一个table,那么就把这个table作为一个mod
    b.如果全局变量name是一个table,就把这个全局变量作为一个mod
    c.创建table:t = {[name]=package.loaded[name], ["_NAME"]=name, ["_M"]=t, ["_PACKAGE"]=*name*(删除了最后的".XXXX"部分)}. 如果name是一个以点分割的串,那么得到的mod类似这个样子:
      hello.world==> {["hello"]={["world"]={XXXXXXX}}}
    d.依次调用cbs:
      cb1(mod), cb2(mod),...
      
    e.将当前模块的环境设置为mod,同时把package.loaded[name] = mod 

posted @ 2014-07-01 08:49 探路者 阅读(203) | 评论 (0)编辑 收藏

2014年6月18日

redis 参数配置

1. Redis默认不是以守护进程的方式运行,可以通过该配置项修改,使用yes启用守护进程

    daemonize no

2. 当Redis以守护进程方式运行时,Redis默认会把pid写入/var/run/redis.pid文件,可以通过pidfile指定

    pidfile /var/run/redis.pid

3. 指定Redis监听端口,默认端口为6379,作者在自己的一篇博文中解释了为什么选用6379作为默认端口,因为6379在手机按键上MERZ对应的号码,而MERZ取自意大利歌女Alessia Merz的名字

    port 6379

4. 绑定的主机地址

    bind 127.0.0.1

5.当 客户端闲置多长时间后关闭连接,如果指定为0,表示关闭该功能

    timeout 300

6. 指定日志记录级别,Redis总共支持四个级别:debug、verbose、notice、warning,默认为verbose

    loglevel verbose

7. 日志记录方式,默认为标准输出,如果配置Redis为守护进程方式运行,而这里又配置为日志记录方式为标准输出,则日志将会发送给/dev/null

    logfile stdout

8. 设置数据库的数量,默认数据库为0,可以使用SELECT <dbid>命令在连接上指定数据库id

    databases 16

9. 指定在多长时间内,有多少次更新操作,就将数据同步到数据文件,可以多个条件配合

    save <seconds> <changes>

    Redis默认配置文件中提供了三个条件:

    save 900 1

    save 300 10

    save 60 10000

    分别表示900秒(15分钟)内有1个更改,300秒(5分钟)内有10个更改以及60秒内有10000个更改。

 

10. 指定存储至本地数据库时是否压缩数据,默认为yes,Redis采用LZF压缩,如果为了节省CPU时间,可以关闭该选项,但会导致数据库文件变的巨大

    rdbcompression yes

11. 指定本地数据库文件名,默认值为dump.rdb

    dbfilename dump.rdb

12. 指定本地数据库存放目录

    dir ./

13. 设置当本机为slav服务时,设置master服务的IP地址及端口,在Redis启动时,它会自动从master进行数据同步

    slaveof <masterip> <masterport>

14. 当master服务设置了密码保护时,slav服务连接master的密码

    masterauth <master-password>

15. 设置Redis连接密码,如果配置了连接密码,客户端在连接Redis时需要通过AUTH <password>命令提供密码,默认关闭

    requirepass foobared

16. 设置同一时间最大客户端连接数,默认无限制,Redis可以同时打开的客户端连接数为Redis进程可以打开的最大文件描述符数,如果设置 maxclients 0,表示不作限制。当客户端连接数到达限制时,Redis会关闭新的连接并向客户端返回max number of clients reached错误信息

    maxclients 128

17. 指定Redis最大内存限制,Redis在启动时会把数据加载到内存中,达到最大内存后,Redis会先尝试清除已到期或即将到期的Key,当此方法处理 后,仍然到达最大内存设置,将无法再进行写入操作,但仍然可以进行读取操作。Redis新的vm机制,会把Key存放内存,Value会存放在swap区

    maxmemory <bytes>

18. 指定是否在每次更新操作后进行日志记录,Redis在默认情况下是异步的把数据写入磁盘,如果不开启,可能会在断电时导致一段时间内的数据丢失。因为 redis本身同步数据文件是按上面save条件来同步的,所以有的数据会在一段时间内只存在于内存中。默认为no

    appendonly no

19. 指定更新日志文件名,默认为appendonly.aof

     appendfilename appendonly.aof

20. 指定更新日志条件,共有3个可选值:
    no:表示等操作系统进行数据缓存同步到磁盘(快)
    always:表示每次更新操作后手动调用fsync()将数据写到磁盘(慢,安全)
    everysec:表示每秒同步一次(折衷,默认值)

    appendfsync everysec

 

21. 指定是否启用虚拟内存机制,默认值为no,简单的介绍一下,VM机制将数据分页存放,由Redis将访问量较少的页即冷数据swap到磁盘上,访问多的页面由磁盘自动换出到内存中(在后面的文章我会仔细分析Redis的VM机制)

     vm-enabled no

22. 虚拟内存文件路径,默认值为/tmp/redis.swap,不可多个Redis实例共享

     vm-swap-file /tmp/redis.swap

23. 将所有大于vm-max-memory的数据存入虚拟内存,无论vm-max-memory设置多小,所有索引数据都是内存存储的(Redis的索引数据 就是keys),也就是说,当vm-max-memory设置为0的时候,其实是所有value都存在于磁盘。默认值为0

     vm-max-memory 0

24. Redis swap文件分成了很多的page,一个对象可以保存在多个page上面,但一个page上不能被多个对象共享,vm-page-size是要根据存储的 数据大小来设定的,作者建议如果存储很多小对象,page大小最好设置为32或者64bytes;如果存储很大大对象,则可以使用更大的page,如果不 确定,就使用默认值

     vm-page-size 32

25. 设置swap文件中的page数量,由于页表(一种表示页面空闲或使用的bitmap)是在放在内存中的,,在磁盘上每8个pages将消耗1byte的内存。

     vm-pages 134217728

26. 设置访问swap文件的线程数,最好不要超过机器的核数,如果设置为0,那么所有对swap文件的操作都是串行的,可能会造成比较长时间的延迟。默认值为4

     vm-max-threads 4

27. 设置在向客户端应答时,是否把较小的包合并为一个包发送,默认为开启

    glueoutputbuf yes

28. 指定在超过一定的数量或者最大的元素超过某一临界值时,采用一种特殊的哈希算法

    hash-max-zipmap-entries 64

    hash-max-zipmap-value 512

29. 指定是否激活重置哈希,默认为开启(后面在介绍Redis的哈希算法时具体介绍)

    activerehashing yes

30. 指定包含其它的配置文件,可以在同一主机上多个Redis实例之间使用同一份配置文件,而同时各个实例又拥有自己的特定配置文件

    include /path/to/local.conf



# By default Redis does not run as a daemon. Use 'yes' if you need it.
# Note that Redis will write a pid file in /var/run/redis.pid when daemonized.
#Redis默认不是以守护进程的方式运行,可以通过该配置项修改,使用yes启用守护进程
daemonize no
# When running daemonized, Redis writes a pid file in /var/run/redis.pid by
# default. You can specify a custom pid file location here.
#当 Redis 以守护进程的方式运行的时候,Redis 默认会把 pid 文件放在/var/run/redis.pid
#可配置到其他地址,当运行多个 redis 服务时,需要指定不同的 pid 文件和端口
pidfile /var/run/redis.pid
# Accept connections on the specified port, default is 6379.
# If port 0 is specified Redis will not listen on a TCP socket.
#端口
port 6379
# If you want you can bind a single interface, if the bind option is not
# specified all the interfaces will listen for incoming connections.
#指定Redis可接收请求的IP地址,不设置将处理所有请求,建议生产环境中设置
# bind 127.0.0.1
# Close the connection after a client is idle for N seconds (0 to disable)
#客户端连接的超时时间,单位为秒,超时后会关闭连接
timeout 0
# Set server verbosity to 'debug'
# it can be one of:
# debug (a lot of information, useful for development/testing)
# verbose (many rarely useful info, but not a mess like the debug level)
# notice (moderately verbose, what you want in production probably)
# warning (only very important / critical messages are logged)
#日志记录等级,4个可选值
loglevel notice
# Specify the log file name. Also 'stdout' can be used to force
# Redis to log on the standard output. Note that if you use standard
# output for logging but daemonize, logs will be sent to /dev/null
#配置 log 文件地址,默认打印在命令行终端的窗口上,也可设为/dev/null屏蔽日志、
logfile stdout
# Set the number of databases. The default database is DB 0, you can select
# a different one on a per-connection basis using SELECT where
# dbid is a number between 0 and 'databases'-1
#设置数据库的个数,可以使用 SELECT 命令来切换数据库。
databases 16
#
# Save the DB on disk:
#
#   save
#
#   Will save the DB if both the given number of seconds and the given
#   number of write operations against the DB occurred.
#
#   In the example below the behaviour will be to save:
#   after 900 sec (15 min) if at least 1 key changed
#   after 300 sec (5 min) if at least 10 keys changed
#   after 60 sec if at least 10000 keys changed
#
#   Note: you can disable saving at all commenting all the "save" lines.
#设置 Redis 进行数据库镜像的频率。保存数据到disk的策略
#900秒之内有1个keys发生变化时
#30秒之内有10个keys发生变化时
#60秒之内有10000个keys发生变化时
save 900 1
save 300 10
save 60 10000
# Compress string objects using LZF when dump .rdb databases?
# For default that's set to 'yes' as it's almost always a win.
# If you want to save some CPU in the saving child set it to 'no' but
# the dataset will likely be bigger if you have compressible values or keys.
#在进行镜像备份时,是否进行压缩
rdbcompression yes
# The filename where to dump the DB
#镜像备份文件的文件名
dbfilename dump.rdb
# The working directory.
#
# The DB will be written inside this directory, with the filename specified
# above using the 'dbfilename' configuration directive.
# Also the Append Only File will be created inside this directory.
# Note that you must specify a directory here, not a file name.
#数据库镜像备份的文件放置的路径
#路径跟文件名分开配置是因为 Redis 备份时,先会将当前数据库的状态写入到一个临时文件
#等备份完成时,再把该临时文件替换为上面所指定的文件
#而临时文件和上面所配置的备份文件都会放在这个指定的路径当中
#默认值为 ./
dir /var/lib/redis/
# Master-Slave replication. Use slaveof to make a Redis instance a copy of
# another Redis server. Note that the configuration is local to the slave
# so for example it is possible to configure the slave to save the DB with a
# different interval, or to listen to another port, and so on.
#设置该数据库为其他数据库的从数据库
#slaveof <masterip> <masterport> 当本机为从服务时,设置主服务的IP及端口
# slaveof
# If the master is password protected (using the "requirepass" configuration
# directive below) it is possible to tell the slave to authenticate before
# starting the replication synchronization process, otherwise the master will
# refuse the slave request.
#指定与主数据库连接时需要的密码验证
#masterauth <master-password> 当本机为从服务时,设置主服务的连接密码
# masterauth
# When a slave lost the connection with the master, or when the replication
# is still in progress, the slave can act in two different ways:
#
# 1) if slave-serve-stale-data is set to 'yes' (the default) the slave will
#    still reply to client requests, possibly with out of data data, or the
#    data set may just be empty if this is the first synchronization.
#
# 2) if slave-serve-stale data is set to 'no' the slave will reply with
#    an error "SYNC with master in progress" to all the kind of commands
#    but to INFO and SLAVEOF.
#当slave丢失与master的连接时,或slave仍然在于master进行数据同步时(未与master保持一致)
#slave可有两种方式来响应客户端请求:
#1)如果 slave-serve-stale-data 设置成 'yes'(默认),slave仍响应客户端请求,此时可能会有问题
#2)如果 slave-serve-stale-data 设置成 'no',slave会返回"SYNC with master in progress"错误信息,但 INFO 和SLAVEOF命令除外。
slave-serve-stale-data yes
# Require clients to issue AUTH before processing any other
# commands.  This might be useful in environments in which you do not trust
# others with access to the host running redis-server.
#
# This should stay commented out for backward compatibility and because most
# people do not need auth (e.g. they run their own servers).
# Warning: since Redis is pretty fast an outside user can try up to
# 150k passwords per second against a good box. This means that you should
# use a very strong password otherwise it will be very easy to break.
#设置客户端连接后进行任何其他指定前需要使用的密码
#redis速度相当快,一个外部用户在一秒钟进行150K次密码尝试,需指定强大的密码来防止暴力破解
# requirepass foobared
# Set the max number of connected clients at the same time. By default there
# is no limit, and it's up to the number of file descriptors the Redis process
# is able to open. The special value '0' means no limits.
# Once the limit is reached Redis will close all the new connections sending
# an error 'max number of clients reached'.
#限制同时连接的客户数量。
#当连接数超过这个值时,redis 将不再接收其他连接请求,客户端尝试连接时将收到 error 信息
# maxclients 128
# Don't use more memory than the specified amount of bytes.
# When the memory limit is reached Redis will try to remove keys
# accordingly to the eviction policy selected (see maxmemmory-policy).
#
# If Redis can't remove keys according to the policy, or if the policy is
# set to 'noeviction', Redis will start to reply with errors to commands
# that would use more memory, like SET, LPUSH, and so on, and will continue
# to reply to read-only commands like GET.
#
# This option is usually useful when using Redis as an LRU cache, or to set
# an hard memory limit for an instance (using the 'noeviction' policy).
#
# WARNING: If you have slaves attached to an instance with maxmemory on,
# the size of the output buffers needed to feed the slaves are subtracted
# from the used memory count, so that network problems / resyncs will
# not trigger a loop where keys are evicted, and in turn the output
# buffer of slaves is full with DELs of keys evicted triggering the deletion
# of more keys, and so forth until the database is completely emptied.
#
# In short... if you have slaves attached it is suggested that you set a lower
# limit for maxmemory so that there is some free RAM on the system for slave
# output buffers (but this is not needed if the policy is 'noeviction').
#设置redis能够使用的最大内存。
#达到最大内存设置后,Redis会先尝试清除已到期或即将到期的Key(设置过expire信息的key
#在删除时,按照过期时间进行删除,最早将要被过期的key将最先被删除
#如果已到期或即将到期的key删光,仍进行set操作,那么将返回错误
#此时redis将不再接收写请求,只接收get请求。
#maxmemory的设置比较适合于把redis当作于类似memcached 的缓存来使用
# maxmemory <bytes>
# By default Redis asynchronously dumps the dataset on disk. If you can live
# with the idea that the latest records will be lost if something like a crash
# happens this is the preferred way to run Redis. If instead you care a lot
# about your data and don't want to that a single record can get lost you should
# enable the append only mode: when this mode is enabled Redis will append
# every write operation received in the file appendonly.aof. This file will
# be read on startup in order to rebuild the full dataset in memory.
#
# Note that you can have both the async dumps and the append only file if you
# like (you have to comment the "save" statements above to disable the dumps).
# Still if append only mode is enabled Redis will load the data from the
# log file at startup ignoring the dump.rdb file.
#
# IMPORTANT: Check the BGREWRITEAOF to check how to rewrite the append
# log file in background when it gets too big.
#redis 默认每次更新操作后会在后台异步的把数据库镜像备份到磁盘,但该备份非常耗时,且备份不宜太频繁
#redis 同步数据文件是按上面save条件来同步的
#如果发生诸如拉闸限电、拔插头等状况,那么将造成比较大范围的数据丢失
#所以redis提供了另外一种更加高效的数据库备份及灾难恢复方式
#开启append only 模式后,redis 将每一次写操作请求都追加到appendonly.aof 文件中
#redis重新启动时,会从该文件恢复出之前的状态。
#但可能会造成 appendonly.aof 文件过大,所以redis支持BGREWRITEAOF 指令,对appendonly.aof重新整理
appendonly no
# The name of the append only file (default: "appendonly.aof")
##更新日志文件名,默认值为appendonly.aof
# appendfilename appendonly.aof
# The fsync() call tells the Operating System to actually write data on disk
# instead to wait for more data in the output buffer. Some OS will really flush 
# data on disk, some other OS will just try to do it ASAP.
#
# Redis supports three different modes:
#
# no: don't fsync, just let the OS flush the data when it wants. Faster.
# always: fsync after every write to the append only log . Slow, Safest.
# everysec: fsync only if one second passed since the last fsync. Compromise.
#
# The default is "everysec" that's usually the right compromise between
# speed and data safety. It's up to you to understand if you can relax this to
# "no" that will will let the operating system flush the output buffer when
# it wants, for better performances (but if you can live with the idea of
# some data loss consider the default persistence mode that's snapshotting),
# or on the contrary, use "always" that's very slow but a bit safer than
# everysec.
#
# If unsure, use "everysec".
#设置对 appendonly.aof 文件进行同步的频率
#always 表示每次有写操作都进行同步,everysec 表示对写操作进行累积,每秒同步一次。
#no表示等操作系统进行数据缓存同步到磁盘,都进行同步,everysec 表示对写操作进行累积,每秒同步一次
# appendfsync always
appendfsync everysec
# appendfsync no
# Virtual Memory allows Redis to work with datasets bigger than the actual
# amount of RAM needed to hold the whole dataset in memory.
# In order to do so very used keys are taken in memory while the other keys
# are swapped into a swap file, similarly to what operating systems do
# with memory pages.
#
# To enable VM just set 'vm-enabled' to yes, and set the following three
# VM parameters accordingly to your needs.
#是否开启虚拟内存支持。
#redis 是一个内存数据库,当内存满时,无法接收新的写请求,所以在redis2.0后,提供了虚拟内存的支持
#但需要注意的,redis 所有的key都会放在内存中,在内存不够时,只把value 值放入交换区
#虽使用虚拟内存,但性能基本不受影响,需要注意的是要把vm-max-memory设置到足够来放下所有的key
vm-enabled no
# vm-enabled yes
# This is the path of the Redis swap file. As you can guess, swap files
# can't be shared by different Redis instances, so make sure to use a swap
# file for every redis process you are running. Redis will complain if the
# swap file is already in use.
#
# The best kind of storage for the Redis swap file (that's accessed at random) 
# is a Solid State Disk (SSD).
#
# *** WARNING *** if you are using a shared hosting the default of putting
# the swap file under /tmp is not secure. Create a dir with access granted
# only to Redis user and configure Redis to create the swap file there.
#设置虚拟内存的交换文件路径,不可多个Redis实例共享
vm-swap-file /tmp/redis.swap
# vm-max-memory configures the VM to use at max the specified amount of
# RAM. Everything that deos not fit will be swapped on disk *if* possible, that
# is, if there is still enough contiguous space in the swap file.
#
# With vm-max-memory 0 the system will swap everything it can. Not a good
# default, just specify the max amount of RAM you can in bytes, but it's
# better to leave some margin. For instance specify an amount of RAM
# that's more or less between 60 and 80% of your free RAM.
#设置开启虚拟内存后,redis将使用的最大物理内存大小。
#默认为0,redis将把他所有能放到交换文件的都放到交换文件中,以尽量少的使用物理内存
#即当vm-max-memory设置为0的时候,其实是所有value都存在于磁盘
#在生产环境下,需要根据实际情况设置该值,最好不要使用默认的 0
vm-max-memory 0
# Redis swap files is split into pages. An object can be saved using multiple
# contiguous pages, but pages can't be shared between different objects.
# So if your page is too big, small objects swapped out on disk will waste
# a lot of space. If you page is too small, there is less space in the swap
# file (assuming you configured the same number of total swap file pages).
#
# If you use a lot of small objects, use a page size of 64 or 32 bytes.
# If you use a lot of big objects, use a bigger page size.
# If unsure, use the default :)
#设置虚拟内存的页大小
如果 value 值比较大,如要在 value 中放置博客、新闻之类的所有文章内容,就设大一点
vm-page-size 32
# Number of total memory pages in the swap file.
# Given that the page table (a bitmap of free/used pages) is taken in memory,
# every 8 pages on disk will consume 1 byte of RAM.
#
# The total swap size is vm-page-size * vm-pages
#
# With the default of 32-bytes memory pages and 134217728 pages Redis will
# use a 4 GB swap file, that will use 16 MB of RAM for the page table.
#
# It's better to use the smallest acceptable value for your application,
# but the default is large in order to work in most conditions.
#设置交换文件的总的 page 数量
#注意page table信息是放在物理内存中,每8个page 就会占据RAM中的 1 个 byte
#总的虚拟内存大小 = vm-page-size * vm-pages
vm-pages 134217728
# Max number of VM I/O threads running at the same time.
# This threads are used to read/write data from/to swap file, since they
# also encode and decode objects from disk to memory or the reverse, a bigger
# number of threads can help with big objects even if they can't help with
# I/O itself as the physical device may not be able to couple with many
# reads/writes operations at the same time.
#
# The special value of 0 turn off threaded I/O and enables the blocking
# Virtual Memory implementation.
#设置 VM IO 同时使用的线程数量。
vm-max-threads 4
# Hashes are encoded in a special way (much more memory efficient) when they
# have at max a given numer of elements, and the biggest element does not
# exceed a given threshold. You can configure this limits with the following
# configuration directives.
#redis 2.0后引入了 hash 数据结构。 
#hash 中包含超过指定元素个数并且最大的元素当没有超过临界时,hash 将以zipmap来存储
#zipmap又称为 small hash,可大大减少内存的使用
hash-max-zipmap-entries 512
hash-max-zipmap-value 64
# Active rehashing uses 1 millisecond every 100 milliseconds of CPU time in
# order to help rehashing the main Redis hash table (the one mapping top-level
# keys to values). The hash table implementation redis uses (see dict.c)
# performs a lazy rehashing: the more operation you run into an hash table
# that is rhashing, the more rehashing "steps" are performed, so if the
# server is idle the rehashing is never complete and some more memory is used
# by the hash table.
# The default is to use this millisecond 10 times every second in order to
# active rehashing the main dictionaries, freeing memory when possible.
#
# If unsure:
# use "activerehashing no" if you have hard latency requirements and it is
# not a good thing in your environment that Redis can reply form time to time
# to queries with 2 milliseconds delay.
#
# use "activerehashing yes" if you don't have such hard requirements but
# want to free memory asap when possible.
#是否重置Hash表
#设置成yes后redis将每100毫秒使用1毫秒CPU时间来对redis的hash表重新hash,可降低内存的使用
#当使用场景有较为严格的实时性需求,不能接受Redis时不时的对请求有2毫秒的延迟的话,把这项配置为no。
#如果没有这么严格的实时性要求,可以设置为 yes,以便能够尽可能快的释放内存
activerehashing yes

Redis官方文档对VM的使用提出了一些建议:
  • 当key很小而value很大时,使用VM的效果会比较好.因为这样节约的内存比较大
  • 当key不小时,可以考虑使用一些非常方法将很大的key变成很大的value,如可将key,value组合成一个新的value
  • 最好使用linux ext3 等对稀疏文件支持比较好的文件系统保存你的swap文件
  • vm-max-threads参数可设置访问swap文件的线程数,最好不要超过机器的核数;设置为0则所有对swap文件的操作都是串行的,可能会造成比较长时间的延迟,但是对数据完整性有很好的保证
redis数据存储
redis的存储分为内存存储、磁盘存储和log文件三部分,配置文件中有三个参数对其进行配置。
  • save seconds updates,save配置,指出在多长时间内,有多少次更新操作,就将数据同步到数据文件。可多个条件配合,默认配置了三个条件。
  • appendonly yes/no ,appendonly配置,指出是否在每次更新操作后进行日志记录,如果不开启,可能会在断电时导致一段时间内的数据丢失。因为redis本身同步数据文件是按上面的save条件来同步的,所以有的数据会在一段时间内只存在于内存中。
  • appendfsync no/always/everysec ,appendfsync配置,no表示等操作系统进行数据缓存同步到磁盘,always表示每次更新操作后手动调用fsync()将数据写到磁盘,everysec表示每秒同步一次。

 

posted @ 2014-06-18 12:57 探路者 阅读(2909) | 评论 (0)编辑 收藏

仅列出标题  下一页

导航

统计

常用链接

留言簿

随笔分类

随笔档案

文章分类

文章档案

新闻档案

Android

Compiler Course

VIM

编译技术集合

测试

高性能计算

个人博客

框架/组件/库

搜索

最新评论

阅读排行榜

评论排行榜