openid 研究

Javascript 代码优化经验

尽可能避免使用全局变量和函数.
全局的变量和函数其实等价于 window 对象的属性/方法, 访问速度自然会慢.

var myvar = 0; // 336ms
window.myvar = 0; // 2383ms

var myfunc = function(){} // 3515ms
window.myfunc = function(){} // 10151ms

尽量避免用 new 操作符创建函数.
可能通过 new 创建的函数还需要额外地对函数内容字符串进行解析操作.

function f(){}; // 277ms
var f  = function(){} // 3085ms
var f = new Function("") // 13275ms

尽量避免使用 eval() 执行代码.
原因同 new 创建函数的操作.

 

var myfunc = function(){} // 3408ms
eval("var myfunc = function(){}"); // 9140ms

少使用 new 操作符创建数组.
原因同 new 创建函数的操作. 特别在有大量数据时更为明显

a = [1, 2, 3]; // 4360ms
a = new Array(1, 2, 3); // 5000ms

尽量避免使用 push() 和 pop() 处理数组数据.

a = value; // 1270ms
a.push(value); // 3240ms

使用对象代替数组存储数据对性能略有影响.
也许是因为 Javascript 的数组是个带有扩展方法和属性的对象, 而不像 VBScript 那样是单纯的数据结构.

a = value; // 1270ms
obj[property] = value; // 960ms

使用 ++ 代替 x = x+1 和 +=.
事实上 ++ 并不比 + 和 += 快很多, 但是在大量的操作时就会体现出其优势.
而 + 和 += 几乎没有性能差别. 同理对 — 和 – 以及 -= 适用.

x++; // 378ms
x = x+1; // 406ms
x += 1; // 406ms

使用局部变量缓存对象属性和函数指针
例如在遍历数组时缓存数组长度, 事实上获取 Javascript 的数组长度等于调用一个方法函数(大部分Javascript 引擎是这样实现的).
如果对 HTML DOM 进行操作, 那么优化的效果会非常明显.

for(var i=0;i<arr.length;i++){ … } // 162ms

var length = arr.length;
for(var i=0;i<length;i++){ … } // 156ms

或者使用局部变量缓存一个外部函数(具体效果视代码复杂度而定).
如果代码块中要多次调用一个外部函数或变量, 那么缓存的效果会非常明显.

function test(){ … }
function run1(){  test(); }
function run2(){  var t = test;  t(); }

run1(); // 98ms
run2(); // 80ms

避免使用 with 操作符

转自： http://hi.baidu.com/dark/blog/item/54fbd7caa7fe1246f21fe75a.html

loadScript 和 addEvent

    function loadScript(url, callback, charset){
        charset = charset || 'utf-8';
        callback = callback ||
        function(){
        };
        var t = document.createElement("script");
        t.type = "text/javascript";
        t.charset = charset;
        t.src = url;
        var _fun = function(){
            if (t.onreadystatechange) {
                t.onreadystatechange = null;
            }
            else {
                t.onload = null;
            }
            _fun = null;  // 此句感觉无效
            document.getElementsByTagName("head")[0].removeChild(t);
            callback();
        };
        if (typeof t.onreadystatechange != "undefined") {
            t.onreadystatechange = function(){
                if (t.readyState == 'complete' || t.readyState == 'loaded') {
                    _fun();
                }
            };
        }
        else {
            t.onload = _fun;
        }
        //此句可能有bug
        //document.getElementsByTagName("head")[0].appendChild(t);
        document.getElementsByTagName("head")[0].insertBefore(t,document.getElementsByTagName("head")[0].firstChild);
    }
    
    function addEventListener(dom, eventName, fn){
        if (dom.addEventListener) {
            dom.addEventListener(eventName, fn, false);
        }
        else if (dom.attachEvent) {
                dom.attachEvent("on" + eventName, fn);
            }
        else
        {
            dom["on" + eventName] = fn;
        }
    }

递归创建目录的一个函数

下面是从openid的php代码中看到的一个递归创建目录的函数，感觉是比较简洁的，值得参考

<?php
    function ensureDir($dir_name)                                                 
    {                                                                             
        if (is_dir($dir_name) || @mkdir($dir_name)) {                             
            return true;                                                          
        } else {                                                                  
            $parent_dir = dirname($dir_name);                                     
                                                                                  
            // Terminal case; there is no parent directory to create.             
            if ($parent_dir == $dir_name) {                                       
                return true;                                                      
            }                                                                     
                                                                                  
            return (ensureDir($parent_dir) && @mkdir($dir_name));    
        }                                                                         
    }  
?>

Memcacheq 出新版本了

官方地址： http://code.google.com/p/memcacheq/

安装方法在INSTALL里面都说的很明白了，这里就絮叨一下自己安装时遇到的一些问题。

1. 文档中说bdb依赖为： Berkeley DB 4.7 or later； 于是我就下了一个最新的4.8.24， 结果安装时不会自动找4.8版本的，还是找4.7版本的，可能通过修改一些问题可以搞定，但是也没有必要，就重新下了一个4.7版本的，安装很顺利了； 所以说，严格安装文档来安装吧！

2. 启动时忘记指定user了，虽然我将错误做了重定向，但是错误信息还是写到了/dev/null中了，这应该算是一个bug吧。

3. 因为memcacheq的数据时落地的，所以要通过-H参数指定数据存放的路径用以存放数据，且该目录要对指定的user可写

top 命令补充 (ni hi si )

Tasks: 247 total,   1 running, 246 sleeping,   0 stopped,   0 zombie
Cpu(s):  0.3% us,  0.7% sy,  0.0% ni,  0.0% id, 98.7% wa,  0.3% hi,  0.0% si

I believe it goes something like this –

wa = wiating for IO
us = userspace
sy = system/kernel
ni = nice processs
id = idle
hi = hardware interrupts
si = software interrupts

Tasks: 29 total 进程总数
1 running 正在运行的进程数
28 sleeping 睡眠的进程数
0 stopped 停止的进程数
0 zombie 僵尸进程数
Cpu(s): 0.3% us 用户空间占用CPU百分比
1.0% sy 内核空间占用CPU百分比
0.0% ni 用户进程空间内改变过优先级的进程占用CPU百分比
98.7% id 空闲CPU百分比
0.0% wa 等待输入输出的CPU时间百分比
0.0% hi 硬件中断  
0.0% si 软件中断

Mem: 191272k total 物理内存总量
173656k used 使用的物理内存总量
17616k free 空闲内存总量
22052k buffers 用作内核缓存的内存量
Swap: 192772k total 交换区总量
0k used 使用的交换区总量
192772k free 空闲交换区总量
123988k cached 缓冲的交换区总量。
内存中的内容被换出到交换区，而后又被换入到内存，但使用过的交换区尚未被覆盖，
该数值即为这些内容已存在于内存中的交换区的大小。
相应的内存再次被换出时可不必再对交换区写入。

进程信息区统计信息区域的下方显示了各个进程的详细信息。首先来认识一下各列的含义。
序号 列名 含义
a PID 进程id
b PPID 父进程id
c RUSER Real user name
d UID 进程所有者的用户id
e USER 进程所有者的用户名
f GROUP 进程所有者的组名
g TTY 启动进程的终端名。不是从终端启动的进程则显示为 ?
h PR 优先级
i NI nice值。负值表示高优先级，正值表示低优先级
j P 最后使用的CPU，仅在多CPU环境下有意义
k %CPU 上次更新到现在的CPU时间占用百分比
l TIME 进程使用的CPU时间总计，单位秒
m TIME+ 进程使用的CPU时间总计，单位1/100秒
n %MEM 进程使用的物理内存百分比
o VIRT 进程使用的虚拟内存总量，单位kb。VIRT=SWAP+RES
p SWAP 进程使用的虚拟内存中，被换出的大小，单位kb。
q RES 进程使用的、未被换出的物理内存大小，单位kb。RES=CODE+DATA
r CODE 可执行代码占用的物理内存大小，单位kb
s DATA 可执行代码以外的部分(数据段+栈)占用的物理内存大小，单位kb
t SHR 共享内存大小，单位kb
u nFLT 页面错误次数
v nDRT 最后一次写入到现在，被修改过的页面数。
w S 进程状态。
D=不可中断的睡眠状态
R=运行
S=睡眠
T=跟踪/停止
Z=僵尸进程
x COMMAND 命令名/命令行
y WCHAN 若该进程在睡眠，则显示睡眠中的系统函数名
z Flags 任务标志，参考 sched.h  

sleep 与 stop的区别之一：
sleep是主动放弃cpu的，stop是被动放弃cpu的。

ll /proc/sys/vm/

Solaris线程模型

计算机中正在执行的程序称为进程，进程中单一顺序的控制流叫做线程，进程是资源管理的最小单位，线程是程序执行的最小单位。在操作系统设计上，从进程演化出线程，最主要的目的就是利用线程共享同一地址空间的特点，更好的支持对称多处理（SMP）以及减小（进程/线程）上下文切换开销。

Solaris是Sun公司开发和发布的一种现代操作系统，是UNIX系统的一个重要分支，下面就其内部的线程模型做一些介绍和讨论。

 

Solaris线程模型的设计目标：

       主要有四个方面：

①．能够描述各种情况下的线程间工作机制

②．支持代价尽可能小的线程

③．既支持单CPU实现，又支持多CPU实现

④．保持对现有UNIX版本的兼容性

 

Solaris线程模型的实现方法：

       线程库的高级内核具有多处理及多线程特性，因此Solaris提供了大量的用户级线程库，其使用了一种两层的线程库模型：在高层是用户线程，而底层则是轻量级进程(LWP)。

LWP其实就是内核线程，是Solaris中真正的可调度实体。内核只关心LWP，而不关心用户线程。

用户线程由线程库管理，线程库支持用户线程及LWP之间的一到一、多到多、多到一映射，并且用线程库管理用户线程与LWP池之间的映射关系及用户线程的调度。

Solaris有两种用户线程: 绑定线程（bound threads）和未绑定线程(unbound threads)。一个绑定线程就是用户线程与LWP之间的一一映射，一个未绑定线程则没有一个固定对应的LWP。在一个进程中，线程库在LWP池上对用户线程进行调度。其结构图如下：

对以上两者进行比较，未绑定进程由线程库来实现用户线程获得LWP的调度，而不需要内核的参与，这种方式的线程上下文切换比较快，并且更节省内核资源，solaris根据一定的策略提供一个LWP池，供上面更多的线程分享。

绑定线程和LWP是一对一关系，因此实时调度性要好，但是由于内核的加入，比较浪费资源。绑定线程比起非绑定线程的开销要大。因为绑定线程可以改变它所在的LWP的属性，LWP在绑定线程退出后不会被缓存，在新的绑定线程生成时，操作系统将提供一个新的LWP。仅仅在线程需要只有在所在的LWP内可用的资源时（例如虚拟的定时器或者一个指定的堆栈），或者为了实现实时调度而必须使线程对于内核可见的场合下，才需要使用绑定线程。

 

Solaris对线程的控制与同步：

内核根据LWP的调度类型和优先级对它们进行调度。进程建立时有一个初始LWP被建立，并且继承父进程的调度类型和优先级。一般来说，绑定的用户线程继承底层的LWP调度类型和优先级，而未绑定的则继承父进程的调度类型和优先级。

Solaris内核使用一种抢先的基于优先级的调度机制，高优先级的LWP比低优先级的LWP先执行。Solaris线程库使用优先级对用户线程在LWP池上进行调度，每次选择一个LWP执行已经就绪的用户线程。如果某LWP因无限等待而阻塞，线程库则将其对应的用户线程的上下文保存起来，并分派另一个用户线程到该LWP上执行。线程库通常建立足够多的LWP，以保证进程不发生”饥饿”。

       线程的同步用于共享数据，转换和控制线程执行，保证程序安全。Solaris支持4种线程的同步原语,分别是互斥锁,信号量,多读进程单写进程锁,条件变量。

内核级线程和用户级线程都具有这些原语操作。一条原语执行时创建一个包含线程信息的数据结构，对每个同步对象只能执行加锁和解锁两项操作，但内核和线程库没有提供防死锁机制。

     

总结：

       Solaris作为多线程，多进程型的操作系统，其关于线程实现机制方面一直是业界领先的，了解solaris的多线程实现机制不但能够帮助我们充分理解操作系统对多线程的控制原理，而且对多线程程序的编写技巧的提高也有很大启发。