---
title: "OpenResty における `string` の利点と欠点 - API7.ai"
description: "本記事では、OpenRestyで従うべき最適化技術を紹介します。リクエストを短く、シンプルに、そして迅速に処理し、中間データの生成を避けることが重要です。また、文字列の最適化技術についても解説します。"
url: "https://api7.ai/ja/learning-center/openresty/advantages-and-disadvantages-of-string"
---

# OpenResty における \`string\` の利点と欠点

API7.ai

December 8, 2022

[OpenResty (NGINX + Lua)](https://api7.ai/learning-center/openresty)

前回の記事では、OpenRestyにおける一般的なブロッキング関数について学び、それらが初心者によく誤用されることを確認しました。今回の記事からは、パフォーマンス最適化の核心に触れていきます。これには多くの最適化技術が含まれており、OpenRestyコードのパフォーマンスを迅速に向上させるのに役立ちますので、軽視しないでください。

この過程では、これらの最適化技術の使用方法を体験し、その効果を検証するために、より多くのテストコードを書く必要があります。これにより、それらをうまく活用できるようになります。

## パフォーマンス最適化の裏側

最適化技術はすべて「実践」の一部ですので、それを行う前に、最適化の「理論」について話しましょう。

パフォーマンス最適化の方法は、LuaJITとOpenRestyの更新に伴って変化します。一部の方法は、基盤技術によって直接最適化され、もはや習得する必要がなくなるかもしれません。同時に、新しい最適化技術も登場します。したがって、これらの最適化技術の背後にある普遍的な概念を習得することが最も重要です。

OpenRestyプログラミングにおけるパフォーマンスに関するいくつかの重要な考え方を見てみましょう。

### 理論1: リクエストの処理は短く、シンプルで、高速であるべき

OpenRestyはウェブサーバーであるため、1,000以上、10,000以上、さらには100,000以上のクライアントリクエストを同時に処理することがよくあります。したがって、全体のパフォーマンスを最大化するためには、個々のリクエストが迅速に処理され、メモリなどのリソースが回収されることを保証する必要があります。

- ここで言う「短い」とは、リクエストのライフサイクルが短く、リソースを長時間占有しないことを意味します。長い接続の場合でも、時間やリクエスト数の閾値を設定して、定期的にリソースを解放する必要があります。
- 2つ目の「シンプル」とは、1つのAPIで1つのことだけを行うことを指します。複雑なビジネスロジックを複数のAPIに分割し、コードをシンプルに保ちます。
- 最後の「高速」とは、メインスレッドをブロックしないこと、そして多くのCPU操作を実行しないことを意味します。もしそうする必要がある場合でも、前回の記事で紹介した他の方法と組み合わせることを忘れないでください。

このアーキテクチャの考慮事項は、OpenRestyだけでなく、さらなる開発言語やプラットフォームにも適していますので、よく理解し、考えてみてください。

### 理論2: 中間データの生成を避ける

中間プロセスでの無駄なデータを避けることは、OpenRestyプログラミングにおいて最も支配的な最適化理論と言えます。中間プロセスでの無駄なデータを説明するために、小さな例を見てみましょう。

```
$ resty -e 'local s= "hello"
s = s .. " world"
s = s .. "!"
print(s)
'
```

このコードスニペットでは、`s`変数に対して複数の結合操作を行い、結果として`hello world!`を得ています。しかし、`s`の最終的な状態である`hello world!`だけが有用です。`s`の初期値や中間の代入はすべて中間データであり、できるだけ生成しないようにするべきです。

その理由は、これらの一時データが初期化とGCのパフォーマンス損失をもたらすからです。これらの損失を軽視しないでください。もしこれがループなどのホットコードに現れると、パフォーマンスが明らかに低下します。後で文字列の例を使ってこれを説明します。

## `string`は不変

さて、本記事の主題である`string`に戻りましょう。ここで強調したいのは、Luaにおいて`string`は不変であるということです。

もちろん、これは`string`が結合や変更などができないという意味ではありませんが、`string`を変更する際には、元の`string`を変更するのではなく、新しい`string`オブジェクトを作成し、`string`への参照を変更します。したがって、元の`string`が他の参照を持っていない場合、LuaのGC（ガベージコレクション）によって回収されます。

不変な`string`の明らかな利点は、メモリを節約できることです。これにより、同じ`string`のコピーがメモリ内に1つだけ存在し、異なる変数が同じメモリアドレスを指すようになります。

この設計の欠点は、`string`の追加や回収に関して、`string`を追加するたびにLuaJITが`lj_str_new`を呼び出して`string`が既に存在するかどうかを確認し、存在しない場合は新しい`string`を作成する必要があることです。これを頻繁に行うと、パフォーマンスに大きな影響を与えます。

この例のような`string`結合操作の具体的な例を見てみましょう。これは多くのOpenRestyオープンソースプロジェクトで見られます。

```
$ resty -e 'local begin = ngx.now()
local s = ""
-- `for`ループで`..`を使用して文字列を結合
for i = 1, 100000 do
    s = s .. "a"
end
ngx.update_time()
print(ngx.now() - begin)
'
```

このサンプルコードは、`s`変数に対して100,000回の`string`結合を行い、実行時間を出力します。この例は少し極端ですが、最適化前後のパフォーマンスの違いをよく示しています。最適化なしでは、このコードは私のラップトップで0.4秒かかりますが、これはまだ比較的遅いです。では、どのように最適化すべきでしょうか？

前回の記事で答えは出ていますが、`table`を使用して一時的な中間`string`をすべて取り除き、元のデータと最終結果だけを保持する方法です。具体的なコード実装を見てみましょう。

```
$ resty -e 'local begin = ngx.now()
local t = {}
-- 配列を使用して文字列を保持する`for`ループで、毎回配列の長さをカウント
for i = 1, 100000 do
    t[#t + 1] = "a"
end
-- 配列の`concat`メソッドを使用して文字列を結合
local s =  table.concat(t, "")
ngx.update_time()
print(ngx.now() - begin)
'
```

このコードでは、各文字列を順番に`table`に保存し、インデックスは`#t + 1`、つまり`table`の現在の長さに`1`を加えた値で決定します。最後に、`table.concat`関数を使用して各配列要素を結合します。これにより、すべての一時的な文字列をスキップし、100,000回の`lj_str_new`とGCを回避します。

これが私たちのコード分析ですが、最適化の効果はどうでしょうか？最適化されたコードはわずか0.007秒で、50倍以上のパフォーマンス向上を実現しています。実際のプロジェクトでは、この例では1回の追加で1文字`a`を追加しているだけなので、さらに顕著なパフォーマンス向上が見られるかもしれません。

新しい`string`が10倍の長さの`a`の場合、パフォーマンスの違いはどうなるでしょうか？

0.007秒のコードは私たちの最適化作業に十分でしょうか？いいえ、まだ最適化できます。もう1行のコードを変更して結果を見てみましょう。

```
$ resty -e 'local begin = ngx.now()
local t = {}
-- `for`ループで、配列を使用して文字列を保持し、配列の長さ自体を維持
for i = 1, 100000 do
    t[i] = "a"
end
local s =  table.concat(t, "")
ngx.update_time()
print(ngx.now() - begin)
'
```

今回は、`t[#t + 1] = "a"`を`t[i] = "a"`に変更し、たった1行のコードで配列の長さを取得する100,000回の関数呼び出しを回避しました。以前の`table`セクションで説明した配列の長さを取得する操作を覚えていますか？これは`O(n)`の時間計算量を持つ比較的高価な操作です。したがって、ここでは単に配列のインデックスを維持することで、配列の長さを取得する操作を回避しています。言い換えれば、もしそれが面倒なら、避けることができます。

もちろん、これはよりシンプルな書き方です。以下のコードは、自分で配列のインデックスを維持する方法をより明確に示しています。

```
$ resty -e 'local begin = ngx.now()
local t = {}
local index = 1
for i = 1, 100000 do
    t[index] = "a"
    index = index + 1
end
local s = table.concat(t, "")
ngx.update_time()
print(ngx.now() - begin)
'
```

## 他の一時的な`string`を減らす

先ほど話した`string`結合による一時的な`string`のミスは明らかです。上記のサンプルコードをいくつか見れば、同様のミスを繰り返さないと信じています。しかし、OpenRestyではもっと隠れた一時的な`string`が生成されることがあり、それらははるかに検出しにくいです。例えば、以下で説明する`string`処理関数はよく使用されますが、それが一時的な`string`を生成することに気づいていましたか？

ご存知の通り、`string.sub`関数は`string`の指定された部分を切り取ります。前述の通り、Luaの`string`は不変であるため、新しい文字列を切り取るには`lj_str_new`とそれに続くGC操作が発生します。

```
resty -e 'print(string.sub("abcd", 1, 1))'
```

上記のコードの機能は、`string`の最初の文字を取得して出力することです。当然、一時的な`string`が生成されます。同じ効果を達成するためのより良い方法はあるでしょうか？

```
resty -e 'print(string.char(string.byte("abcd")))'
```

もちろんあります。このコードでは、まず`string.byte`を使用して最初の文字の数値コードを取得し、次に`string.char`を使用してその数値を対応する文字に変換します。このプロセスでは一時的な`string`は生成されません。したがって、`string`関連のスキャンや分析を行う際には、`string.byte`を使用することが最も効率的です。

## `table`型のSDKサポートを活用

一時的な`string`を減らす方法を学んだ後、試してみたくなりましたか？それでは、上記のサンプルコードの結果をクライアントにレスポンスボディの内容として出力してみましょう。この時点で、一時停止して、まず自分でこのコードを書いてみてください。

```
$ resty -e 'local begin = ngx.now()
local t = {}
local index = 1
for i = 1, 100000 do
    t[index] = "a"
    index = index + 1
end
local response = table.concat(t, "")
ngx.say(response)
'
```

もしこのコードを書けるなら、あなたはすでにほとんどのOpenResty開発者よりも進んでいます。OpenRestyのLua APIは、`string`結合に`table`を使用することを考慮しているため、`ngx.say`、`ngx.print`、`ngx.log`、`cosocket:send`などの多くの`string`を取る可能性のあるAPIでは、`string`だけでなく`table`もパラメータとして受け入れます。

```
resty -e 'local begin = ngx.now()
local t = {}
local index = 1
for i = 1, 100000 do
    t[index] = "a"
    index = index + 1
end
ngx.say(t)
'
```

この最後のコードスニペットでは、`local response = table.concat(t, "")`という`string`結合のステップを省略し、`table`を直接`ngx.say`に渡しています。これにより、`string`結合のタスクをLuaレベルからCレベルにシフトし、別の`string`の検索、生成、GCを回避します。長い`string`の場合、これはさらなる大きなパフォーマンス向上をもたらします。

## まとめ

この記事を読んだ後、OpenRestyのパフォーマンス最適化が多くの細かい部分に触れていることがわかります。したがって、最適なパフォーマンスを達成するためには、LuaJITとOpenRestyのLua APIをよく知る必要があります。これはまた、以前の内容を忘れてしまった場合、すぐに復習して定着させる必要があることを思い出させます。

最後に、1つの問題を考えてみてください：文字列`hello`、`world`、`!`をエラーログに書き込む場合、`string`結合なしでサンプルコードを書くことはできるでしょうか？

また、本文中の他の質問も忘れないでください。新しい`string`が10倍の長さの`a`の場合、以下のコードのパフォーマンスの違いはどうなるでしょうか？

```
$ resty -e 'local begin = ngx.now()
local t = {}
for i = 1, 100000 do
    t[#t + 1] = "a"
end
local s =  table.concat(t, "")
ngx.update_time()
print(ngx.now() - begin)
'
```

この記事を友人と共有して学び、交流することも歓迎します。

Share article link

Share

Related Posts

[![非阻塞I/O - OpenResty性能提升的关键](https://static.api7.ai/2022/12/05/638dce5075e0f.png)](https://api7.ai/learning-center/openresty/blocking-io)

## [非阻塞I/O - OpenResty性能提升的关键](https://api7.ai/learning-center/openresty/blocking-io)

[![OpenResty FAQ | OpenRestyの実践的な使い方](https://static.api7.ai/uploads/2023/02/12/jbv9M0zi_Hello%20World%20in%20OpenResty%20%283%29.png)](https://api7.ai/learning-center/openresty/faq-5)

## [OpenResty FAQ | OpenRestyの実践的な使い方](https://api7.ai/learning-center/openresty/faq-5)

Table of Contents

- [パフォーマンス最適化の裏側](#%E3%83%91%E3%83%95%E3%82%A9%E3%83%BC%E3%83%9E%E3%83%B3%E3%82%B9%E6%9C%80%E9%81%A9%E5%8C%96%E3%81%AE%E8%A3%8F%E5%81%B4)

  - [理論1: リクエストの処理は短く、シンプルで、高速であるべき](#%E7%90%86%E8%AB%961-%E3%83%AA%E3%82%AF%E3%82%A8%E3%82%B9%E3%83%88%E3%81%AE%E5%87%A6%E7%90%86%E3%81%AF%E7%9F%AD%E3%81%8F%E3%82%B7%E3%83%B3%E3%83%97%E3%83%AB%E3%81%A7%E9%AB%98%E9%80%9F%E3%81%A7%E3%81%82%E3%82%8B%E3%81%B9%E3%81%8D)
  - [理論2: 中間データの生成を避ける](#%E7%90%86%E8%AB%962-%E4%B8%AD%E9%96%93%E3%83%87%E3%83%BC%E3%82%BF%E3%81%AE%E7%94%9F%E6%88%90%E3%82%92%E9%81%BF%E3%81%91%E3%82%8B)

- [`string`は不変](#string%E3%81%AF%E4%B8%8D%E5%A4%89)

- [他の一時的な`string`を減らす](#%E4%BB%96%E3%81%AE%E4%B8%80%E6%99%82%E7%9A%84%E3%81%AAstring%E3%82%92%E6%B8%9B%E3%82%89%E3%81%99)

- [`table`型のSDKサポートを活用](#table%E5%9E%8B%E3%81%AEsdk%E3%82%B5%E3%83%9D%E3%83%BC%E3%83%88%E3%82%92%E6%B4%BB%E7%94%A8)

- [まとめ](#%E3%81%BE%E3%81%A8%E3%82%81)
