Javaで学ぶ！ファイル入出力とマルチスレッドを組み合わせた効率的なデータ処理の方法

try (BufferedReader reader = new BufferedReader(new FileReader("example.txt"))) {
    String line;
    while ((line = reader.readLine()) != null) {
        System.out.println(line);
    }
} catch (IOException e) {
    e.printStackTrace();
}

try (BufferedWriter writer = new BufferedWriter(new FileWriter("output.txt"))) {
    writer.write("Hello, World!");
} catch (IOException e) {
    e.printStackTrace();
}

try (FileInputStream inputStream = new FileInputStream("image.png");
     FileOutputStream outputStream = new FileOutputStream("copy_image.png")) {
    int data;
    while ((data = inputStream.read()) != -1) {
        outputStream.write(data);
    }
} catch (IOException e) {
    e.printStackTrace();
}

class MyThread extends Thread {
    public void run() {
        System.out.println("スレッドが実行中です: " + Thread.currentThread().getName());
    }
}

public class Main {
    public static void main(String[] args) {
        MyThread thread1 = new MyThread();
        MyThread thread2 = new MyThread();
        thread1.start();
        thread2.start();
    }
}

class MyRunnable implements Runnable {
    public void run() {
        System.out.println("スレッドが実行中です: " + Thread.currentThread().getName());
    }
}

public class Main {
    public static void main(String[] args) {
        Thread thread1 = new Thread(new MyRunnable());
        Thread thread2 = new Thread(new MyRunnable());
        thread1.start();
        thread2.start();
    }
}

try (BufferedReader reader = new BufferedReader(new FileReader("example.txt"));
     BufferedWriter writer = new BufferedWriter(new FileWriter("output.txt"))) {
    String line;
    while ((line = reader.readLine()) != null) {
        writer.write(line);
        writer.newLine();
    }
} catch (IOException e) {
    e.printStackTrace();
}

AsynchronousFileChannel fileChannel = AsynchronousFileChannel.open(Paths.get("example.txt"), StandardOpenOption.READ);
ByteBuffer buffer = ByteBuffer.allocate(1024);

fileChannel.read(buffer, 0, buffer, new CompletionHandler<Integer, ByteBuffer>() {
    @Override
    public void completed(Integer result, ByteBuffer attachment) {
        System.out.println("読み込み完了");
    }

    @Override
    public void failed(Throwable exc, ByteBuffer attachment) {
        exc.printStackTrace();
    }
});

try (RandomAccessFile file = new RandomAccessFile("largefile.txt", "rw");
     FileChannel fileChannel = file.getChannel()) {
    MappedByteBuffer buffer = fileChannel.map(FileChannel.MapMode.READ_WRITE, 0, fileChannel.size());

    while (buffer.hasRemaining()) {
        System.out.print((char) buffer.get());
    }
} catch (IOException e) {
    e.printStackTrace();
}

public class FileUtil {
    private static final Object lock = new Object();

    public static void writeToFile(String data, String filePath) {
        synchronized (lock) {
            try (BufferedWriter writer = new BufferedWriter(new FileWriter(filePath, true))) {
                writer.write(data);
                writer.newLine();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

import java.util.concurrent.locks.ReentrantLock;

public class FileUtil {
    private static final ReentrantLock lock = new ReentrantLock();

    public static void writeToFile(String data, String filePath) {
        lock.lock();
        try {
            try (BufferedWriter writer = new BufferedWriter(new FileWriter(filePath, true))) {
                writer.write(data);
                writer.newLine();
            } catch (IOException e) {
                e.printStackTrace();
            }
        } finally {
            lock.unlock();
        }
    }
}

import java.util.concurrent.atomic.AtomicInteger;

public class Counter {
    private AtomicInteger count = new AtomicInteger(0);

    public void increment() {
        count.incrementAndGet();
    }

    public int getCount() {
        return count.get();
    }
}

import java.nio.channels.FileChannel;
import java.nio.file.StandardOpenOption;

public class FileLockExample {
    public static void lockFile(String filePath) {
        try (FileChannel fileChannel = FileChannel.open(Paths.get(filePath), StandardOpenOption.WRITE)) {
            try (FileLock lock = fileChannel.lock()) {
                // ロック中にファイル操作を行う
                System.out.println("ファイルはロックされています");
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

import java.io.IOException;
import java.io.RandomAccessFile;

public class MultiThreadedFileReader {
    public static void main(String[] args) {
        String filePath = "largefile.txt";
        int numberOfThreads = 4;  // 使用するスレッド数
        long fileSize;

        try (RandomAccessFile file = new RandomAccessFile(filePath, "r")) {
            fileSize = file.length();
            long chunkSize = fileSize / numberOfThreads;

            for (int i = 0; i < numberOfThreads; i++) {
                long start = i * chunkSize;
                long end = (i == numberOfThreads - 1) ? fileSize : start + chunkSize;

                Thread readerThread = new Thread(new FileChunkReader(filePath, start, end));
                readerThread.start();
            }

        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

class FileChunkReader implements Runnable {
    private final String filePath;
    private final long start;
    private final long end;

    public FileChunkReader(String filePath, long start, long end) {
        this.filePath = filePath;
        this.start = start;
        this.end = end;
    }

    @Override
    public void run() {
        try (RandomAccessFile file = new RandomAccessFile(filePath, "r")) {
            file.seek(start);

            byte[] buffer = new byte[1024];
            long bytesRead = start;
            while (bytesRead < end) {
                int read = file.read(buffer, 0, (int) Math.min(buffer.length, end - bytesRead));
                if (read == -1) break;

                // 読み込んだデータを処理する（ここでは単純に出力）
                System.out.print(new String(buffer, 0, read));
                bytesRead += read;
            }

        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;

public class ThreadPoolFileReader {
    public static void main(String[] args) {
        String[] filePaths = {"file1.txt", "file2.txt", "file3.txt", "file4.txt"}; // 処理するファイルのパス
        int numberOfThreads = 4;  // スレッドプールのサイズ

        // スレッドプールの作成
        ExecutorService executorService = Executors.newFixedThreadPool(numberOfThreads);

        // ファイルごとにタスクをスレッドプールに追加
        for (String filePath : filePaths) {
            executorService.submit(new FileReadTask(filePath));
        }

        // スレッドプールのシャットダウン
        executorService.shutdown();
        try {
            if (!executorService.awaitTermination(60, TimeUnit.SECONDS)) {
                executorService.shutdownNow();
            }
        } catch (InterruptedException e) {
            executorService.shutdownNow();
        }
    }
}

class FileReadTask implements Runnable {
    private final String filePath;

    public FileReadTask(String filePath) {
        this.filePath = filePath;
    }

    @Override
    public void run() {
        try (BufferedReader reader = new BufferedReader(new FileReader(filePath))) {
            String line;
            while ((line = reader.readLine()) != null) {
                // 読み込んだ行を処理する（ここでは単純に出力）
                System.out.println(Thread.currentThread().getName() + " - " + line);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

   if (lock1.tryLock(1000, TimeUnit.MILLISECONDS)) {
       try {
           if (lock2.tryLock(1000, TimeUnit.MILLISECONDS)) {
               try {
                   // ロックを取得した状態での処理
               } finally {
                   lock2.unlock();
               }
           }
       } finally {
           lock1.unlock();
       }
   }

   private final Map<String, Integer> map = new ConcurrentHashMap<>();

   public void incrementValue(String key) {
       map.computeIfPresent(key, (k, v) -> v + 1);
   }

   try (BufferedReader reader = new BufferedReader(new FileReader("file.txt"))) {
       // ファイル読み込み処理
   } catch (FileNotFoundException e) {
       System.err.println("ファイルが見つかりません: " + e.getMessage());
   } catch (IOException e) {
       System.err.println("I/Oエラーが発生しました: " + e.getMessage());
   }

   private static final Logger logger = Logger.getLogger(MyClass.class.getName());

   public void run() {
       logger.info("スレッド開始: " + Thread.currentThread().getName());
       try {
           // 処理コード
       } catch (Exception e) {
           logger.severe("エラー発生: " + e.getMessage());
       } finally {
           logger.info("スレッド終了: " + Thread.currentThread().getName());
       }
   }

   @Test
   public void testConcurrentModification() throws InterruptedException {
       int threadCount = 5;
       CountDownLatch latch = new CountDownLatch(threadCount);
       ExecutorService executor = Executors.newFixedThreadPool(threadCount);

       for (int i = 0; i < threadCount; i++) {
           executor.submit(() -> {
               try {
                   // スレッドの処理
               } finally {
                   latch.countDown();
               }
           });
       }

       latch.await();  // すべてのスレッドが終了するまで待機
       executor.shutdown();
   }

public void singleThreadedFileProcessing(String[] files) {
    for (String file : files) {
        try (BufferedReader reader = new BufferedReader(new FileReader(file))) {
            String line;
            while ((line = reader.readLine()) != null) {
                // ファイルの行を処理する
                processLine(line);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

public void multiThreadedFileProcessing(String[] files) {
    ExecutorService executor = Executors.newFixedThreadPool(files.length);
    for (String file : files) {
        executor.submit(() -> {
            try (BufferedReader reader = new BufferedReader(new FileReader(file))) {
                String line;
                while ((line = reader.readLine()) != null) {
                    processLine(line);
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        });
    }
    executor.shutdown();
    try {
        executor.awaitTermination(1, TimeUnit.HOURS);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
}

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.atomic.AtomicInteger;

public class LogFileAnalyzer {
    private static final ConcurrentHashMap<String, AtomicInteger> errorCountMap = new ConcurrentHashMap<>();

    public static void main(String[] args) {
        String[] logFiles = {"server1.log", "server2.log", "server3.log"};
        ExecutorService executor = Executors.newFixedThreadPool(logFiles.length);

        for (String logFile : logFiles) {
            executor.submit(() -> analyzeLogFile(logFile));
        }

        executor.shutdown();
        while (!executor.isTerminated()) {
            // 待機
        }

        // 結果の出力
        errorCountMap.forEach((error, count) -> System.out.println(error + ": " + count));
    }

    private static void analyzeLogFile(String filePath) {
        try (BufferedReader reader = new BufferedReader(new FileReader(filePath))) {
            String line;
            while ((line = reader.readLine()) != null) {
                if (line.contains("ERROR")) {
                    errorCountMap.computeIfAbsent("ERROR", k -> new AtomicInteger()).incrementAndGet();
                }
                if (line.contains("WARNING")) {
                    errorCountMap.computeIfAbsent("WARNING", k -> new AtomicInteger()).incrementAndGet();
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

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

public class CSVTransformer {
    public static void main(String[] args) {
        String[] csvFiles = {"data1.csv", "data2.csv", "data3.csv"};
        ExecutorService executor = Executors.newFixedThreadPool(csvFiles.length);

        for (String csvFile : csvFiles) {
            executor.submit(() -> transformCSV(csvFile));
        }

        executor.shutdown();
        while (!executor.isTerminated()) {
            // 待機
        }
    }

    private static void transformCSV(String filePath) {
        String outputFilePath = filePath.replace(".csv", ".json");  // CSVをJSONに変換する例
        try (BufferedReader reader = new BufferedReader(new FileReader(filePath));
             FileWriter writer = new FileWriter(outputFilePath)) {

            String line;
            writer.write("[\n");
            while ((line = reader.readLine()) != null) {
                String[] fields = line.split(",");
                writer.write("  { \"field1\": \"" + fields[0] + "\", \"field2\": \"" + fields[1] + "\" },\n");
            }
            writer.write("]\n");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}