PR

.coderabbit.yaml

@@ -0,0 +1,9 @@
+# Minimal configuration for getting started
+language: "zh-CN"
+
+reviews:
+  profile: "chill"
+  high_level_summary: true
+  auto_review:
+    enabled: true
+    drafts: false

Calculator.java

@@ -0,0 +1,120 @@
+/**
+ * 计算器类 - 包含数值计算和逻辑错误
+ */
+public class Calculator {
+
+    public static final double PI = 3.14; // 精度不够
+    private static int lastResult; // 应该用long或BigDecimal
+
+    // 除零问题
+    public double divide(double a, double b) {
+        return a / b; // 没有检查b是否为0
+    }
+
+    // 整数除法精度丢失
+    public double percentage(int value, int total) {
+        return (value / total) * 100; // 整数除法会丢失精度
+    }
+
+    // 数值溢出风险
+    public int factorial(int n) {
+        if (n == 0)
+            return 1;
+        return n * factorial(n - 1); // 可能栈溢出，int溢出
+    }
+
+    // 浮点数比较问题
+    public boolean isEqual(double a, double b) {
+        return a == b; // 不应该直接比较浮点数
+    }
+
+    // 复杂的方法，职责不单一
+    public String calculateAndFormat(double num1, double num2, String operation) {
+        double result = 0;
+        String symbol = "";
+
+        // 应该使用switch或策略模式
+        if (operation.equals("add")) {
+            result = num1 + num2;
+            symbol = "+";
+        } else if (operation.equals("subtract")) {
+            result = num1 - num2;
+            symbol = "-";
+        } else if (operation.equals("multiply")) {
+            result = num1 * num2;
+            symbol = "*";
+        } else if (operation.equals("divide")) {
+            if (num2 != 0) {
+                result = num1 / num2;
+                symbol = "/";
+            } else {
+                return "Error: Division by zero";
+            }
+        } else {
+            return "Invalid operation";
+        }
+
+        // 格式化逻辑也在这里
+        String formatted;
+        if (result == (int) result) {
+            formatted = String.valueOf((int) result);
+        } else {
+            formatted = String.format("%.2f", result);
+        }
+
+        lastResult = (int) result; // 可能丢失精度
+
+        return num1 + " " + symbol + " " + num2 + " = " + formatted;
+    }
+
+    // 无限循环风险
+    public double sqrt(double number) {
+        if (number < 0)
+            return Double.NaN;
+
+        double guess = number / 2;
+        double previous;
+
+        do {
+            previous = guess;
+            guess = (guess + number / guess) / 2;
+        } while (Math.abs(guess - previous) > 0.0001); // 可能无限循环
+
+        return guess;
+    }
+
+    // 静态方法访问实例变量
+    public static int getLastResult() {
+        return lastResult; // 线程安全问题
+    }
+
+    // 缺少输入验证
+    public double power(double base, int exponent) {
+        double result = 1;
+        for (int i = 0; i < exponent; i++) { // 没有处理负指数
+            result *= base;
+        }
+        return result;
+    }
+
+    // 魔法数字
+    public double calculateCircleArea(double radius) {
+        return 3.14159 * radius * radius; // 应该使用常量
+    }
+
+    // 不一致的返回类型处理
+    public Object calculate(String expression) {
+        try {
+            if (expression.contains("+")) {
+                String[] parts = expression.split("\\+");
+                return Double.parseDouble(parts[0]) + Double.parseDouble(parts[1]);
+            } else if (expression.contains("-")) {
+                String[] parts = expression.split("-");
+                return Double.parseDouble(parts[0]) - Double.parseDouble(parts[1]);
+            }
+            return "Unsupported operation";
+        } catch (Exception e) {
+            return null; // 不一致的错误处理
+        }
+    }
+}

ConcurrentTask.java

@@ -0,0 +1,179 @@
+import java.util.*;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+
+/**
+ * 并发任务处理类 - 包含线程安全和并发问题
+ */
+public class ConcurrentTask {
+
+    private static int counter = 0; // 线程不安全的计数器
+    private List<String> results = new ArrayList<>(); // 非线程安全集合
+    private Map<String, Object> cache = new HashMap<>(); // 非线程安全缓存
+
+    // 竞态条件
+    public void incrementCounter() {
+        counter++; // 非原子操作
+    }
+
+    public int getCounter() {
+        return counter;
+    }
+
+    // 双重检查锁定的错误实现
+    private static volatile ConcurrentTask instance;
+
+    public static ConcurrentTask getInstance() {
+        if (instance == null) {
+            synchronized (ConcurrentTask.class) {
+                if (instance == null) {
+                    instance = new ConcurrentTask(); // 正确，但有其他问题
+                }
+            }
+        }
+        return instance;
+    }
+
+    // 死锁风险
+    private final Object lock1 = new Object();
+    private final Object lock2 = new Object();
+
+    public void method1() {
+        synchronized (lock1) {
+            try {
+                Thread.sleep(100);
+            } catch (InterruptedException e) {
+                Thread.currentThread().interrupt();
+            }
+            synchronized (lock2) {
+                // 一些操作
+            }
+        }
+    }
+
+    public void method2() {
+        synchronized (lock2) {
+            try {
+                Thread.sleep(100);
+            } catch (InterruptedException e) {
+                Thread.currentThread().interrupt();
+            }
+            synchronized (lock1) {
+                // 一些操作
+            }
+        }
+    }
+
+    // 不正确的线程池使用
+    public void processItems(List<String> items) {
+        ExecutorService executor = Executors.newFixedThreadPool(10);
+
+        for (String item : items) {
+            executor.submit(() -> {
+                processItem(item);
+                results.add("Processed: " + item); // 非线程安全操作
+            });
+        }
+
+        // 没有shutdown和awaitTermination
+    }
+
+    private void processItem(String item) {
+        // 模拟处理
+        try {
+            Thread.sleep(1000);
+        } catch (InterruptedException e) {
+            // 不正确的中断处理
+        }
+    }
+
+    // 不安全的缓存操作
+    public Object getCachedValue(String key) {
+        if (!cache.containsKey(key)) {
+            // 计算值的过程可能很耗时
+            Object value = computeExpensiveValue(key);
+            cache.put(key, value); // 竞态条件
+            return value;
+        }
+        return cache.get(key);
+    }
+
+    private Object computeExpensiveValue(String key) {
+        try {
+            Thread.sleep(2000); // 模拟耗时操作
+        } catch (InterruptedException e) {
+            Thread.currentThread().interrupt();
+        }
+        return "Value for " + key;
+    }
+
+    // 生产者消费者问题
+    private Queue<String> queue = new LinkedList<>();
+    private boolean finished = false;
+
+    public void producer() {
+        for (int i = 0; i < 100; i++) {
+            queue.offer("Item " + i); // 非线程安全
+        }
+        finished = true; // 可见性问题
+    }
+
+    public void consumer() {
+        while (!finished || !queue.isEmpty()) {
+            String item = queue.poll(); // 可能NPE
+            if (item != null) {
+                System.out.println("Consumed: " + item);
+            }
+        }
+    }
+
+    // 资源竞争
+    private int sharedResource = 0;
+
+    public void updateResource(int value) {
+        // 非原子操作
+        sharedResource = sharedResource + value;
+    }
+
+    public int getResource() {
+        return sharedResource;
+    }
+
+    // 不正确的同步
+    public synchronized void synchronizedMethod() {
+        // 在同步方法中调用其他对象的方法
+        String result = externalService.process("data");
+        results.add(result); // 外部调用可能耗时很长
+    }
+
+    private ExternalService externalService = new ExternalService();
+
+    class ExternalService {
+        public String process(String data) {
+            try {
+                Thread.sleep(5000); // 模拟网络调用
+            } catch (InterruptedException e) {
+                Thread.currentThread().interrupt();
+            }
+            return "Processed: " + data;
+        }
+    }
+
+    // ThreadLocal内存泄漏
+    private static ThreadLocal<StringBuilder> threadLocalBuilder = new ThreadLocal<StringBuilder>() {
+        @Override
+        protected StringBuilder initialValue() {
+            return new StringBuilder();
+        }
+    };
+
+    public String buildString(String... parts) {
+        StringBuilder builder = threadLocalBuilder.get();
+        for (String part : parts) {
+            builder.append(part);
+        }
+        String result = builder.toString();
+        // 没有清理ThreadLocal
+        return result;
+    }
+}