还是建议去照照，我也是腰疼，去拍片，不过不是腰突，骨质增生，就建议睡硬床板。

@liuzimin 早期还有 ipv4 公网 ip ，得自己打电话要。我是因为搬家，宽带迁移了，ipv4 没了，再要也要不到了。

@jmliubiao #10 ipv4 公网 ip 要加钱，很贵，100 一月。我是 169 套餐，1000M 带宽，两张副卡免费的，有 ipv6 的公网 ip ，深圳城中村。

纸终究包不住火，能还上还是赶紧还了吧。

@duduji77 #43 可以问一下 gpt ，说不定能提供好的思路。解决难题一般来说都有成就感！

板 U：i5 12600k(核显) + 微星 760Gaming plus WiFi(四内存槽)；
内存：威刚 ddr5 6000 16G * 2 ；
硬盘：m.2 固态 1T ；
不要机箱，找个风冷散热 + 400W 左右电源。
pdd 看的，可能会超一点，主要四内存槽主板贵了...

看不懂，自费 2000 多给公司电脑升级，到时候走人自费的那些东西怎么办，不得扯皮 https://i.imgur.com/km62MY2.png

@helone A 站肥肥？

男人的最终归宿：钓鱼佬！所以买钓具。https://i.imgur.com/6DMydmQ.png

我这上传设计是一个单独接口，接收 MultipartFile 数组和一个枚举（区分业务），返回字符串 url 。然后把这个 url 放对应的字段就行。

我在 21 年底，闲鱼掏了一套雅马哈 V340 ，功放+低音炮+5 个喇叭，1100 。感觉还行。

感谢大佬，支持！ https://i.imgur.com/pmNOo2w.png

第一个是泛型接口 + 普通方法。第二个是普通接口 + 泛型方法。应该去了解泛型类和泛型方法的区别。

明天 V50 ，你这朋友我交定了！

public class Code {

// 执行外层任务的线程池
static ExecutorService outerExecutor = Executors.newFixedThreadPool(8);

// 执行内层任务的线程池
static ExecutorService innerExecutor = Executors.newFixedThreadPool(16);

// 任务总数
static AtomicInteger taskCount = new AtomicInteger();

static String url = "url";

static Random random = ThreadLocalRandom.current();

public static void optimization() {

StopWatch stopWatch = new StopWatch();
stopWatch.start();

// 模拟任务
final int maxTask = random.nextInt(1000);

System.out.println("外层总任务数：" + maxTask);

List<String> list = IntStream.rangeClosed(1, maxTask).mapToObj(String::valueOf).collect(Collectors.toList());

// 50 个任务一组
final List<List<String>> partition = Lists.partition(list, 50);

System.out.println("拆分任务数量：" + partition.size());

partition.parallelStream()
.map(task -> CompletableFuture.runAsync(new OuterTask(task), outerExecutor))
.forEach(CompletableFuture::join);

System.out.println("taskCount = " + taskCount);
stopWatch.stop();
System.out.println("耗时：" + stopWatch.getTotalTimeSeconds());

innerExecutor.shutdown();
outerExecutor.shutdown();

}

private static class OuterTask implements Runnable {

private final List<String> tasks;

public OuterTask(List<String> tasks) {
this.tasks = tasks;
}

@Override
public void run() {
tasks.parallelStream()
.map(task -> CompletableFuture.runAsync(new InnerTask(task), innerExecutor))
.forEach(CompletableFuture::join);
}
}

private static class InnerTask implements Runnable {

private final String body;

public InnerTask(String body) {
this.body = body;
}

@Override
public void run() {
final List<String> responseResult = HttpRequest.post(url).body(body);

for (String aParam : responseResult) {
final String bParam = functionA(aParam);
final String cParam = functionB(bParam);
final String result = functionC(cParam);

// handle result...

taskCount.incrementAndGet();
}
}
}
}

考虑不周，仅作参考。。。

@cloudzhou 感觉，CompletableFuture 蛮符合的