Promise简单使用

ES6原生提供了Promise对象。所谓Promise,就是Node中的一个对象,用来传递异步操作的消息。

Promise的特点
  1. 对象的状态不受外界影响。Promise对象代表一个异步操作,有三种状态:Pending、Resolved和Rejected。只有异步操作的结果,可以决定当前是哪一种状态,任何其他操作都无法改变这个状态。这也是Promise这个名字的由来,他的英语意思就是【承诺】,表示其他手段无法改变。

  2. 一旦状态改变,就不会再变,任何时候都可以得到这个结果。Promise对象的状态改变,只有两种可能:从Pending变为Resolved和从Pending变为Rejected。只要这两种情况发生,状态就凝固了,不会再变,会一直保持这个结果。就算改变已经发生了,你在对Promise对象添加回调函数,也会立即得到这个结果,这与实践(Event)完全不同,事件的特点是:如果你错过了它,再去监听,是得不到结果的。

Promise简单例子

创建一个Promise
var promise = new Promise(function (resolve, reject) {
    setTimeout(function () {
        console.log('执行完成');
        resolve('随便什么数据');
    }, 1500)
})

Promise的构造函数接收一个参数,就是一个函数,并传入两个参数:resolve、reject,分别表示异步操作执行成功后的回调函数和异步执行失败后的回调函数。其实这里用“成功”和“失败”来描述并不准确,按照标准来讲,resolve是将Promise的状态置为fullfiled,reject是将Promise的状态置为rejected。不过在我们开始阶段可以先这么理解,后面再细究概念。

上边的例子中,我们只是创建了一个Promise的对象,并没有调用它,然后我们来看下边的这个完整的例子:

function runAsync () {
    var promise = new Promise(function (resolve, reject) {
        setTimeout(function () {
            console.log('执行完成');
            resolve('随便什么数据');
        }, 2000);
    });
    return promise;
}
runAsync();

这个时候你应该有两个疑问:1. 包装这么一个函数有什么用?2. resolve(‘随便什么数据’);这个是干什么的?

接下来我们继续讲。在我们包装好的函数最后,会return出Promise对象,也就是说,执行这个函数我们得到了一个Promise对象。还记得Promise对象上有then、catch方法吧。这就是强大之处了,看下边的代码:

runAsync().then(function (data) {
    console.log(data);
    // 后边可以用传过来的数据来做一些其他操作
    // ......
});

在runAsync()的返回上直接调用then方法,then方法接收一个参数,是函数,并且会拿到我们在runAsync中调用resolve时传的参数。运行这段代码,会在两秒后输出“执行完成”,“随便什么数据”。

以上的例子中还不能很好的表现出Promise的强大之处,下面我们开始讲解链式操作

链式操作

首先看一个例子

function runAsync1(){
    var promise = new Promise(function(resolve, reject){
        //做一些异步操作
        setTimeout(function(){
            console.log('异步任务1执行完成');
            resolve('随便什么数据1');
        }, 1000);
    });
    return promise;
}
function runAsync2(){
    var promise = new Promise(function(resolve, reject){
        //做一些异步操作
        setTimeout(function(){
            console.log('异步任务2执行完成');
            resolve('随便什么数据2');
        }, 2000);
    });
    return promise;
}
function runAsync3(){
    var promise = new Promise(function(resolve, reject){
        //做一些异步操作
        setTimeout(function(){
            console.log('异步任务3执行完成');
            resolve('随便什么数据3');
        }, 2000);
    });
    return promise;
}
runAsync1()
    .then(function (data) {
        console.log(data);
        return runAsync2();
    })
    .then(function (data) {
        console.log(data);
        return runAsync3();
    })
    .then(function (data) {
        console.log(data);
    });

这段代码运行的结果是:

异步任务1执行完成
随便什么数据1
异步任务2执行完成
随便什么数据2
异步任务3执行完成
随便什么数据3

如果我们来把上班执行的代码改为这样:

runAsync1()
    .then(function (data) {
        console.log(data);
        return runAsync2();
    })
    .then(function (data) {
        console.log(data);
        return '直接返回数据';
    })
    .then(function (data) {
        console.log(data);
        done();
    });

这样执行完的结果就会变成:

异步任务1执行完成
随便什么数据1
异步任务2执行完成
随便什么数据2
直接返回数据

这里的原因自己慢慢体会吧!!!

reject的用法

到这里,你应该对Promise有了最基本的了解了。在ES6中除了resolve,还有reject这个功能。事实上,我们前面的例子中都是只有“执行成功”的回调,还没有“失败”的情况,reject的作用就是把Promise的状态置为rejected,这样我们在then中就能捕捉到,然后执行“失败”情况的回调,看下面的代码:

function getNumber() {
    var promise = new Promise(function (resolve, reject) {
        setTimeout(function () {
            var num = Math.ceil(Math.random() * 10);
            if (num < 5) {
                resolve(num);
            } else {
                reject('数字太大了');
            }
        }, 1000);
    });
    return promise;
}
getNumber().then(
    function (data) {
        console.log('resolved');
        console.log(data);
    },
    function (reason, data) {
        console.log('rejected');
        console.log(reason);
    });

getNumber函数用来获取一个数字,1秒后执行完成,如果数字小于5,我们认为是“成功”了,调用resolve修改Promise的状态。否则我们就认为是“失败”了,调用reject并传递一个参数,作为失败的原因。

运行getNumber并且在then中传了两个参数,then方法可以接受两个参数,第一个对应resolve的回调,第二个对应reject的回调。所以我们能够分别拿到他们传过来的数据,多次运行这段代码,你会随机到下面两种结果:

resolved
3
或者
rejected
数字太大了

catch的用法

我们知道Promise对象除了then方法,还有一个catch方法,他是做什么用的呢?其实它和then的第二个参数一样,用来指定reject的回调,用法是这样的:

getNumber()
    .then(function (data) {
        console.log('resolved');
        console.log(data);
    })
    .catch(function (reason) {
        console.log('rejected');
        console.log(reason);
    })

效果和写在then的第二个参数里边是一样的。不过它还有另一个作用:在执行resolve的回调(也就是上面then中的第一个参数)时,如果抛出异常(代码出错),那么并不会报错卡死js,而是进到这个catch方法中。请看下面的代码:

getNumber()
    .then(function(data){
        console.log('resolved');
        console.log(data);
        console.log(somedata); //此处的somedata未定义
    })
    .catch(function(reason){
        console.log('rejected');
        console.log(reason);
    });

在resolve的回调中,我们console.log(somedata);而somedata这个变量是没有被定义的。如果我们不用Promise,代码运行到这里就直接在控制台报错了,不往下运行了。但是这里,我们会得到这样的结果:

resolved
4
rejected
[ReferenceError: somedata is not defined]

all的用法

Promise的all方法提供了并行执行异步操作的能力,并且在所有异步操作执行完后才执行回调。我们仍旧使用上面定义好的runAsync1、runAsync2、runAsync3这三个函数,看下面的例子:

Promise
    .all([runAsync1(), runAsync2(), runAsync3()])
    .then(function (results) {
        console.log(results);
    });

会打印:

异步任务1执行完成
异步任务2执行完成
异步任务3执行完成
[ '随便什么数据1', '随便什么数据2', '随便什么数据3' ]

有了all,你就可以并行执行多个异步操作,并且在一个回调中处理所有返回数据,是不是很酷?有一个场景是很适合用这个的,一些游戏类的素材比较多的应用,打开网页时,预先加载需要用到的各种资源,比如图片、flash以及各种静态文件。所有的都加载完后,我们进行页面的初始化。

race的用法

all方法的效果实际上是【谁跑得慢,以谁为准执行回调】,那么相对的就有另一个方法【谁跑的快,以谁为准执行回调】,这就是race方法,这个词本来就是赛跑的意思。race的用法与all一样,我们把上面runAsync()的延时改为1秒来看一下:

Promise
    .race([runAsync1(), runAsync2(), runAsync3()])
    .then(function (results) {
        console.log(results);
    });

这个异步操作同样是并行执行的。1秒后runAsync已经执行完了,此时then里面的就执行了。结果是这样的:

异步任务1执行完成
随便什么数据1
异步任务2执行完成
异步任务3执行完成

这个时候runAsync2()和runAsync3()并没有停止,仍旧再执行。于是再过1秒后,输出了他们结束的标志。

类的适配器模式

首先,有两个类:ClassA、ClassB

ClassA类:有A、B两个方法

ClassB类:有B、C两个方法

那么,怎么做才能在实现了ClassA类之后,让ClassB类公用ClassA类的B方法

如下一个例子:

鸡子和鸭子都会飞,但是鸭子是”嘎嘎”叫,鸡子是”咯咯”叫,

那么怎么在创建了一个鸭子类之后,让鸡子类使用鸭子类中共同属性的方法呢?

1. 类适配器模式

    public static void main(String[] args) {
//        使用 Adapter 创建 Duck 对象
        Duck duck = new Adapter();
        duck.fly();         // 鸭子 飞 的方法
        duck.quack();       // 鸭子 嘎嘎 的方法
        System.out.println("----------------------");
//        使用 Adapter 创建 Chicken 对象
        Chicken chicken = new Adapter();
        chicken.fly();      // 鸡子 飞 的方法
        chicken.gobble();   // 鸡子 咯咯 的方法
        System.out.println("----------------------");
//        使用 Adapter 创建 Bird 对象
        Bird bird = new Adapter();
        bird.fly();         // 小鸟 飞 的方法
        bird.chirp();       // 小鸟 叽叽 的方法
    }


    public interface Duck {
        void fly();
        void quack();
    }

    public interface Chicken {
        void fly();
        void gobble();
    }

    public interface Bird {
        void fly();
        void chirp();
    }

    public static class Ducker implements Duck {
        @Override
        public void fly() {
            System.out.println("我会飞 我会飞");
        }
        @Override
        public void quack() {
            System.out.println("Duck 嘎嘎 嘎嘎");
        }
    }

    public static class Adapter extends Ducker implements Chicken, Bird {
        @Override
        public void gobble() {
            System.out.println("Chicken 咯咯 咯咯");
        }

        @Override
        public void chirp() {
            System.out.println("Bird 叽叽 叽叽");
        }
    }

打印结果为

我会飞 我会飞
Duck 嘎嘎 嘎嘎
----------------------
我会飞 我会飞
Chicken 咯咯 咯咯
----------------------
我会飞 我会飞
Bird 叽叽 叽叽

2. 对象适配器模式

ChickenBird想用Duckfly()方法,则看下面的例子

    public static void main(String[] args) {
//        使用 Adapter 创建 Chicken 对象
//        需要传入 Duck 的对象, 才能使用 Duck 中的 fly 方法
        Chicken chicken = new Adapter(new Ducker());
        chicken.fly();
        chicken.gobble();
        System.out.println("-----------------");

//        使用 Adapter 创建 Chicken 对象
//        需要传入 Duck 的对象, 才能使用 Duck 中的 fly 方法
        Bird bird = new Adapter(new Ducker());
        bird.fly();
        bird.chirp();
        System.out.println("-----------------");

//        使用自己的类创建对象
        Duck duck = new Ducker();
        duck.fly();
        duck.quack();
    }


    public interface Duck {
        void fly();
        void quack();
    }

    public interface Chicken {
        void fly();
        void gobble();
    }

    public interface Bird {
        void fly();
        void chirp();
    }

    public static class Ducker implements Duck {
        @Override
        public void fly() {
            System.out.println("我会飞 我会飞");
        }
        @Override
        public void quack() {
            System.out.println("Duck 嘎嘎 嘎嘎");
        }
    }


    public static class Adapter implements Chicken, Bird {
        Ducker ducker;

        public Adapter(Ducker ducker) {
            super();
            this.ducker = ducker;
        }

        @Override
        public void fly() {
            ducker.fly();
        }

        @Override
        public void chirp() {
            System.out.println("Bird 叽叽 叽叽");
        }


        @Override
        public void gobble() {
            System.out.println("Chicken 咯咯 咯咯");
        }
    }

运行结果:

我会飞 我会飞
Chicken 咯咯 咯咯
-----------------
我会飞 我会飞
Bird 叽叽 叽叽
-----------------
我会飞 我会飞
Duck 嘎嘎 嘎嘎

关于Nodejs的多进程模板Cluster

前言

我们都知道nodejs最大的特点就是单进程、无阻塞运行,并且是异步事件驱动的。Nodejs的这些特性能够很好的解决一些问题,例如在服务器开发中,并发的请求处理是个大问题,阻塞式的函数会导致资源浪费和时间延迟。通过事件注册、异步函数,开发人员可以提高资源的利用率,性能也会改善。既然Node.js采用单进程、单线程模式,那么在如今多核硬件流行的环境中,单核性能出色的Nodejs如何利用多核CPU呢?创始人Ryan Dahl建议,运行多个Nodejs进程,利用某些通信机制来协调各项任务。目前,已经有不少第三方的Node.js多进程支持模块发布,而NodeJS 0.6.x 以上的版本提供了一个cluster模块 ,允许创建“共享同一个socket”的一组进程,用来分担负载压力。本篇文章就基于该cluster模块来讲述Node.js在多核CPU下的编程。

Cluster用法介绍

首先贴出一段该模板示例应用代码,接下来进行分析,代码如下

'use strict';

var cluster = require('cluster');
var http = require('http');
var numCPUs = require('os').cpus().length;

if (cluster.isMaster) {
    for (var i = 0; i < numCPUs; i++) {
        cluster.fork();
    }
    cluster.on('listening',function(worker,address){
        console.log('listening: worker ' + worker.process.pid +', Address: '+address.address+":"+address.port);
    });

    cluster.on('exit', function(worker, code, signal) {
        console.log('worker ' + worker.process.pid + ' died');
    });
} else {
    process.env.NODE_ENV = 'production';
    require('./server.js');
}

负载均衡问题

一个请求过来,是给worker进程A处理,还是给worker进程B处理呢?怎么保证大家均等的干活呢?这就是负载均衡的问题。

当前有两种可选的方法来做负载均衡。

早期的cluster是各个worker进程自己去监听socket端口,由操作系统去唤醒worker进程,大家可能很容易认为操作系统会随机的选择worker进程,于是就实现了服务的负载均衡。但实际上,像Linux操作系统总是唤醒某几个进程,因为对于系统来说,上下文切换时很昂贵的操作,唤醒最近被唤醒的进程是比较好的选择。早期的这种方式负载是很不均衡的。

从0.11.2版本开始,cluster开始增加了round-robin模式做负载均衡:master进程负责监听,收到请求后转发给worker进程,多个worker进程轮流干活。round-robin是当前cluster的默认负载均衡处理模式(除了windows平台),如果要回到之前的模式,有两种方式

(1)可以在cluster加载之后未调用其他cluster函数之前执行:cluster.schedulingPolicy = cluster.SCHED_NODE;来设定。

(2)设置环境变量NODE_CLUSTER_SCHED_POLICY = “none”

进程监控

master进程不会自动管理worker进程的生死,如果worker被外界杀掉了,不会自动重启,只会给master进程发送‘exit’消息,开发者需要自己做好管理。

数据共享问题

各个worker进程之间是独立的,为了让多个worker进程共享数据(譬如用户session),一般的做法是在Nodejs之外搭建一个数据库,多个worker进程通过数据库做数据共享。

Ubuntu14.04设置静态IP

第一步:

配置静态IP地址: 打开/etc/network/interfaces文件,内容为

auto lo
iface lo inet loopback

auto eth0
iface eth0 inet dhcp

以上表示默认使用DHCP分配IP,如果想指定静态IP,则需要如下的修改

auto lo
iface lo inet loopback

auto eth0
iface eth0 inet static *******定义为静态IP

address 192.168.2.29   *******所要设置的IP地址
netmask 255.255.255.0  *******子网掩码
gateway 192.168.2.1    *******网关(路由地址)

然后保存此文件

第二步:

手动设置DNS服务器

打开文件/etc/resolv.conf,设置内容如下

nameserver 192.168.2.1  ******网关(同上)
nameserver 202.106.0.20 ******DNS服务器地址(我是参照其他电脑链接到此网络上查到的)
// 202.96.128.86

第三步:

注意:重启Ubuntu后发现不能上网,问题出现在/etc/resolv.conf。重启后,此文件配置的dns又被自动修改为默认值。所以需要永久性修改DNS。方法为 打开文件/etc/resolvconf/resolv.conf.d/base,写入一下内容:

nameserver 192.168.2.1
nameserver 202.106.0.20

第四步:

重启networking服务,使其生效,命令为:

/etc/init.d/networking restart

(亲身经历为:重启此服务无效,还是重启系统给力)