写一个java并发写入文件的代码

### 回答1：
好的，以下是一个示例代码，它实现了多个线程同时写入同一个文件：

import java.io.FileWriter;
import java.io.IOException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class ConcurrentFileWriter {
    private final static int THREAD_COUNT = 10;
    private final static String FILE_NAME = "concurrent_file.txt";

    public static void main(String[] args) {
        ExecutorService executorService = Executors.newFixedThreadPool(THREAD_COUNT);
        for (int i = 0; i < THREAD_COUNT; i++) {
            final int index = i;
            executorService.submit(() -> {
                try (FileWriter fileWriter = new FileWriter(FILE_NAME, true)) {
                    for (int j = 0; j < 100; j++) {
                        fileWriter.write("Thread " + index + ": Line " + j + "\n");
                    }
                } catch (IOException e) {
                    e.printStackTrace();
                }
            });
        }
        executorService.shutdown();
    }
}

这段代码创建了 10 个线程，每个线程写入文件 `concurrent_file.txt` 100 行数据。注意，由于文件是被多个线程写入，因此文件内容可能是无序的。

### 回答2：
下面是一个使用Java并发写入文件的示例代码：

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

public class ConcurrentFileWriter {

    private static final String FILE_PATH = "output.txt";
    private static final int NUM_THREADS = 10;
    private static final int NUM_TASKS = 100;

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

        for (int i = 0; i < NUM_TASKS; i++) {
            final int taskNumber = i;
            executor.execute(() -> {
                String content = "This is task number " + taskNumber + "\n";
                writeToFile(content);
            });
        }

        executor.shutdown();
        try {
            executor.awaitTermination(Long.MAX_VALUE, TimeUnit.NANOSECONDS);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    private static synchronized void writeToFile(String content) {
        try (BufferedWriter writer = new BufferedWriter(new FileWriter(FILE_PATH, true))) {
            writer.write(content);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

该代码创建了一个固定大小的线程池，通过`ExecutorService`管理线程。`NUM_THREADS`和`NUM_TASKS`分别表示线程池中的线程数量和要执行的任务数量。

在主循环中，通过调用`executor.execute()`方法，将待写入文件的任务提交给线程池执行。每个任务都会生成一段内容并调用`writeToFile()`方法将内容写入文件中。

在`writeToFile()`方法中，使用`synchronized`关键字来确保多个线程之间的互斥访问，避免并发写入导致的问题。

最后，当所有任务都执行完毕后，调用`executor.shutdown()`关闭线程池，并通过`executor.awaitTermination()`等待所有任务执行完成。

注意：由于在`writeToFile()`方法中使用了`synchronized`关键字，可能会影响性能。在实际应用中，可以考虑使用更高效的并发写入方式，例如使用`java.util.concurrent.locks.Lock`实现精确控制。

### 回答3：
以下是一个使用Java并发编写文件的示例代码：

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

public class ConcurrentFileWriter {
    public static void main(String[] args) {
        // 创建一个具有10个线程的线程池
        ExecutorService executorService = Executors.newFixedThreadPool(10);

        // 定义要写入的数据
        String data = "Hello, World!";

        // 创建10个任务同时写入文件
        for (int i = 1; i <= 10; i++) {
            int fileNumber = i;
            executorService.execute(() -> writeFile("file_" + fileNumber + ".txt", data));
        }

        // 关闭线程池
        executorService.shutdown();
    }

    private static void writeFile(String fileName, String data) {
        try {
            BufferedWriter writer = new BufferedWriter(new FileWriter(fileName));
            writer.write(data);

            // 模拟写入数据需要一些时间
            Thread.sleep(1000);

            writer.close();
            System.out.println("写入文件成功：" + fileName);
        } catch (IOException | InterruptedException e) {
            e.printStackTrace();
        }
    }
}

在上面的代码中，我们创建了一个具有10个线程的线程池，然后定义了要写入的数据为"Hello, World!"。接下来，我们使用循环创建了10个任务，每个任务使用线程池并行地执行。每个任务会调用`writeFile`方法来写入文件。

在`writeFile`方法中，我们使用`BufferedWriter`和`FileWriter`来打开文件并写入数据。为了模拟写入操作需要一些时间，我们在写入数据之后使用`Thread.sleep(1000)`方法来暂停1秒钟。最后，关闭文件，并打印写入文件成功的信息。

这样，我们便可以通过并发的方式将数据写入多个文件中。