多线程树篱模拟器开发问询：线程协作与分段、园丁线程实现问题

我来帮你搞定这个多线程树篱模拟器的问题！核心要解决的就是线程安全的状态共享和多线程协作这两个点，下面给你一个完整的实现思路和代码示例，一步步讲清楚：

首先明确三个核心组件的职责：

• 树篱分段（HedgeSegment）：存储当前尺寸，提供线程安全的读写/修改方法，是多线程共享的核心资源
• 生长线程（GrowthThread）：每个分段对应一个专属线程，负责随机触发生长行为
• 园丁线程（GardenerThread）：全局监控所有分段，一旦发现尺寸达到阈值就修剪并记录操作

1. 线程安全的树篱分段类 #

这个类是整个模拟器的基础，必须保证多线程读写时的原子性，避免竞态条件：

public class HedgeSegment {
    private int size;
    private final int id; // 分段ID，方便记录操作
    private static final int TRIM_THRESHOLD = 10; // 修剪阈值

    public HedgeSegment(int id) {
        this.id = id;
        this.size = 1; // 初始尺寸为1
    }

    // 线程安全的获取当前尺寸
    public synchronized int getSize() {
        return size;
    }

    // 随机触发生长：50%概率尺寸+1，可自行调整概率
    public synchronized boolean grow() {
        // 已经到阈值就不再生长
        if (size >= TRIM_THRESHOLD) {
            return false;
        }
        if (Math.random() > 0.5) {
            size++;
            return true;
        }
        return false;
    }

    // 线程安全的修剪操作，重置为初始尺寸并记录
    public synchronized void trim() {
        int oldSize = size;
        size = 1;
        System.out.printf("[%s] 园丁修剪了分段%d，尺寸从%d重置为1%n", 
                java.time.LocalTime.now(), id, oldSize);
    }

    public int getId() {
        return id;
    }
}

2. 生长线程类 #

每个线程绑定一个分段，循环执行生长逻辑，用休眠模拟生长的时间间隔：

public class GrowthThread extends Thread {
    private final HedgeSegment segment;
    private final long checkInterval; // 生长检查的间隔时间（毫秒）

    public GrowthThread(HedgeSegment segment, long checkInterval) {
        this.segment = segment;
        this.checkInterval = checkInterval;
        this.setName("生长线程-" + segment.getId()); // 设置线程名，方便调试
    }

    @Override
    public void run() {
        // 线程持续运行，直到收到中断信号
        while (!isInterrupted()) {
            boolean grew = segment.grow();
            if (grew) {
                System.out.printf("[%s] 分段%d生长了，当前尺寸：%d%n",
                        java.time.LocalTime.now(), segment.getId(), segment.getSize());
            }
            try {
                Thread.sleep(checkInterval);
            } catch (InterruptedException e) {
                // 优雅响应中断，退出循环
                Thread.currentThread().interrupt();
                System.out.printf("[%s] 分段%d的生长线程已停止%n",
                        java.time.LocalTime.now(), segment.getId());
            }
        }
    }
}

3. 园丁线程类 #

全局监控所有分段，定期检查并修剪达到阈值的分段，同样用休眠避免忙等：

import java.util.List;

public class GardenerThread extends Thread {
    private final List<HedgeSegment> segments;
    private final long checkInterval; // 检查间隔时间（毫秒）
    private static final int TRIM_THRESHOLD = 10;

    public GardenerThread(List<HedgeSegment> segments, long checkInterval) {
        this.segments = segments;
        this.checkInterval = checkInterval;
        this.setName("园丁线程");
    }

    @Override
    public void run() {
        while (!isInterrupted()) {
            // 遍历所有分段检查尺寸
            for (HedgeSegment segment : segments) {
                if (segment.getSize() >= TRIM_THRESHOLD) {
                    segment.trim();
                }
            }
            try {
                Thread.sleep(checkInterval);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                System.out.printf("[%s] 园丁线程已停止%n", java.time.LocalTime.now());
            }
        }
    }
}

4. 主程序入口 #

创建所有组件，启动线程，并提供优雅的停止方式：

import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

public class HedgeSimulator {
    public static void main(String[] args) {
        // 创建10个树篱分段
        List<HedgeSegment> segments = new ArrayList<>();
        for (int i = 1; i <= 10; i++) {
            segments.add(new HedgeSegment(i));
        }

        // 启动10个生长线程（每100ms检查一次生长）
        List<GrowthThread> growthThreads = new ArrayList<>();
        for (HedgeSegment segment : segments) {
            GrowthThread gt = new GrowthThread(segment, 100);
            growthThreads.add(gt);
            gt.start();
        }

        // 启动园丁线程（每500ms检查一次修剪）
        GardenerThread gardener = new GardenerThread(segments, 500);
        gardener.start();

        // 等待用户输入任意键停止程序
        System.out.println("树篱模拟器已启动，按任意键停止...");
        Scanner scanner = new Scanner(System.in);
        scanner.nextLine();

        // 中断所有线程并等待结束
        gardener.interrupt();
        for (GrowthThread gt : growthThreads) {
            gt.interrupt();
        }

        try {
            gardener.join();
            for (GrowthThread gt : growthThreads) {
                gt.join();
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("树篱模拟器已停止");
    }
}

1. 线程安全保障：所有对分段尺寸的读写操作都用synchronized修饰，确保同一时间只有一个线程能修改或读取尺寸，避免出现“刚读到尺寸9，还没修剪就被生长线程加到11”的问题。
2. 随机生长逻辑：用Math.random()实现概率性生长，你可以调整Math.random() > 0.5中的阈值来改变生长概率（比如改成0.3就是70%的生长概率）。
3. 避免资源浪费：生长线程和园丁线程都加入了休眠，不会一直占用CPU，更贴近真实场景的时间流逝。
4. 优雅停止：用interrupt()方法终止线程，而不是强制杀死，保证线程有机会完成收尾操作。

内容的提问来源于stack exchange，提问作者J. Doe