Java线程调用优化：如何高效批量生成10位字母数字令牌？

嘿，你的这个需求我太懂了！手动创建一堆线程确实不够优雅，而且还可能藏着性能或者线程安全的坑。咱们来一步步优化你的令牌生成实现：

首先得提一下当前代码的几个潜在问题：手动创建12个线程不仅写起来繁琐，没法灵活调整并发数，另外如果TokenGenerator.main()里直接往同一个文件写内容，多线程同时写入大概率会出现内容乱序、覆盖的问题，这可是个隐形坑。

下面是几个更优的实现思路，附具体代码示例：

1. 用线程池替代手动创建线程 #

线程池可以帮你自动管理线程的创建、复用和销毁，比手动new Thread优雅太多，还能避免频繁创建线程的开销。你可以根据任务类型调整并发数：如果令牌生成是CPU密集型任务，并发数建议设为CPU核心数+1；如果是IO密集型（比如写文件），可以设得稍大一些。

示例代码：

package Random;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class TokenStarter {
    public static void main(String[] args) {
        // 和你原来的线程数保持一致，也可以根据需求动态调整
        int threadCount = 12;
        ExecutorService executor = Executors.newFixedThreadPool(threadCount);
        
        // 批量提交令牌生成任务
        for (int i = 0; i < threadCount; i++) {
            executor.submit(() -> TokenGenerator.main(null));
        }
        
        // 关闭线程池：不再接受新任务，等待现有任务全部完成
        executor.shutdown();
    }
}

2. 解决文件写入的线程安全问题 #

如果你的TokenGenerator是直接往同一个文件写内容，多线程操作肯定会出问题。这里有两个实用的解决办法：

方法一：给文件写入操作加同步锁 #

在TokenGenerator的写入逻辑里，用synchronized保证同一时间只有一个线程写文件：

// 在TokenGenerator类中修改写入逻辑
private static final Object WRITE_LOCK = new Object();

public static void writeTokenToFile(String token) {
    synchronized (WRITE_LOCK) {
        try (BufferedWriter writer = new BufferedWriter(new FileWriter("tokens.txt", true))) {
            writer.write(token);
            writer.newLine();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

方法二：生成与写入解耦（更高效） #

让生成令牌的线程只负责生成，把令牌放到线程安全的队列里，专门开一个线程从队列取令牌写入文件。这样能减少锁竞争，提升整体效率：

package Random;

import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.LinkedBlockingQueue;

public class TokenStarter {
    // 线程安全的阻塞队列，存放生成的令牌
    private static final BlockingQueue<String> TOKEN_QUEUE = new LinkedBlockingQueue<>();
    private static final int THREAD_COUNT = 12;

    public static void main(String[] args) {
        ExecutorService executor = Executors.newFixedThreadPool(THREAD_COUNT);

        // 启动令牌生成任务（循环生成直到你停止程序）
        for (int i = 0; i < THREAD_COUNT; i++) {
            executor.submit(() -> {
                while (!Thread.currentThread().isInterrupted()) {
                    String token = TokenGenerator.generateToken(); // 假设新增单个令牌生成方法
                    try {
                        TOKEN_QUEUE.put(token);
                    } catch (InterruptedException e) {
                        Thread.currentThread().interrupt();
                        break;
                    }
                }
            });
        }

        // 启动专门的文件写入线程
        new Thread(() -> {
            try (BufferedWriter writer = new BufferedWriter(new FileWriter("tokens.txt", true))) {
                while (!Thread.currentThread().isInterrupted()) {
                    String token = TOKEN_QUEUE.take();
                    writer.write(token);
                    writer.newLine();
                    writer.flush(); // 按需刷新，避免缓存积压
                }
            } catch (IOException | InterruptedException e) {
                e.printStackTrace();
            }
        }).start();
    }
}

3. 优化令牌生成的性能 #

如果令牌生成是性能瓶颈，可以从随机数生成入手优化：

• 用ThreadLocalRandom代替Random：Random在多线程下会因为CAS操作产生竞争，ThreadLocalRandom是线程本地的，性能更优。
• 预定义字符集数组，避免重复创建：

// 在TokenGenerator类中优化生成逻辑
private static final char[] ALPHANUMERIC = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789".toCharArray();

public static String generateToken() {
    StringBuilder sb = new StringBuilder(10);
    for (int i = 0; i < 10; i++) {
        int index = ThreadLocalRandom.current().nextInt(ALPHANUMERIC.length);
        sb.append(ALPHANUMERIC[index]);
    }
    return sb.toString();
}

你可以根据实际需求选择方案：如果只是想优化代码结构，用线程池就够了；如果文件写入有异常，加上线程安全的写入逻辑；如果追求最高效率，就用生成与写入解耦的方式+高效的令牌生成逻辑。

内容的提问来源于stack exchange，提问作者Alex Ritchie