"JSqlParser 协作式超时机制优化 - 性能提升 70%"

1
// 原有实现（伪代码）
2
public Statement parseStatement(CCJSqlParser parser) {
3
    ExecutorService executor = Executors.newSingleThreadExecutor();
4
    Future<Statement> future = executor.submit(() -> parser.Statement());
5

6
    try {
7
        return future.get(timeout, TimeUnit.MILLISECONDS);
8
    } catch (TimeoutException ex) {
9
        future.cancel(true);
10
        throw new JSQLParserException("Time out occurred.");
11
    } finally {
12
        executor.shutdown();
13
    }
14
}

1
%%{init: {'theme': 'neutral'}}%%
2
flowchart TD
3
    A["User Thread"] --> B["create ExecutorService"]
4
    B --> C["Parser Thread"]
5
    C --> D["parse SQL"]
6
    D --> E["Result"]
7
    B --> F["wait/timeout"]
8
    F --> G["User Thread - 继续"]

1
%%{init: {'theme': 'neutral'}}%%
2
flowchart TD
3
    A["User Thread"] --> B["startTimeout - 启动计时"]
4
    B --> C["Parser"]
5
    C --> D["checkpoint - checkTimeout"]
6
    D --> E["checkpoint - checkTimeout"]
7
    E --> F["checkpoint - checkTimeout"]
8
    F --> G["resetTimeout - 重置状态"]
9
    G --> H["Result"]

1
public abstract class AbstractJSqlParser<P> {
2
    // 协作式超时机制
3
    protected long parseStartTime = 0;      // 解析开始时间戳
4
    protected long timeoutMillis = 0;       // 超时时长（毫秒）
5
    protected volatile boolean interrupted = false;  // 中断标志
6

7
    // ... 其他字段
8
}

1
/**
2
 * 启动超时计时器
3
 */
4
public void startTimeout() {
5
    this.timeoutMillis = getConfiguration().getAsLong(Feature.timeOut);
6
    this.parseStartTime = System.currentTimeMillis();
7
    this.interrupted = false;
8
}
9

10
/**
11
 * 检查是否超时
12
 * @return true 表示已超时
13
 */
14
public boolean checkTimeout() {
15
    if (timeoutMillis <= 0) {
16
        return false;  // 未配置超时
17
    }
18

19
    long elapsed = System.currentTimeMillis() - parseStartTime;
20
    if (elapsed > timeoutMillis) {
21
        interrupted = true;
22
        return true;
23
    }
24
    return false;
25
}
26

27
/**
28
 * 重置超时状态
29
 */
30
public void resetTimeout() {
31
    this.parseStartTime = 0;
32
    this.interrupted = false;
33
}

1
public static Statement parseStatement(CCJSqlParser parser, ExecutorService executorService)
2
        throws JSQLParserException {
3
    Statement statement = null;
4
    try {
5
        parser.startTimeout();              // 启动计时
6
        statement = parser.Statement();      // 执行解析
7
        if (parser.interrupted) {
8
            throw new JSQLParserException("Time out occurred.");
9
        }
10
    } catch (Exception ex) {
11
        if (parser.interrupted) {
12
            throw new JSQLParserException("Time out occurred.", ex);
13
        }
14
        throw new JSQLParserException(ex);
15
    } finally {
16
        parser.resetTimeout();              // 重置状态
17
    }
18
    return statement;
19
}

1
Statement Statement() #Statement:
2
{
3
    // ... 变量声明
4
}
5
{
6
    {
7
        // 语句级别检查
8
        if (checkTimeout()) {
9
            throw new ParseException("Parsing timeout exceeded");
10
        }
11
    }
12
    try {
13
        // ... 解析逻辑
14
    }
15
}

1
// SELECT 项列表
2
List<SelectItem> SelectItemsList():
3
{
4
    List<SelectItem> selectItemsList = new ArrayList<SelectItem>();
5
    SelectItem selectItem = null;
6
}
7
{
8
    selectItem=SelectItem() { selectItemsList.add(selectItem); }
9
    (
10
        LOOKAHEAD(2, {!interrupted && !checkTimeout()})  // 循环前检查
11
        "," selectItem=SelectItem() { selectItemsList.add(selectItem); }
12
    )*
13
    { return selectItemsList; }
14
}

1
Expression OrExpression():
2
{
3
    Expression left, right, result;
4
}
5
{
6
    left=AndExpression() { result = left; }
7
    (
8
        LOOKAHEAD(2, {!interrupted && !checkTimeout()})  // 每次迭代检查
9
        <K_OR>
10
        right=AndExpression()
11
        {
12
            result = new OrExpression(left, right);
13
            left = result;
14
        }
15
     )*
16
     { return result; }
17
}

1
@BenchmarkMode(Mode.AverageTime)
2
@OutputTimeUnit(TimeUnit.MICROSECONDS)
3
@Warmup(iterations = 3, time = 1, timeUnit = TimeUnit.SECONDS)
4
@Measurement(iterations = 5, time = 1, timeUnit = TimeUnit.SECONDS)
5
@Fork(1)
6
@State(Scope.Benchmark)

1
性能提升分布图:
2

3
简单查询    ████████████████████████████████ 86.25% (7.5x)
4
复杂查询    ████████████████████ 49.08% (2.0x)
5
超时场景    ████████████████████████████████████ 79.63% (5.9x)
6
混合负载    ██████████████████████ 57.44% (2.4x)
7
            0%   20%   40%   60%   80%   100%

1
<dependency>
2
    <groupId>com.github.jsql-parser</groupId>
3
    <artifactId>jsqlparser</artifactId>
4
    <version>4.5-ext-v1.0</version>
5
    <scope>system</scope>
6
    <systemPath>${project.basedir}/lib/jsqlparser-jsqlparser-4.5-ext-v1.0.jar</systemPath>
7
</dependency>

1
dependencies {
2
    implementation files('libs/jsqlparser-jsqlparser-4.5-ext-v1.0.jar')
3
}

1
// 原有代码，无需任何修改
2
import net.sf.jsqlparser.parser.CCJSqlParserUtil;
3
import net.sf.jsqlparser.statement.Statement;
4

5
String sql = "SELECT * FROM users WHERE id = 1";
6

7
// 不配置超时
8
Statement stmt = CCJSqlParserUtil.parse(sql);
9

10
// 配置超时（推荐）
11
CCJSqlParser parser = CCJSqlParserUtil.newParser(sql);
12
parser.withTimeOut(5000);  // 5 秒超时
13
Statement stmt = CCJSqlParserUtil.parseStatement(parser);

1
// 简单验证脚本
2
import net.sf.jsqlparser.parser.CCJSqlParserUtil;
3

4
public class VerifyOptimization {
5
    public static void main(String[] args) throws Exception {
6
        long start = System.nanoTime();
7

8
        for (int i = 0; i < 1000; i++) {
9
            CCJSqlParserUtil.parse("SELECT * FROM users WHERE id = 1");
10
        }
11

12
        long elapsed = (System.nanoTime() - start) / 1_000_000;
13
        System.out.println("1000 次解析耗时: " + elapsed + " ms");
14

15
        // 优化版本应该在 30-50 ms
16
        // 原始版本约 200-250 ms
17
    }
18
}

1
// 生产环境建议添加监控
2
import io.micrometer.core.instrument.Timer;
3

4
Timer.Sample sample = Timer.start();
5
Statement stmt = CCJSqlParserUtil.parse(sql);
6
sample.stop(Timer.builder("sql.parse.time")
7
    .tag("type", "simple")
8
    .register(registry));