Что такое фибы?

fibjs — это фреймворк для разработки серверов приложений, в основном предназначенный для веб-бэкенда, основанный на движке Google v8 JavaScript и использующий другое решение для параллелизма, отличное от традиционного обратного вызова. fibjs использует волокно, чтобы изолировать сложность бизнеса, вызванную асинхронными вызовами на уровне инфраструктуры, значительно снижая сложность разработки и снижая проблемы с производительностью, вызванные частой асинхронной обработкой в ​​пользовательском пространстве.

По историческим причинам JavaScript в основном используется для обработки пользовательского интерфейса браузеров.Разработка пользовательского интерфейса представляет собой типичную однопоточную модель, управляемую событиями, поэтому JavaScript также сформировал асинхронную обработку в качестве основной парадигмы программирования.

С успехом JavaScript все больше и больше людей начали применять JavaScript в других сценариях. В то же время люди все чаще обнаруживают, что асинхронная обработка — не самый подходящий выбор во многих сценариях.

Назад к основам, Agile-разработка

fibjs использует волокно на уровне фреймворка, чтобы изолировать сложность бизнеса, связанную с асинхронными вызовами, и инкапсулирует асинхронную обработку ввода-вывода в более интуитивно понятные синхронные вызовы.Инженерам нужно только написать код в соответствии с обычной синхронной бизнес-логикой, чтобы воспользоваться преимуществами асинхронного обработки Большое удобство.

Следующий фрагмент кода взят из документации модуля mysql:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
conn.beginTransaction(err => {
    if (err) {
        throw err;
    }
    conn.query('INSERT INTO posts SET title=?', title,
        (error, results, fields) => {
            if (error) {
                return conn.rollback(() => {
                    throw error;
                });
            }

            var log = 'Post ' + results.insertId + ' added';

            conn.query('INSERT INTO log SET data=?', log,
                (error, results, fields) => {
                    if (error) {
                        return conn.rollback(() => {
                            throw error;
                        });
                    }
                    conn.commit((err) => {
                        if (err) {
                            return conn.rollback(() => {
                                throw err;
                            });
                        }
                        console.log('success!');
                    });
                });
        });
});

В fibjs для выполнения той же работы используется следующий код:

1
2
3
4
5
6
conn.trans(() => {
    var result = conn.execute('INSERT INTO posts SET title=?', title);
    var log = 'Post ' + results.insertId + ' added';
    conn.execute('INSERT INTO log SET data=?', log);
});
console.log('success!');

Если вам нужна краткость, вы можете даже написать свой код так:

1
2
3
4
conn.trans(() => conn.execute('INSERT INTO log SET data=?',
        'Post ' + conn.execute('INSERT INTO posts SET title=?', title).insertId +
        ' added'));
console.log('success!');

Мы можем ясно сравнить различия, вызванные двумя разными стилями программирования. Чем меньше кода, тем меньше ошибок. С уменьшением кода логика кода будет понятнее, и от этого выиграют как разработка, так и сопровождение.

принять высокую энергию

Хотя мы можем легко увеличить скорость отклика, расширив сервер, производительность по-прежнему должна быть одним из важных оснований для выбора среды разработки. С введением ES7 асинхронность была введена в JavaScript как новый шаблон асинхронной разработки. Однако, когда нам нравится синхронный стиль, обеспечиваемый асинхронностью, нам также приходится сталкиваться с его влиянием на производительность.

Мы можем использовать фрагмент тестового кода, чтобы сравнить различия в производительности, вызванные разными стилями программирования:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
var count = 1000;

async function test_async(n) {
    if (n == count)
        return;
    await test_async(n + 1);
}

function test_callback(n, cb) {
    if (n == count)
        return cb();

    test_callback(n + 1, () => {
        cb();
    });
}

function test_sync(n) {
    if (n == count)
        return;
    test_sync(n + 1);
}

async function test() {
    console.time("async");
    await test_async(0);
    console.timeEnd("async");

    console.time("callback");
    test_callback(0, () => {
        console.timeEnd("callback");
    });

    console.time("sync");
    test_sync(0);
    console.timeEnd("sync");
}

test();

В последней версии v8 результат этого кода выглядит следующим образом:

1
2
3
async: 0.539ms
callback: 0.221ms
sync: 0.061ms

Из результатов тестов мы можем ясно знать, что при широком использовании асинхронности в проекте сервер будет тратить много времени на обработку вызова и возврата асинхронных функций. Мы также обнаружили это в некоторых реальных тестах серверных приложений. И такое резкое падение производительности совершенно недопустимо.

Поскольку fibjs использует волокно, он может в полной мере использовать характеристики самого языка JavaScript и максимизировать превосходную производительность v8. Инженеры могут легко максимизировать производительность сервера.

Гибкий выбор парадигмы без похищения

Выбор использования fibjs не означает, что вы должны использовать синхронный стиль разработки, на самом деле fibjs поддерживает любую из известных вам парадигм асинхронного программирования, и вы можете гибко переключаться между синхронным и асинхронным стилями.

Будь то обратный вызов или асинхронность, есть фатальный недостаток — заражение. Пока функция является обратным вызовом или асинхронной, все остальные функции, зависящие от нее, должны быть обратными или асинхронными. Это приведет к огромным затратам на разработку при крупномасштабной разработке программного обеспечения.

Возьмем в качестве примера простой сценарий разработки сервера. В начале проекта мы выбрали память в качестве хранилища данных сеанса, в настоящее время мы можем использовать метод синхронизации для прямого чтения и хранения данных и развивать на этом полноценный бизнес. С развитием масштаба бизнеса нам необходимо хранить данные сеанса в Redis или mongodb, В настоящее время нам необходимо изменить операции, связанные с сеансом, в асинхронный режим.

Теоретически мы можем модифицировать каждую функцию по очереди, чтобы они соответствовали требованиям функций, от которых они зависят, но для этого требуется полное понимание всех модулей и возможность их модифицировать. Это совершенно невозможно при совместной разработке несколькими людьми или при использовании сторонних модулей.

Следовательно, все распространенные модули должны предоставлять как синхронизирующий, так и асинхронный интерфейсы, чтобы сбалансировать баланс между асинхронностью и производительностью. Более обычные разработчики предпочтут предоставлять только асинхронные интерфейсы. Таким образом, вызывая катастрофу производительности.

В fibjs можно легко решить подобные задачи, избегая явного асинхронного неконтролируемого заражения:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
var util = require('util');

function session_get(sid) {
    return sdata;
}

async function async_session_get(sid) {
    return sdata;
}

function callback_session_get(sid, cb) {
    cb(null, sdata);
}

data = session_get(sid);
data = util.sync(async_session_get)(sid);
data = util.sync(callback_session_get)(sid);

fibjs может использовать util.sync для преобразования функции обратного вызова или асинхронной функции в функцию синхронизации и вызывать ее напрямую. Таким образом, мы можем легко интегрировать модули различных парадигм программирования и преобразовывать их в парадигмы синхронизации с минимальными затратами на разработку, эффективно избегая катастроф, вызванных заражением парадигм.

начать испытывать

Готовы начать приятный опыт разработки? Итак, начнем с установки.

👉 【Среда установки и эксплуатации】