常见压缩算法性能和压缩率对比 LZ4 LZO ZSTD SNAPPY

news2025/6/2 2:31:36

网传压缩算法对比表

算法压缩率压缩速度解压速度支持流式压缩适用场景
LZ4低极快极快是实时数据压缩、日志压缩、内存缓存等
Zstandard高快快是文件压缩、网络传输、数据库备份等
Brotli很高中等快是静态资源压缩（HTML、CSS、JS）等
LZO低极快快是嵌入式系统、实时数据压缩
Snappy中等快快否日志压缩、内存缓存、网络传输

性能实测

在这里插入图片描述

./compress_test syslog.txt

LZ4 0 comp:   64.669 ms  decom:   15.282 ms  Size: 85.906 MB  Ratio: 17.186 %
LZ4 1 comp:   65.662 ms  decom:   15.046 ms  Size: 85.906 MB  Ratio: 17.186 %
LZO 0 comp:   65.834 ms  decom:   51.929 ms  Size: 85.906 MB  Ratio: 17.936 %
LZO 1 comp:   61.834 ms  decom:   50.462 ms  Size: 85.906 MB  Ratio: 17.936 %
Zstd 0 comp:   71.713 ms  decom:   31.642 ms  Size: 85.906 MB  Ratio: 9.230 %
Zstd 1 comp:   93.255 ms  decom:   47.457 ms  Size: 85.906 MB  Ratio: 9.230 %
Brotli 0 comp:  156.201 ms  decom:  115.879 ms  Size: 85.906 MB  Ratio: 13.189 %
Brotli 1 comp:  127.775 ms  decom:  104.258 ms  Size: 85.906 MB  Ratio: 13.189 %
Snappy 0 comp:   84.727 ms  decom:   52.499 ms  Size: 85.906 MB  Ratio: 18.220 %
Snappy 1 comp:   82.503 ms  decom:   52.898 ms  Size: 85.906 MB  Ratio: 18.220 %

对于一个系统日志文件，LZ4 LZO速度最快， 压缩率zstd遥遥领先，综合性价比 Zstd完胜。

安装与使用

LZ4

编译

git clone https://github.com/lz4/lz4.git
cd lz4
make

使用

ckun@DESKTOP-PODAH1A:~/ws/compress/test$ rm -f log.lz4
ckun@DESKTOP-PODAH1A:~/ws/compress/test$ time ./lz4 syslog -T1 log.lz4
Compressed 3290808339 bytes into 567183342 bytes ==> 17.24%

real    0m5.855s
user    0m4.636s
sys     0m1.910s

Zstd

git clone https://github.com/facebook/zstd.git
cd zstd
make

Brotli

git clone https://github.com/google/brotli.git
cd brotli

mkdir build
cd build
cmake -DCMAKE_BUILD_TYPE=Release ..
make

LZO

wget http://www.oberhumer.com/opensource/lzo/download/lzo-2.10.tar.gz
tar -xvzf lzo-2.10.tar.gz
cd lzo-2.10
mkdir build
cd build
cmake -DENABLE_SHARED=ON ..
make

Snappy

git clone https://github.com/google/snappy.git
cd snappy
git submodule update --init
mkdir build
cd build 
cmake ..
make

测试程序


#include <iostream>
#include <fstream>
#include <vector>
#include <chrono>
#include <cstring>
#include <lz4.h>
#include <lzo/lzo1x.h>
#include <zstd.h>
#include <brotli/encode.h>
#include <brotli/decode.h>
#include <snappy.h>

#include <iomanip> 
// Helper function to calculate checksum (simple Adler-32 implementation)
uint32_t calculate_checksum(const std::vector<char>& data) {
    uint32_t a = 1, b = 0;
    for (char c : data) {
        a = (a + static_cast<uint8_t>(c)) % 65521;
        b = (b + a) % 65521;
    }
    return (b << 16) | a;
}

// Read file into memory
std::vector<char> read_file(const std::string& filename) {
    std::ifstream file(filename, std::ios::binary | std::ios::ate);
    if (!file) {
        throw std::runtime_error("Failed to open file: " + filename);
    }
    std::streamsize size = file.tellg();
    file.seekg(0, std::ios::beg);

    std::vector<char> buffer(size);
    if (!file.read(buffer.data(), size)) {
        throw std::runtime_error("Failed to read file: " + filename);
    }
    return buffer;
}

// Test LZ4 compression and decompression
void test_lz4(const std::vector<char>& input, int i) {
    //std::cout << "Testing LZ4..." << std::endl;

    // Allocate buffers
    int max_compressed_size = LZ4_compressBound(input.size());
    std::vector<char> compressed(max_compressed_size);
    std::vector<char> decompressed(input.size());

    // Compress
    auto start = std::chrono::high_resolution_clock::now();
    int compressed_size = LZ4_compress_default(input.data(), compressed.data(), input.size(), max_compressed_size);
    auto end = std::chrono::high_resolution_clock::now();
    if (compressed_size <= 0) {
        throw std::runtime_error("LZ4 compression failed");
    }
    auto compression_time = std::chrono::duration_cast<std::chrono::microseconds>(end - start).count();

    // Decompress
    start = std::chrono::high_resolution_clock::now();
    int decompressed_size = LZ4_decompress_safe(compressed.data(), decompressed.data(), compressed_size, decompressed.size());
    end = std::chrono::high_resolution_clock::now();
    if (decompressed_size != input.size()) {
        throw std::runtime_error("LZ4 decompression failed");
    }
    auto decompression_time = std::chrono::duration_cast<std::chrono::microseconds>(end - start).count();

    // Verify checksum
    uint32_t original_checksum = calculate_checksum(input);
    uint32_t decompressed_checksum = calculate_checksum(decompressed);
    if (original_checksum != decompressed_checksum) {
        throw std::runtime_error("LZ4 checksum mismatch");
    }

    // Output results
    printf("LZ4 %d comp: %8.3lf ms  decom: %8.3lf ms  Size: %.3f MB  Ratio: %.3f %%\n",
           i, (compression_time / 1000.0), (decompression_time / 1000.0),
           (input.size() / (1024.0 * 1024.0)),
           (double) (static_cast<double>(compressed_size) / input.size()) * 100);
}

// Test LZO compression and decompression
void test_lzo(const std::vector<char>& input, int i) {
    //std::cout << "Testing LZO..." << std::endl;

    // Initialize LZO
    if (lzo_init() != LZO_E_OK) {
        throw std::runtime_error("LZO initialization failed");
    }

    // Allocate buffers
    std::vector<char> compressed(input.size() + input.size() / 16 + 64 + 3);
    std::vector<char> decompressed(input.size());
    std::vector<unsigned char> wrkmem(LZO1X_1_MEM_COMPRESS);

    // Compress
    auto start = std::chrono::high_resolution_clock::now();
    lzo_uint compressed_size;
    int r = lzo1x_1_compress(reinterpret_cast<const unsigned char*>(input.data()), input.size(),
                             reinterpret_cast<unsigned char*>(compressed.data()), &compressed_size, wrkmem.data());
    auto end = std::chrono::high_resolution_clock::now();
    if (r != LZO_E_OK) {
        throw std::runtime_error("LZO compression failed");
    }
    auto compression_time = std::chrono::duration_cast<std::chrono::microseconds>(end - start).count();

    // Decompress
    start = std::chrono::high_resolution_clock::now();
    lzo_uint decompressed_size;
    r = lzo1x_decompress(reinterpret_cast<const unsigned char*>(compressed.data()), compressed_size,
                         reinterpret_cast<unsigned char*>(decompressed.data()), &decompressed_size, nullptr);
    end = std::chrono::high_resolution_clock::now();
    if (r != LZO_E_OK || decompressed_size != input.size()) {
        throw std::runtime_error("LZO decompression failed");
    }
    auto decompression_time = std::chrono::duration_cast<std::chrono::microseconds>(end - start).count();

    // Verify checksum
    uint32_t original_checksum = calculate_checksum(input);
    uint32_t decompressed_checksum = calculate_checksum(decompressed);
    if (original_checksum != decompressed_checksum) {
        throw std::runtime_error("LZO checksum mismatch");
    }

    // Output results
    // std::cout << "LZO " << i << " ";
    // std::cout << "comp: " << (compression_time / 1000.0) << " ms  "
    //           << "decom: " << (decompression_time / 1000.0) << " ms  "
    //           << "Size: " << (input.size() / (1024.0 * 1024.0)) << " MB  "
    //           << "Ratio: " << (static_cast<double>(compressed_size) / input.size()) * 100 << " %" 
    //           << std::endl;
    printf("LZO %d comp: %8.3lf ms  decom: %8.3lf ms  Size: %.3f MB  Ratio: %.3f %%\n",
           i, (compression_time / 1000.0), (decompression_time / 1000.0),
           (input.size() / (1024.0 * 1024.0)),
           (double) (static_cast<double>(compressed_size) / input.size()) * 100);
}

void test_zstd(const std::vector<char>& input, int i) {
    // Allocate buffers
    size_t max_compressed_size = ZSTD_compressBound(input.size());
    std::vector<char> compressed(max_compressed_size);
    std::vector<char> decompressed(input.size());

    // Compress
    auto start = std::chrono::high_resolution_clock::now();
    size_t compressed_size = ZSTD_compress(compressed.data(), max_compressed_size, input.data(), input.size(), 1);
    auto end = std::chrono::high_resolution_clock::now();
    if (ZSTD_isError(compressed_size)) {
        throw std::runtime_error("Zstd compression failed: " + std::string(ZSTD_getErrorName(compressed_size)));
    }
    auto compression_time = std::chrono::duration_cast<std::chrono::microseconds>(end - start).count();

    // Decompress
    start = std::chrono::high_resolution_clock::now();
    size_t decompressed_size = ZSTD_decompress(decompressed.data(), decompressed.size(), compressed.data(), compressed_size);
    end = std::chrono::high_resolution_clock::now();
    if (ZSTD_isError(decompressed_size) || decompressed_size != input.size()) {
        throw std::runtime_error("Zstd decompression failed: " + std::string(ZSTD_getErrorName(decompressed_size)));
    }
    auto decompression_time = std::chrono::duration_cast<std::chrono::microseconds>(end - start).count();

    // Verify checksum
    uint32_t original_checksum = calculate_checksum(input);
    uint32_t decompressed_checksum = calculate_checksum(decompressed);
    if (original_checksum != decompressed_checksum) {
        throw std::runtime_error("Zstd checksum mismatch");
    }

    // Output results
    printf("Zstd %d comp: %8.3lf ms  decom: %8.3lf ms  Size: %.3f MB  Ratio: %.3f %%\n",
           i, (compression_time / 1000.0), (decompression_time / 1000.0),
           (input.size() / (1024.0 * 1024.0)),
           (double) (static_cast<double>(compressed_size) / input.size()) * 100);
}

void test_brotli(const std::vector<char>& input, int i) {
    // Allocate buffers
    size_t max_compressed_size = BrotliEncoderMaxCompressedSize(input.size());
    std::vector<uint8_t> compressed(max_compressed_size);
    std::vector<uint8_t> decompressed(input.size());

    // Compress
    auto start = std::chrono::high_resolution_clock::now();
    size_t compressed_size = max_compressed_size;
    if (!BrotliEncoderCompress(
            0, BROTLI_DEFAULT_WINDOW, BROTLI_MODE_GENERIC,
            input.size(), reinterpret_cast<const uint8_t*>(input.data()),
            &compressed_size, compressed.data())) {
        throw std::runtime_error("Brotli compression failed");
    }
    auto end = std::chrono::high_resolution_clock::now();
    auto compression_time = std::chrono::duration_cast<std::chrono::microseconds>(end - start).count();

    // Decompress
    start = std::chrono::high_resolution_clock::now();
    size_t decompressed_size = decompressed.size();
    if (BrotliDecoderDecompress(
            compressed_size, compressed.data(),
            &decompressed_size, decompressed.data()) != BROTLI_DECODER_RESULT_SUCCESS) {
        throw std::runtime_error("Brotli decompression failed");
    }
    end = std::chrono::high_resolution_clock::now();
    auto decompression_time = std::chrono::duration_cast<std::chrono::microseconds>(end - start).count();

    // Verify checksum
    uint32_t original_checksum = calculate_checksum(input);
    uint32_t decompressed_checksum = calculate_checksum(std::vector<char>(decompressed.begin(), decompressed.end()));
    if (original_checksum != decompressed_checksum) {
        throw std::runtime_error("Brotli checksum mismatch");
    }

    // Output results
    printf("Brotli %d comp: %8.3lf ms  decom: %8.3lf ms  Size: %.3f MB  Ratio: %.3f %%\n",
           i, (compression_time / 1000.0), (decompression_time / 1000.0),
           (input.size() / (1024.0 * 1024.0)),
           (double) (static_cast<double>(compressed_size) / input.size()) * 100);
}

void test_snappy(const std::vector<char>& input, int i) {
    // Allocate buffers
    std::string compressed;
    std::string decompressed;

    // Compress
    auto start = std::chrono::high_resolution_clock::now();
    snappy::Compress(input.data(), input.size(), &compressed);
    auto end = std::chrono::high_resolution_clock::now();
    auto compression_time = std::chrono::duration_cast<std::chrono::microseconds>(end - start).count();

    // Decompress
    start = std::chrono::high_resolution_clock::now();
    if (!snappy::Uncompress(compressed.data(), compressed.size(), &decompressed)) {
        throw std::runtime_error("Snappy decompression failed");
    }
    end = std::chrono::high_resolution_clock::now();
    auto decompression_time = std::chrono::duration_cast<std::chrono::microseconds>(end - start).count();

    // Verify checksum
    uint32_t original_checksum = calculate_checksum(input);
    uint32_t decompressed_checksum = calculate_checksum(std::vector<char>(decompressed.begin(), decompressed.end()));
    if (original_checksum != decompressed_checksum) {
        throw std::runtime_error("Snappy checksum mismatch");
    }

    // Output results
    printf("Snappy %d comp: %8.3lf ms  decom: %8.3lf ms  Size: %.3f MB  Ratio: %.3f %%\n",
           i, (compression_time / 1000.0), (decompression_time / 1000.0),
           (input.size() / (1024.0 * 1024.0)),
           (double) (static_cast<double>(compressed.size()) / input.size()) * 100);
}

template <typename Func>
void run_test(Func func, const std::vector<char>& input, int times) {
    for (int i = 0; i < times; ++i) {
        func(input, i);
    }
}

int main(int argc, char* argv[]) {
    if (argc != 2) {
        std::cerr << "Usage: " << argv[0] << " <file>" << std::endl;
        return 1;
    }
    std::cout << std::fixed << std::setprecision(3); 
    try {
        // Read file into memory
        std::vector<char> input = read_file(argv[1]);

        // Calculate checksum
        uint32_t checksum = calculate_checksum(input);
        std::cout << "Original Checksum: " << checksum << std::endl;

        // Test LZ4
        run_test(test_lz4, input, 2);
        // Test LZO
        run_test(test_lzo, input, 2);

        run_test(test_zstd, input, 2);

        // Test Brotli
        run_test(test_brotli, input, 2);

        // Test Snappy
        run_test(test_snappy, input, 2);

    } catch (const std::exception& e) {
        std::cerr << "Error: " << e.what() << std::endl;
        return 1;
    }

    return 0;
}

Makefile

TARGET = compress_test

SRCS = $(wildcard *.cpp)

CC = g++

CFLAGS += -g -O2 -I../lz4/lib -I../lzo-2.10/include -I../zstd/lib \
		  -I../brotli/c/include -I../snappy 

LDFLAGS += -lyaml-cpp  -L../lz4/lib -llz4 \
		   -L../lzo-2.10/build -llzo2 -lz \
		   -L../zstd/lib -lzstd \
		   -L../brotli/build -lbrotlicommon -lbrotlidec -lbrotlienc \
		   -L../snappy/build -lsnappy
all: $(TARGET)

$(TARGET): $(SRCS)
	$(CC) $(CFLAGS) $(SRCS) -o $@ $(LDFLAGS)

.PHONY: clean
clean:
	rm $(TARGET)

运行

export LD_LIBRARY_PATH=../lz4/lib:../lzo-2.10/build:../zstd/lib:../brotli/build/:../snappy/build

$ ldd compress_test
        linux-vdso.so.1 (0x00007ffdb71cf000)
        liblz4.so.1 => ../lz4/lib/liblz4.so.1 (0x00007fc26045a000)
        liblzo2.so.2 => ../lzo-2.10/build/liblzo2.so.2 (0x00007fc260427000)
        libzstd.so.1 => ../zstd/lib/libzstd.so.1 (0x00007fc260330000)
        libbrotlidec.so.1 => ../brotli/build/libbrotlidec.so.1 (0x00007fc260321000)
        libbrotlienc.so.1 => ../brotli/build/libbrotlienc.so.1 (0x00007fc260268000)
        libsnappy.so.1 => ../snappy/build/libsnappy.so.1 (0x00007fc260259000)
        libstdc++.so.6 => /lib/x86_64-linux-gnu/libstdc++.so.6 (0x00007fc260026000)
        libgcc_s.so.1 => /lib/x86_64-linux-gnu/libgcc_s.so.1 (0x00007fc260006000)
        libc.so.6 => /lib/x86_64-linux-gnu/libc.so.6 (0x00007fc25fddd000)
        libbrotlicommon.so.1 => ../brotli/build/libbrotlicommon.so.1 (0x00007fc25fdb7000)
        libm.so.6 => /lib/x86_64-linux-gnu/libm.so.6 (0x00007fc25fcd0000)
        /lib64/ld-linux-x86-64.so.2 (0x00007fc260498000)

./compress_test file

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/2393413.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

Spring Boot 应用中实现配置文件敏感信息加密解密方案

Spring Boot 应用中实现配置文件敏感信息加密解密方案

Spring Boot 应用中实现配置文件敏感信息加密解密方案 背景与挑战 &#x1f6a9;一、设计目标 &#x1f3af;二、整体启动流程 &#x1f504;三、方案实现详解 ⚙️3.1 配置解密入口&#xff1a;EnvironmentPostProcessor3.2 通用解密工具类&#xff1a;EncryptionTool 四、快速…
阅读更多...
【TTS】基于GRPO的流匹配文本到语音改进：F5R-TTS

【TTS】基于GRPO的流匹配文本到语音改进：F5R-TTS

论文地址&#xff1a;https://arxiv.org/abs/2504.02407v3 摘要 我们提出了F5R-TTS&#xff0c;这是一种新颖的文本到语音(TTS)系统&#xff0c;它将群体相对策略优化(GRPO)集成到基于流匹配的架构中。 通过将流匹配TTS的确定性输出重新表述为概率高斯分布&#xff0c;我们的方…
阅读更多...
动态规划-152.乘积最大子数组-力扣(LeetCode)

动态规划-152.乘积最大子数组-力扣(LeetCode)

一、题目解析 根据示例nums数组中存在负数&#xff0c;下面分析时需注意 二、算法原理 1、状态表示 此时f[i]表示&#xff1a;以i位置为结尾的所有子数组中的最大乘积&#xff0c;但是由于nums中存在负数&#xff0c;所以还需要g[i]表示&#xff1a;以i位置为结尾的所有子数组…
阅读更多...
1-1 初探Dart编程语言

1-1 初探Dart编程语言

Dart 是 Google 最初开发的一种开源编程语言&#xff0c;适用于客户端与服务端开发。它配套提供 Dart SDK&#xff0c;其中包含 Dart 编译器、Dart 虚拟机&#xff08;Dart VM&#xff09;以及一个名为 dart2js 的工具&#xff0c;可将 Dart 脚本转换为 JavaScript&#xff0c;…
阅读更多...
搭建最新版开源监控平台SigNoz踩的坑

搭建最新版开源监控平台SigNoz踩的坑

转载说明&#xff1a;如果您喜欢这篇文章并打算转载它&#xff0c;请私信作者取得授权并注明出处。感谢您喜爱本文&#xff0c;请文明转载&#xff0c;谢谢。 一、前言 SigNoz 是一款开源应用程序性能监控工具&#xff0c;在往期相关文章&#xff08;文末有链接&#xff09;中…
阅读更多...
无人机多人协同控制技术解析

无人机多人协同控制技术解析

一、运行方式 无人机多人点对点控制通常采用以下两种模式&#xff1a; 1. 主从控制模式 指定一个主控用户拥有最高优先级&#xff0c;负责飞行路径规划、紧急操作等关键指令&#xff1b;其他用户作为观察者&#xff0c;仅能查看实时画面或提交辅助指令&#xff0c;需经主…
阅读更多...
【东枫科技】KrakenSDR 测向快速入门指南

【东枫科技】KrakenSDR 测向快速入门指南

本快速入门指南旨在帮助您使用运行在 Raspberry Pi 4/5 或 Orange Pi 5B (OPI5B)&#xff08;带 WiFi 型号&#xff09;上的 KrakenSDR 尽快连接到测向应用程序。不过&#xff0c;请务必阅读本手册的其余部分&#xff0c;以了解无线电测向的工作原理。 你需要什么 本指南假设…
阅读更多...
【Redis】hash

【Redis】hash

Hash 哈希 几乎所有的主流编程语言都提供了哈希&#xff08;hash&#xff09;类型&#xff0c;它们的叫法可能是哈希、字典、关联数组、映射等。在 Redis 中&#xff0c;哈希类型指值本身又是一个键值对结构&#xff0c;形如 key “key”, value {{field1, value1}, …{field…
阅读更多...
基于Vite的前端自动化部署方案

基于Vite的前端自动化部署方案

&#x1f468; 作者简介&#xff1a;大家好&#xff0c;我是Taro&#xff0c;全栈领域创作者 ✒️ 个人主页&#xff1a;唐璜Taro &#x1f680; 支持我&#xff1a;点赞&#x1f44d;&#x1f4dd; 评论 ⭐️收藏 文章目录 前言一、主流解决方案二、了解SCP概念三、自动化部署…
阅读更多...
antDesignVue中a-upload上传组件的使用

antDesignVue中a-upload上传组件的使用

工作中需要使用上传组件&#xff0c;记录一下a-upload部分属性用法 1.showUploadList属性使用 使用:showUploadList"{ showRemoveIcon: true ,showDownloadIcon: true }"属性可控制右侧下载&#xff0c;删除图标 2.如何实现回显功能 使用:defaultFileList"fil…
阅读更多...
龙舟竞渡与芯片制造的共通逻辑：华芯邦的文化破局之道

龙舟竞渡与芯片制造的共通逻辑：华芯邦的文化破局之道

端午节承载着中华民族数千年的精神密码&#xff0c;龙舟最初是古人沟通天地、祈求风调雨顺的仪式载体。战国时期&#xff0c;屈原投江的悲壮故事为端午注入了家国情怀&#xff0c;龙舟竞渡从此兼具纪念英雄与祈福避疫的双重意义。这种文化内核&#xff0c;与深圳市华芯邦“以科…
阅读更多...
机房网络设备操作安全管理制度

机房网络设备操作安全管理制度

该制度围绕机房网络设备操作安全，规定账号实行系统管理员、操作管理员、一般用户三级分级管理，遵循最小授权和权限分割原则，账号需实名制、禁止共享及转借，密码设置需至少 8 位、3 种字符组合且每 3 个月修改一次；高危指令执行需上级审批、双人核查，远程登录需限制权限、…
阅读更多...
Milvus分区-分片-段结构详解与最佳实践

Milvus分区-分片-段结构详解与最佳实践

导读&#xff1a;在构建大规模向量数据库应用时&#xff0c;数据组织架构的设计往往决定了系统的性能上限。Milvus作为主流向量数据库&#xff0c;其独特的三层架构设计——分区、分片、段&#xff0c;为海量向量数据的高效存储和检索提供了坚实基础。 本文通过图书馆管理系统的…
阅读更多...
5月课程精彩回顾 | 2025高通边缘智能创新应用大赛系列公开课

5月课程精彩回顾 | 2025高通边缘智能创新应用大赛系列公开课

当边缘计算与人工智能的碰撞掀起技术革命浪潮&#xff0c;如何抢占创新先机&#xff1f;2025高通边缘智能创新应用大赛以行业顶尖资源赋能开发者&#xff0c;在初赛阶段重磅打造系列公开课。 5月13日至29日&#xff0c;大赛主办方高通技术公司携手承办方阿加犀&#xff0c;以及…
阅读更多...
设计模式25——中介者模式

设计模式25——中介者模式

写文章的初心主要是用来帮助自己快速的回忆这个模式该怎么用&#xff0c;主要是下面的UML图可以起到大作用&#xff0c;在你学习过一遍以后可能会遗忘&#xff0c;忘记了不要紧&#xff0c;只要看一眼UML图就能想起来了。同时也请大家多多指教。 中介者模式&#xff08;Mediat…
阅读更多...
阿里云配置安全组策略开放端口

阿里云配置安全组策略开放端口

目录 1. 测试端口是否开放 1.1 测试程序 1.2 测试工具 2. 阿里云安全组开放端口 3. 测试开放之后是否能访问 1. 测试端口是否开放 1.1 测试程序 Linux: This repository is specifically designed to store Linux code - Gitee.comhttps://gitee.com/Axurea/linux/tree/…
阅读更多...
uniapp 搭配uviwe u-picker 实现地区联栋

uniapp 搭配uviwe u-picker 实现地区联栋

原始数据&#xff1a; ["id": 2,"createTime": null,"updateTime": null,"citycode": null,"adcode": "410000","cityName": "河南省","level": "province","cent…
阅读更多...
win10电脑时间同步失败的解决方法

win10电脑时间同步失败的解决方法

win10电脑时间同步失败 问题如下&#xff1a; 解决方法如下: 搜索里搜索:控制面板&#xff0c;然后选择时钟和区域 ![在这里插入图片描述](https://i-blog.csdnimg.cn/direct/d734b28553514f6699d559d4218e5e99.png 此处输入:ntp.aliyun.com 然后时间就同步完成了~ 可以…
阅读更多...
代码随想录打卡|Day53 图论（Floyd 算法精讲 、A * 算法精讲 （A star算法）、最短路算法总结篇、图论总结 ）

代码随想录打卡|Day53 图论（Floyd 算法精讲 、A * 算法精讲 （A star算法）、最短路算法总结篇、图论总结 ）

图论part11 Floyd 算法精讲 代码随想录链接 题目链接 代码 三维DP数组 import java.util.Scanner;public class Main {// 定义最大距离值&#xff0c;避免使用Integer.MAX_VALUE防止加法溢出public static final int INF 100000000; // 10^8足够大且不会溢出public static…
阅读更多...
yum安装nginx后无法通过服务方式启动

yum安装nginx后无法通过服务方式启动

背景 在linux系统下&#xff0c;通过yum方式安装nginx后 通过nginx命令 nginx 可以启动nginx 但是作为测试或者生产服务器&#xff0c;我们需要配置开机自启动&#xff0c;这时候需要用服务方式启动 yum安装后的nginx 已经默认生成了服务启动方式的 nginx.service文件 按…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023