团队 code review 时，一位同事把 count(*)改成了 count(1)，说这样性能更好。真的是这样吗？今天通过源码和实测数据，把这个问题说透。

本文基于 MySQL 8.0.28 版本测试，不同版本的优化器行为可能有差异

三种 count 方式的本质区别

先看看这三种写法在 MySQL 中到底做了什么：

// 模拟MySQL处理count的伪代码
public class CountProcessor {


    // count(*) 的处理逻辑
    public long countStar(Table table) {
        long count = 0;
        for (Row row : table.getAllRows()) {
            // 只要行存在就计数，不管字段值
            count++;
        }
        return count;
    }


    // count(1) 的处理逻辑
    public long countOne(Table table) {
        long count = 0;
        for (Row row : table.getAllRows()) {
            // MySQL优化器会把count(1)转换为count(*)
            count++;
        }
        return count;
    }


    // count(字段) 的处理逻辑
    public long countField(Table table, String fieldName) {
        long count = 0;
        for (Row row : table.getAllRows()) {
            Object value = row.getField(fieldName);
            // 关键：只统计非NULL值
            if (value != null) {
                count++;
            }
        }
        return count;
    }
}

性能测试：用数据说话

创建测试环境，准备 1000 万条数据，多轮测试取平均值：

@Slf4j
@SpringBootTest
@TestPropertySource(properties = {
    "spring.datasource.hikari.maximum-pool-size=5",
    "spring.datasource.hikari.minimum-idle=1"
})
public class CountPerformanceTest {


    private static final DecimalFormat df = new DecimalFormat("#.##");


    @Autowired
    private JdbcTemplate jdbcTemplate;


    @Autowired
    private PlatformTransactionManager transactionManager;


    @BeforeEach
    @Transactional(propagation = Propagation.REQUIRES_NEW)
    public void setupTestData() {
        try {
            // 创建测试表
            jdbcTemplate.execute("""
                CREATE TABLE IF NOT EXISTS user_test (
                    id BIGINT PRIMARY KEY AUTO_INCREMENT,
                    username VARCHAR(50) NOT NULL,
                    email VARCHAR(100),
                    age INT,
                    city VARCHAR(50),
                    create_time TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
                    INDEX idx_username (username),
                    INDEX idx_email (email),
                    INDEX idx_city (city)
                ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4
            """);


            // 使用事务批量插入
            TransactionTemplate transactionTemplate = new TransactionTemplate(transactionManager);
            transactionTemplate.execute(status -> {
                insertTestDataInBatches();
                return null;
            });


            // 更新统计信息
            jdbcTemplate.execute("ANALYZE TABLE user_test");
            log.info("测试数据准备完成，表统计信息已更新");


        } catch (Exception e) {
            log.error("准备测试数据失败", e);
            throw new RuntimeException("测试数据初始化失败", e);
        }
    }


    private void insertTestDataInBatches() {
        List<Object[]> batchArgs = new ArrayList<>();
        String[] cities = {"北京", "上海", "广州", "深圳", "杭州"};


        for (int i = 1; i <= 10_000_000; i++) {
            String username = "user_" + i;
            String email = (i % 10 == 0) ? null : "user" + i + "@test.com";
            Integer age = (i % 20 == 0) ? null : 20 + (i % 50);
            String city = (i % 15 == 0) ? null : cities[i % cities.length];


            batchArgs.add(new Object[]{username, email, age, city});


            if (i % 10000 == 0) {
                jdbcTemplate.batchUpdate(
                    "INSERT INTO user_test (username, email, age, city) VALUES (?, ?, ?, ?)",
                    batchArgs
                );
                batchArgs.clear();
                if (i % 100000 == 0) {
                    log.info("已插入 {} 条数据", i);
                }
            }
        }
    }


    @Test
    public void testCountPerformance() {
        StopWatch stopWatch = new StopWatch("COUNT性能测试");
        try {
            warmUp();


            // 多次测试取平均值
            int testRounds = 5;
            Map<String, List<Long>> timings = new HashMap<>();


            for (int round = 0; round < testRounds; round++) {
                log.info("===== 第 {} 轮测试 =====", round + 1);
                performSingleRound(stopWatch, timings, round + 1);


                // 轮次间隔，避免缓存影响
                Thread.sleep(1000);
            }


            // 计算并输出平均值
            logAverageTimings(timings);


        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            log.error("测试被中断", e);
        } finally {
            if (stopWatch.isRunning()) {
                stopWatch.stop();
            }
            log.info("性能测试总结:\n{}", stopWatch.prettyPrint());
        }
    }


    private void performSingleRound(StopWatch stopWatch, Map<String, List<Long>> timings, int round) {
        // 测试count(*)
        stopWatch.start("COUNT(*) - Round " + round);
        Long countStar = jdbcTemplate.queryForObject("SELECT COUNT(*) FROM user_test", Long.class);
        stopWatch.stop();
        long time = stopWatch.getLastTaskTimeMillis();
        timings.computeIfAbsent("COUNT(*)", k -> new ArrayList<>()).add(time);
        log.info("COUNT(*) 结果: {}, 耗时: {} ms", countStar != null ? countStar : "null", time);


        // 测试count(1)
        stopWatch.start("COUNT(1) - Round " + round);
        Long countOne = jdbcTemplate.queryForObject("SELECT COUNT(1) FROM user_test", Long.class);
        stopWatch.stop();
        time = stopWatch.getLastTaskTimeMillis();
        timings.computeIfAbsent("COUNT(1)", k -> new ArrayList<>()).add(time);
        log.info("COUNT(1) 结果: {}, 耗时: {} ms", countOne != null ? countOne : "null", time);


        // 测试count(主键)
        stopWatch.start("COUNT(id) - Round " + round);
        Long countId = jdbcTemplate.queryForObject("SELECT COUNT(id) FROM user_test", Long.class);
        stopWatch.stop();
        time = stopWatch.getLastTaskTimeMillis();
        timings.computeIfAbsent("COUNT(id)", k -> new ArrayList<>()).add(time);
        log.info("COUNT(id) 结果: {}, 耗时: {} ms", countId != null ? countId : "null", time);


        // 测试count(索引列)
        stopWatch.start("COUNT(username) - Round " + round);
        Long countUsername = jdbcTemplate.queryForObject("SELECT COUNT(username) FROM user_test", Long.class);
        stopWatch.stop();
        time = stopWatch.getLastTaskTimeMillis();
        timings.computeIfAbsent("COUNT(username)", k -> new ArrayList<>()).add(time);
        log.info("COUNT(username) 结果: {}, 耗时: {} ms", countUsername != null ? countUsername : "null", time);


        // 测试count(非索引列)
        stopWatch.start("COUNT(age) - Round " + round);
        Long countAge = jdbcTemplate.queryForObject("SELECT COUNT(age) FROM user_test", Long.class);
        stopWatch.stop();
        time = stopWatch.getLastTaskTimeMillis();
        timings.computeIfAbsent("COUNT(age)", k -> new ArrayList<>()).add(time);
        log.info("COUNT(age) 结果: {}, 耗时: {} ms", countAge != null ? countAge : "null", time);
    }


    private void logAverageTimings(Map<String, List<Long>> timings) {
        log.info("\n===== 性能测试平均值 =====");
        timings.forEach((query, times) -> {
            double average = times.stream()
                .mapToLong(Long::longValue)
                .average()
                .orElse(0.0);
            log.info("{} 平均耗时: {} ms", query, df.format(average));
        });
    }


    private void warmUp() {
        log.info("开始预热查询...");
        for (int i = 0; i < 5; i++) {
            jdbcTemplate.queryForObject("SELECT COUNT(*) FROM user_test", Long.class);
        }
    }


    @AfterEach
    public void cleanup() {
        try {
            jdbcTemplate.execute("DROP TABLE IF EXISTS user_test");
            log.info("测试表清理完成");
        } catch (Exception e) {
            log.error("清理测试数据失败", e);
        }
    }
}

结论：COUNT(*)和 COUNT(1)性能基本一致，COUNT(非索引列)性能最差。

存储引擎差异与索引统计

不同存储引擎对 COUNT 的处理方式差异很大：

@Component
@Slf4j
public class StorageEngineCountAnalyzer {


    @Autowired
    private JdbcTemplate jdbcTemplate;


    public void analyzeEngineSpecificBehavior() {
        // 查看表的存储引擎和统计信息
        String engineQuery = """
            SELECT
                t.table_name,
                t.engine,
                t.table_rows,
                t.avg_row_length,
                t.data_length,
                t.index_length
            FROM information_schema.tables t
            WHERE t.table_schema = DATABASE()
            AND t.table_name IN ('users', 'orders', 'products')
        """;


        List<Map<String, Object>> results = jdbcTemplate.queryForList(engineQuery);


        results.forEach(row -> {
            String tableName = (String) row.get("table_name");
            String engine = (String) row.get("engine");
            Long approximateRows = (Long) row.get("table_rows");


            log.info("表: {}, 引擎: {}, 近似行数: {}", tableName, engine, approximateRows);


            // 不同引擎的COUNT行为
            switch (engine) {
                case "MyISAM":
                    log.info("MyISAM引擎维护了准确的行数，COUNT(*)是O(1)操作");
                    break;
                case "InnoDB":
                    log.info("InnoDB引擎需要扫描索引统计行数，COUNT(*)是O(n)操作");
                    updateIndexStatistics(tableName);
                    break;
                case "Memory":
                    log.info("Memory引擎类似MyISAM，维护行数元数据");
                    break;
            }
        });
    }


    /**
     * 更新表的索引统计信息
     */
    public void updateIndexStatistics(String tableName) {
        try {
            // 更新索引统计信息
            jdbcTemplate.execute("ANALYZE TABLE " + tableName);


            // 查看索引基数和选择性
            String sql = """
                SELECT
                    s.index_name,
                    s.cardinality,
                    t.table_rows,
                    ROUND((s.cardinality / t.table_rows * 100), 2) as selectivity_percent
                FROM information_schema.statistics s
                JOIN information_schema.tables t
                    ON s.table_schema = t.table_schema
                    AND s.table_name = t.table_name
                WHERE s.table_schema = DATABASE()
                AND s.table_name = ?
                AND s.seq_in_index = 1
                ORDER BY s.cardinality DESC
            """;


            List<Map<String, Object>> stats = jdbcTemplate.queryForList(sql, tableName);
            stats.forEach(stat ->
                log.info("索引: {}, 基数: {}, 选择性: {}%",
                    stat.get("index_name"),
                    stat.get("cardinality"),
                    stat.get("selectivity_percent")
                )
            );
        } catch (Exception e) {
            log.error("更新表统计信息失败: {}", tableName, e);
        }
    }
}

执行计划成本分析与监控

通过 EXPLAIN 和性能监控深入分析 COUNT 的执行成本：

@Component
@Slf4j
public class CountCostAnalyzer {


    @Autowired
    private JdbcTemplate jdbcTemplate;


    @Autowired
    private MeterRegistry meterRegistry;


    public void analyzeCountPlans() {
        String[] queries = {
            "SELECT COUNT(*) FROM user_test",
            "SELECT COUNT(1) FROM user_test",
            "SELECT COUNT(id) FROM user_test",
            "SELECT COUNT(username) FROM user_test",
            "SELECT COUNT(email) FROM user_test"
        };


        for (String query : queries) {
            analyzeQueryWithMetrics(query);
        }
    }


    private void analyzeQueryWithMetrics(String query) {
        Timer.Sample sample = Timer.Sample.start(meterRegistry);


        try {
            log.info("分析查询: {}", query);


            // EXPLAIN分析
            List<Map<String, Object>> explainResult = jdbcTemplate.queryForList("EXPLAIN " + query);


            for (Map<String, Object> row : explainResult) {
                log.info("type: {}, key: {}, rows: {}, Extra: {}",
                    row.get("type"),
                    row.get("key"),
                    row.get("rows"),
                    row.get("Extra")
                );
            }


            // 使用会话级profiling
            analyzeCostProfile(query);


            // 记录成功指标
            meterRegistry.counter("mysql.count.success", "query", extractQueryType(query))
                .increment();


        } catch (Exception e) {
            log.error("查询分析失败: {}", query, e);
            meterRegistry.counter("mysql.count.error", "query", extractQueryType(query))
                .increment();
        } finally {
            sample.stop(Timer.builder("mysql.count.duration")
                .tag("query", extractQueryType(query))
                .register(meterRegistry));
        }
    }


    public void analyzeCostProfile(String query) {
        jdbcTemplate.execute((ConnectionCallback<Void>) connection -> {
            try (Statement stmt = connection.createStatement()) {
                stmt.execute("SET profiling = 1");


                // 执行查询
                jdbcTemplate.queryForObject(query, Long.class);


                // 获取profile信息
                try (ResultSet rs = stmt.executeQuery("SHOW PROFILE")) {
                    while (rs.next()) {
                        double duration = rs.getDouble("Duration");
                        if (duration > 0.001) {
                            log.info("步骤: {}, 耗时: {}s",
                                rs.getString("Status"),
                                duration
                            );
                        }
                    }
                }
            } catch (SQLException e) {
                log.error("Profile分析失败", e);
            } finally {
                // 确保关闭profiling
                try {
                    connection.createStatement().execute("SET profiling = 0");
                } catch (SQLException e) {
                    log.warn("关闭profiling失败", e);
                }
            }
            return null;
        });
    }


    private String extractQueryType(String query) {
        if (query.contains("COUNT(*)")) return "count_star";
        if (query.contains("COUNT(1)")) return "count_one";
        if (query.contains("COUNT(id)")) return "count_id";
        if (query.contains("COUNT(email)")) return "count_email";
        return "count_other";
    }
}