Directorio de artículos
Biblioteca común de Golang - Biblioteca común de Golang - Paquete pierrec/lz4 | Algoritmo de compresión lz4 (alta velocidad de descompresión)
Algoritmo de compresión LZ4
Sitio web oficial: https://lz4.github.io/lz4/
Yann Collet inventó el algoritmo de compresión LZ4 en 2011.
LZ4 es un algoritmo de compresión sin pérdidas que proporciona velocidades de compresión de > 500 MB/s (> 0,15 bytes/ciclo) por núcleo. Tiene un decodificador muy rápido, varios GB/s (~1 byte/ciclo) por núcleo. Está disponible un derivado de alta compresión llamado LZ4_HC, que intercambia tiempo de CPU personalizable por relación de compresión. La biblioteca LZ4 se proporciona como software de código abierto bajo la licencia BSD.
Ventajas de lz4
: La compresión/descompresión es muy rápida, unas 10 veces más rápida que gzip. Cuando lz4 garantiza una cierta tasa de compresión, es conocido por su velocidad de compresión invencible y su velocidad de descompresión más rápida .
Desventajas: En comparación con gzip, la versatilidad es ligeramente inferior
Resumen: lz4 es actualmente el algoritmo de compresión más eficiente, centrándose más en la velocidad de compresión y descompresión, y la relación de compresión no es la primera.
El sitio web oficial de lz4 proporciona un enlace a la operación de idioma lz4, en el que se rellena el Go Pierre Curto https://github.com/pierrec/lz4almacén .
escenarios de uso de lz4
lz4 es un algoritmo de compresión que "a todo el mundo le encanta y ve florecer las flores", que se puede extender bien en varios núcleos. lz4 es ligeramente inferior en tasa de compresión, pero tiene una ventaja sorprendente en la velocidad de descompresión (alrededor de 3 veces la de gzip (comparaciones de pruebas múltiples)). ¡Debido a la utilización eficiente de varios núcleos durante la compresión y la sorprendente descompresión, lz4 se ha utilizado en muchas ocasiones importantes! Para escenarios que requieren compresión frecuente y descompresión rápida en tiempo real, lz4 es muy adecuado ; el objeto descomprimido por lz4 es un archivo y no un directorio.
Instalación y uso de la herramienta de comando lz4
yum install -y lz4 lz4-devel
压缩 (默认解压之后的名称filename.lz4)
# lz4 filename
解压缩
# lz4 -d filename.lz4
centos7下默认有lz4_decompress 命令，可以直接解压, 并可以定义解压后的文件名
# lz4_decompress filename.lz4 filename
# lz4_decompress filename.lz4 filename.txt
explicación del parámetro lz4
lz4 --help
参数
-1: 快速压缩（默认）
-9: 高压缩
-d: 解压缩（默认为.lz4扩展名）
-z: 强制压缩
-f: 覆盖输出而不提示
-k: 保留源文件（默认）
--rm: 成功地解除/压缩后删除源文件
-h/-h: 显示帮助/长帮助和退出
高级参数
-v: 显示版本号并退出
-v: 详细模式
-q: 取消警告；指定两次也可以取消错误
-c: 强制写入标准输出，即使它是控制台
-t: 测试压缩文件完整性
-m: 多个输入文件（表示自动输出文件名）
-r: 在目录上递归操作（也设置为-m）
-l: 使用旧格式压缩（Linux内核压缩）
paquete pierrec/lz4
github: https://github.com/pierrec/lz4/
Este paquete proporciona una interfaz de transmisión para flujos de datos LZ4, así como funciones de compresión y descompresión de bajo nivel para bloques de datos LZ4. La implementación se basa en la referencia C. Este paquete proporciona una interfaz de transmisión para flujos
de datos LZ4 y bloques de datos LZ4. funciones subyacentes de compresión y descompresión. La implementación se basa en la referencia C.
demostración de código
Demostración oficial: leer bytecode y descomprimir
package lz4_test
import (
"fmt"
"io"
"os"
"strings"
"github.com/pierrec/lz4/v4"
)
func Example() {
// Compress and uncompress an input string.
s := "hello world"
r := strings.NewReader(s)
// The pipe will uncompress the data from the writer.
pr, pw := io.Pipe()
zw := lz4.NewWriter(pw)
zr := lz4.NewReader(pr)
go func() {
// Compress the input string.
_, _ = io.Copy(zw, r)
_ = zw.Close() // Make sure the writer is closed
_ = pw.Close() // Terminate the pipe
}()
_, _ = io.Copy(os.Stdout, zr)
// Output:
// hello world
}
func ExampleCompressBlock() {
s := "hello world"
data := []byte(strings.Repeat(s, 100))
buf := make([]byte, lz4.CompressBlockBound(len(data)))
var c lz4.Compressor
n, err := c.CompressBlock(data, buf)
if err != nil {
fmt.Println(err)
}
if n >= len(data) {
fmt.Printf("`%s` is not compressible", s)
}
buf = buf[:n] // compressed data
// Allocate a very large buffer for decompression.
out := make([]byte, 10*len(data))
n, err = lz4.UncompressBlock(buf, out)
if err != nil {
fmt.Println(err)
}
out = out[:n] // uncompressed data
fmt.Println(string(out[:len(s)]))
// Output:
// hello world
}
Resumen: Golang descomprime bytes comprimidos lz4, y el núcleo es usar la función oficial UncompressBlock.
UncompressBlock descomprime el búfer de origen al búfer de destino y devuelve el tamaño sin comprimir. El tamaño del búfer de destino debe ser adecuado. Devuelve un error si los datos de origen no son válidos o el búfer de destino es demasiado pequeño.
Al usar datos de bytes que no son datos comprimidos lz4, obtendrá un error cuando los descomprima: lz4errors.Error=lz4: invalid source or destination buffer too short
// UncompressBlock uncompresses the source buffer into the destination one,
// and returns the uncompressed size.
//
// The destination buffer must be sized appropriately.
//
// An error is returned if the source data is invalid or the destination buffer is too small.
func UncompressBlock(src, dst []byte) (int, error) {
return lz4block.UncompressBlock(src, dst, nil)
}
Referirse a
¿Qué hay de la relación de velocidad y compresión? Optimización del algoritmo de compresión en construcción e implementación
URL de referencia: https://tech.meituan.com/2021/01/07/pack-gzip-zstd-lz4.html
Speed King — Algoritmo de compresión LZ4 (1)
URL de referencia: https ://www.cnblogs.com/aiwz/p/6333317.html