初心者でもわかる！Javaマルチスレッド完全ガイド2024 – 現場で使える実践テクニック7選

// 1. Threadクラスを使用した基本的なスレッドの作成
Thread thread = new Thread(() -> {
    System.out.println("新しいスレッドで実行中");
});
thread.start(); // スレッドの開始

// 2. スレッドの状態を確認
System.out.println("スレッドの状態: " + thread.getState());

// シングルスレッドでの処理例
public void processDataSingleThread(List<Integer> numbers) {
    // 直列処理
    numbers.forEach(num -> {
        heavyCalculation(num);
    });
}

// マルチスレッドでの処理例
public void processDataMultiThread(List<Integer> numbers) {
    // 並列処理
    numbers.parallelStream().forEach(num -> {
        heavyCalculation(num);
    });
}

public class MyThread extends Thread {
    @Override
    public void run() {
        // スレッドで実行する処理
        for (int i = 0; i < 5; i++) {
            System.out.println("スレッド実行中: " + i);
            try {
                Thread.sleep(1000); // 1秒待機
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

// 使用例
MyThread thread = new MyThread();
thread.start(); // スレッドの開始

public class MyRunnable implements Runnable {
    private final String name;

    public MyRunnable(String name) {
        this.name = name;
    }

    @Override
    public void run() {
        // スレッドで実行する処理
        for (int i = 0; i < 5; i++) {
            System.out.println(name + ": 処理実行中 " + i);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

// 使用例
Thread thread1 = new Thread(new MyRunnable("Thread-1"));
Thread thread2 = new Thread(new MyRunnable("Thread-2"));
thread1.start();
thread2.start();

// ラムダ式を使用した簡潔な実装
Runnable task = () -> {
    // スレッドで実行する処理
    System.out.println("ラムダ式で実装したスレッド処理");
};
new Thread(task).start();

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

public class ExecutorServiceExample {
    public static void main(String[] args) {
        // 固定数のスレッドプールを作成
        ExecutorService executor = Executors.newFixedThreadPool(3);

        try {
            // タスクの実行
            Future<?> future1 = executor.submit(() -> {
                System.out.println("タスク1実行中...");
                return "タスク1完了";
            });

            Future<?> future2 = executor.submit(() -> {
                System.out.println("タスク2実行中...");
                return "タスク2完了";
            });

            // 結果の取得
            System.out.println(future1.get());
            System.out.println(future2.get());

        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            // ExecutorServiceのシャットダウン
            executor.shutdown();
        }
    }
}

// 1. 単一スレッドのExecutor
ExecutorService singleExecutor = Executors.newSingleThreadExecutor();

// 2. キャッシュされたスレッドプール
ExecutorService cachedExecutor = Executors.newCachedThreadPool();

// 3. スケジュール実行が可能なExecutor
ScheduledExecutorService scheduledExecutor = Executors.newScheduledThreadPool(4);

// CPU数に基づくスレッドプールサイズの設定
int processors = Runtime.getRuntime().availableProcessors();
ExecutorService executor = Executors.newFixedThreadPool(processors);

executor.submit(() -> {
    try {
        // タスクの処理
    } catch (Exception e) {
        // 例外のログ記録
        logger.error("タスク実行中にエラーが発生", e);
        throw e;
    }
});

try {
    executor.shutdown();
    if (!executor.awaitTermination(60, TimeUnit.SECONDS)) {
        executor.shutdownNow();
    }
} catch (InterruptedException e) {
    executor.shutdownNow();
}

public class BankAccount {
    private int balance;

    // インスタンスメソッドの同期
    public synchronized void deposit(int amount) {
        balance += amount;
    }

    // staticメソッドの同期
    public static synchronized void transferLog(String message) {
        System.out.println("Transfer: " + message);
    }
}

public class InventoryManager {
    private final List<String> items = new ArrayList<>();
    private final Object lock = new Object(); // 同期用のロックオブジェクト

    public void addItem(String item) {
        // 特定のブロックのみを同期
        synchronized (lock) {
            items.add(item);
            System.out.println("Added: " + item);
        }
        // この部分は同期されない
        processItem(item);
    }

    private void processItem(String item) {
        // 非同期の処理
    }
}

   // 不適切な実装（デッドロックの危険）
   public void transfer(BankAccount to, int amount) {
       synchronized (this) {
           synchronized (to) {
               // 転送処理
           }
       }
   }

   // 改善された実装
   public void transfer(BankAccount to, int amount) {
       // 口座番号でロックの順序を固定
       BankAccount first = this.accountNumber < to.accountNumber ? this : to;
       BankAccount second = this.accountNumber < to.accountNumber ? to : this;

       synchronized (first) {
           synchronized (second) {
               // 転送処理
           }
       }
   }

import java.util.concurrent.locks.ReentrantLock;

public class BankAccountWithLock {
    private final ReentrantLock lock = new ReentrantLock();
    private int balance;

    public void deposit(int amount) {
        lock.lock();  // ロックの取得
        try {
            balance += amount;
        } finally {
            lock.unlock();  // 必ず解放
        }
    }

    public boolean tryTransfer(BankAccount to, int amount, long timeout) {
        // タイムアウト付きのロック取得
        try {
            if (lock.tryLock(timeout, TimeUnit.MILLISECONDS)) {
                try {
                    if (balance >= amount) {
                        balance -= amount;
                        to.deposit(amount);
                        return true;
                    }
                } finally {
                    lock.unlock();
                }
            }
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
        return false;
    }
}

import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

public class CacheManager {
    private final ReadWriteLock lock = new ReentrantReadWriteLock();
    private final Map<String, String> cache = new HashMap<>();

    public String getData(String key) {
        lock.readLock().lock();  // 読み取りロック
        try {
            return cache.get(key);
        } finally {
            lock.readLock().unlock();
        }
    }

    public void putData(String key, String value) {
        lock.writeLock().lock();  // 書き込みロック
        try {
            cache.put(key, value);
        } finally {
            lock.writeLock().unlock();
        }
    }
}

public class ResourceManager {
    private static final Object LOCK_1 = new Object();
    private static final Object LOCK_2 = new Object();

    public void process() {
        // 常に同じ順序でロックを取得
        synchronized (LOCK_1) {
            synchronized (LOCK_2) {
                // 処理
            }
        }
    }
}

public class TimeoutExample {
    private final Lock lock = new ReentrantLock();

    public void processWithTimeout() {
        try {
            // タイムアウト付きでロック取得を試みる
            if (lock.tryLock(1000, TimeUnit.MILLISECONDS)) {
                try {
                    // 処理
                } finally {
                    lock.unlock();
                }
            } else {
                // タイムアウト時の処理
                System.out.println("ロック取得がタイムアウトしました");
            }
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }
}

public class DeadlockDetector {
    public static void detectDeadlock() {
        ThreadMXBean threadBean = ManagementFactory.getThreadMXBean();
        long[] threadIds = threadBean.findDeadlockedThreads();

        if (threadIds != null) {
            ThreadInfo[] threadInfos = threadBean.getThreadInfo(threadIds);
            System.out.println("デッドロックを検出:");
            for (ThreadInfo info : threadInfos) {
                System.out.println(info.getThreadName() + " - " + 
                    info.getLockName() + " 待ち");
            }
        }
    }
}

import java.util.concurrent.CompletableFuture;

public class CompletableFutureExample {
    public CompletableFuture<String> fetchUserData(String userId) {
        return CompletableFuture.supplyAsync(() -> {
            // 非同期でユーザーデータを取得
            return "User:" + userId;
        }).thenApply(userData -> {
            // データの加工
            return userData + " (processed)";
        }).exceptionally(throwable -> {
            // 例外処理
            System.err.println("Error: " + throwable.getMessage());
            return "Default User Data";
        });
    }

    // 複数の非同期処理の組み合わせ
    public void processMultipleUsers() {
        CompletableFuture<String> user1 = fetchUserData("1");
        CompletableFuture<String> user2 = fetchUserData("2");

        CompletableFuture.allOf(user1, user2)
            .thenRun(() -> {
                System.out.println("All users processed");
            });
    }
}

public class AdvancedCompletableFuture {
    public void demonstrateAdvancedFeatures() {
        CompletableFuture<String> future1 = CompletableFuture
            .supplyAsync(() -> "Price:")
            .thenCombine(
                CompletableFuture.supplyAsync(() -> 100.0),
                (str, price) -> str + price
            );

        // タイムアウト処理の追加
        try {
            String result = future1
                .completeOnTimeout("Price:0.0", 1, TimeUnit.SECONDS)
                .get();
            System.out.println(result);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    // 非同期処理のエラーハンドリング
    public CompletableFuture<String> robustAsyncOperation() {
        return CompletableFuture
            .supplyAsync(() -> {
                if (Math.random() < 0.5) {
                    throw new RuntimeException("Random failure");
                }
                return "Success";
            })
            .handle((result, ex) -> {
                if (ex != null) {
                    return "Error handled: " + ex.getMessage();
                }
                return result;
            });
    }
}

import java.util.List;
import java.util.stream.Collectors;

public class ParallelStreamExample {
    public List<Integer> processNumbers(List<Integer> numbers) {
        return numbers.parallelStream()
            .filter(n -> n > 0)           // 正の数をフィルタリング
            .map(n -> n * 2)              // 各数を2倍
            .sorted()                      // ソート
            .collect(Collectors.toList()); // リストに収集
    }

    // パフォーマンス最適化の例
    public double calculateAverage(List<Double> values) {
        return values.parallelStream()
            .filter(v -> v != null)
            .mapToDouble(Double::doubleValue)
            .average()
            .orElse(0.0);
    }
}

public class ParallelStreamBestPractices {
    // 適切なスレッド数の設定
    static {
        // 利用可能なプロセッサ数に基づいてパラレリズムを設定
        System.setProperty(
            "java.util.concurrent.ForkJoinPool.common.parallelism",
            String.valueOf(Runtime.getRuntime().availableProcessors())
        );
    }

    // 大規模データセットの処理
    public void processLargeDataSet(List<String> data) {
        data.parallelStream()
            .filter(str -> str != null && !str.isEmpty())
            .map(String::toUpperCase)
            .forEach(str -> {
                // バッファリングして処理
                processBatch(str);
            });
    }

    private void processBatch(String data) {
        // バッチ処理の実装
    }
}

import java.util.concurrent.RecursiveTask;
import java.util.concurrent.ForkJoinPool;

public class ArraySumCalculator extends RecursiveTask<Long> {
    private static final int THRESHOLD = 1000;
    private final int[] array;
    private final int start;
    private final int end;

    public ArraySumCalculator(int[] array, int start, int end) {
        this.array = array;
        this.start = start;
        this.end = end;
    }

    @Override
    protected Long compute() {
        if (end - start <= THRESHOLD) {
            // 閾値以下なら直接計算
            return computeDirectly();
        }

        // タスクを分割して並列処理
        int middle = start + (end - start) / 2;
        ArraySumCalculator leftTask = 
            new ArraySumCalculator(array, start, middle);
        ArraySumCalculator rightTask = 
            new ArraySumCalculator(array, middle, end);

        leftTask.fork(); // 左半分を別スレッドで実行
        Long rightResult = rightTask.compute(); // 右半分を現在のスレッドで実行
        Long leftResult = leftTask.join(); // 左半分の結果を待機

        return leftResult + rightResult;
    }

    private long computeDirectly() {
        long sum = 0;
        for (int i = start; i < end; i++) {
            sum += array[i];
        }
        return sum;
    }

    // 使用例
    public static void main(String[] args) {
        int[] array = new int[100000];
        // 配列の初期化
        for (int i = 0; i < array.length; i++) {
            array[i] = i;
        }

        ForkJoinPool pool = new ForkJoinPool();
        ArraySumCalculator calculator = 
            new ArraySumCalculator(array, 0, array.length);
        long sum = pool.invoke(calculator);
        System.out.println("Sum: " + sum);
    }
}

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

public class ThreadPoolSizeCalculator {
    public static int calculateOptimalThreads(float targetCpuUtilization,
                                           float cpuRatio) {
        int cpuCount = Runtime.getRuntime().availableProcessors();

        // スレッド数 = CPU数 * CPU使用率 * (1 + 待機時間/CPU時間)
        int optimal = (int)(cpuCount * targetCpuUtilization * (1 + cpuRatio));
        return Math.max(optimal, 1); // 最低1スレッド
    }

    // 実装例
    public static ExecutorService createOptimalThreadPool() {
        int threadCount = calculateOptimalThreads(0.8f, 0.5f);
        return Executors.newFixedThreadPool(threadCount);
    }
}

public class ThreadExceptionHandler {
    public static class GlobalExceptionHandler implements Thread.UncaughtExceptionHandler {
        @Override
        public void uncaughtException(Thread t, Throwable e) {
            System.err.println("Thread " + t.getName() + " threw exception: " + e.getMessage());
            // ログ記録やメトリクス収集
            logException(e);
        }

        private void logException(Throwable e) {
            // ログ記録の実装
        }
    }

    // ExecutorServiceでの例外ハンドリング
    public static ExecutorService createExecutorWithExceptionHandler(int threadCount) {
        ThreadFactory factory = new ThreadFactory() {
            @Override
            public Thread newThread(Runnable r) {
                Thread thread = new Thread(r);
                thread.setUncaughtExceptionHandler(new GlobalExceptionHandler());
                return thread;
            }
        };

        return Executors.newFixedThreadPool(threadCount, factory);
    }
}

public class FutureExceptionHandler {
    private final ExecutorService executor;

    public FutureExceptionHandler(int threadCount) {
        this.executor = Executors.newFixedThreadPool(threadCount);
    }

    public void executeWithExceptionHandling(Runnable task) {
        Future<?> future = executor.submit(task);
        try {
            future.get(); // 完了を待機
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        } catch (ExecutionException e) {
            handleExecutionException(e.getCause());
        }
    }

    private void handleExecutionException(Throwable cause) {
        // 例外の種類に応じた処理
        if (cause instanceof BusinessException) {
            // ビジネスロジック例外の処理
        } else if (cause instanceof SystemException) {
            // システム例外の処理
        } else {
            // 予期せぬ例外の処理
        }
    }
}

// 1. 遅延初期化のダブルチェックロッキング
public class DoubleCheckedSingleton {
    private static volatile DoubleCheckedSingleton instance;

    private DoubleCheckedSingleton() {}

    public static DoubleCheckedSingleton getInstance() {
        if (instance == null) {
            synchronized (DoubleCheckedSingleton.class) {
                if (instance == null) {
                    instance = new DoubleCheckedSingleton();
                }
            }
        }
        return instance;
    }
}

// 2. 初期化ホルダーイディオム
public class HolderSingleton {
    private HolderSingleton() {}

    private static class Holder {
        private static final HolderSingleton INSTANCE = new HolderSingleton();
    }

    public static HolderSingleton getInstance() {
        return Holder.INSTANCE;
    }
}

// 3. enumを使用した実装
public enum EnumSingleton {
    INSTANCE;

    private final ConnectionPool connectionPool;

    EnumSingleton() {
        connectionPool = new ConnectionPool();
    }

    public ConnectionPool getConnectionPool() {
        return connectionPool;
    }
}

public final class ImmutableConfig {
    private final String serverUrl;
    private final int maxConnections;

    public ImmutableConfig(String serverUrl, int maxConnections) {
        this.serverUrl = serverUrl;
        this.maxConnections = maxConnections;
    }

    // getterのみ提供（setterなし）
    public String getServerUrl() {
        return serverUrl;
    }

    public int getMaxConnections() {
        return maxConnections;
    }
}

public class AtomicCounter {
    private final AtomicInteger counter = new AtomicInteger(0);

    public int increment() {
        return counter.incrementAndGet();
    }

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

public class OptimizedLocking {
    private final Lock lock = new ReentrantLock();
    private final Map<String, Object> cache = new HashMap<>();

    public Object getFromCache(String key) {
        // 読み取り操作はロック不要
        Object value = cache.get(key);
        if (value != null) {
            return value;
        }

        // 必要な場合のみロック
        lock.lock();
        try {
            value = cache.get(key);
            if (value == null) {
                value = computeValue(key);
                cache.put(key, value);
            }
            return value;
        } finally {
            lock.unlock();
        }
    }

    private Object computeValue(String key) {
        // 値の計算ロジック
        return "computed-" + key;
    }
}

public class RaceConditionDetection {
    // 競合状態が発生しやすい実装例
    public class UnsafeCounter {
        private int count = 0;

        public void increment() {
            count++; // 非アトミック操作
        }

        public int getCount() {
            return count;
        }
    }

    // 競合状態を修正した実装
    public class SafeCounter {
        private final AtomicInteger count = new AtomicInteger(0);

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

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

    // 競合状態のテスト
    public void testRaceCondition() {
        final int THREAD_COUNT = 100;
        final int ITERATIONS = 1000;

        ExecutorService executor = Executors.newFixedThreadPool(THREAD_COUNT);
        UnsafeCounter unsafeCounter = new UnsafeCounter();
        SafeCounter safeCounter = new SafeCounter();

        // 非安全な実装のテスト
        for (int i = 0; i < THREAD_COUNT; i++) {
            executor.submit(() -> {
                for (int j = 0; j < ITERATIONS; j++) {
                    unsafeCounter.increment();
                }
            });
        }

        // 安全な実装のテスト
        for (int i = 0; i < THREAD_COUNT; i++) {
            executor.submit(() -> {
                for (int j = 0; j < ITERATIONS; j++) {
                    safeCounter.increment();
                }
            });
        }
    }
}

@JCStressTest
@Outcome(id = "1, 2", expect = Expect.ACCEPTABLE)
@Outcome(id = "2, 1", expect = Expect.ACCEPTABLE)
@Outcome(id = "1, 1", expect = Expect.FORBIDDEN)
@State
public class ConcurrencyTest {
    private int x;
    private int y;

    @Actor
    public void actor1() {
        x = 1;
        y = 2;
    }

    @Actor
    public void actor2() {
        x = 2;
        y = 1;
    }

    @Arbiter
    public void arbiter(II_Result r) {
        r.r1 = x;
        r.r2 = y;
    }
}

public class ThreadDumpAnalyzer {
    public static void generateThreadDump() {
        ThreadMXBean threadMXBean = ManagementFactory.getThreadMXBean();
        ThreadInfo[] threadInfos = threadMXBean.dumpAllThreads(true, true);

        for (ThreadInfo info : threadInfos) {
            System.out.println(formatThreadInfo(info));
        }
    }

    private static String formatThreadInfo(ThreadInfo info) {
        StringBuilder sb = new StringBuilder();
        sb.append("\"").append(info.getThreadName()).append("\"");
        sb.append(" Id=").append(info.getThreadId());
        sb.append(" ").append(info.getThreadState());

        if (info.getLockName() != null) {
            sb.append(" on ").append(info.getLockName());
        }
        if (info.getLockOwnerName() != null) {
            sb.append(" owned by \"").append(info.getLockOwnerName())
              .append("\" Id=").append(info.getLockOwnerId());
        }

        StackTraceElement[] stackTrace = info.getStackTrace();
        for (StackTraceElement element : stackTrace) {
            sb.append("\n\tat ").append(element);
        }

        return sb.toString();
    }
}

@State(Scope.Thread)
@BenchmarkMode(Mode.AverageTime)
@OutputTimeUnit(TimeUnit.MICROSECONDS)
public class ConcurrencyBenchmark {
    private ExecutorService executor;
    private final int TASK_COUNT = 1000;

    @Setup
    public void setup() {
        executor = Executors.newFixedThreadPool(
            Runtime.getRuntime().availableProcessors()
        );
    }

    @Benchmark
    public void measureParallelExecution() {
        List<CompletableFuture<Void>> futures = new ArrayList<>();

        for (int i = 0; i < TASK_COUNT; i++) {
            futures.add(CompletableFuture.runAsync(() -> {
                // ベンチマーク対象の処理
                heavyComputation();
            }, executor));
        }

        CompletableFuture.allOf(
            futures.toArray(new CompletableFuture[0])
        ).join();
    }

    private void heavyComputation() {
        // 重い処理のシミュレーション
        try {
            Thread.sleep(1);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }

    @TearDown
    public void tearDown() {
        executor.shutdown();
    }
}

public class ProfilingExample {
    public static void main(String[] args) {
        // プロファイリング用のマーカー
        System.setProperty("visualvm.display.name", "ConcurrencyTest");

        ExecutorService executor = Executors.newFixedThreadPool(4);
        try {
            for (int i = 0; i < 1000; i++) {
                executor.submit(() -> {
                    // CPU負荷の高い処理
                    performCPUIntensiveTask();

                    // メモリ負荷の高い処理
                    performMemoryIntensiveTask();
                });
            }
        } finally {
            executor.shutdown();
        }
    }

    private static void performCPUIntensiveTask() {
        // CPUプロファイリング用の処理
        for (int i = 0; i < 1000000; i++) {
            Math.sqrt(i);
        }
    }

    private static void performMemoryIntensiveTask() {
        // メモリプロファイリング用の処理
        List<byte[]> list = new ArrayList<>();
        for (int i = 0; i < 100; i++) {
            list.add(new byte[1024]);
        }
    }
}

public class PerformanceOptimization {
    // 1. バッチ処理の最適化
    public void optimizedBatchProcessing(List<Task> tasks) {
        int batchSize = calculateOptimalBatchSize(tasks.size());
        List<List<Task>> batches = Lists.partition(tasks, batchSize);

        CompletableFuture<?>[] futures = batches.stream()
            .map(batch -> CompletableFuture.runAsync(() -> {
                processBatch(batch);
            }))
            .toArray(CompletableFuture[]::new);

        CompletableFuture.allOf(futures).join();
    }

    // 2. キャッシュの活用
    private final LoadingCache<String, Data> cache = CacheBuilder.newBuilder()
        .maximumSize(1000)
        .expireAfterWrite(10, TimeUnit.MINUTES)
        .build(new CacheLoader<String, Data>() {
            @Override
            public Data load(String key) {
                return loadData(key);
            }
        });

    // 3. 効率的なデータ構造の使用
    private final ConcurrentHashMap<String, Object> concurrentMap = 
        new ConcurrentHashMap<>();
    private final BlockingQueue<Task> taskQueue = 
        new LinkedBlockingQueue<>();
}

import java.util.concurrent.*;
import java.util.Set;
import java.util.concurrent.atomic.AtomicInteger;

public class ParallelWebCrawler {
    private final ExecutorService executor;
    private final Set<String> visitedUrls = 
        ConcurrentHashMap.newKeySet();
    private final BlockingQueue<String> urlQueue = 
        new LinkedBlockingQueue<>();
    private final AtomicInteger activeThreads = new AtomicInteger(0);
    private final int maxDepth;

    public ParallelWebCrawler(int threadCount, int maxDepth) {
        this.executor = Executors.newFixedThreadPool(threadCount);
        this.maxDepth = maxDepth;
    }

    public void crawl(String startUrl) {
        urlQueue.offer(startUrl);
        activeThreads.incrementAndGet();

        while (activeThreads.get() > 0) {
            String url = urlQueue.poll();
            if (url != null) {
                processCrawling(url, 0);
            }
        }

        executor.shutdown();
    }

    private void processCrawling(String url, int depth) {
        if (depth >= maxDepth || !visitedUrls.add(url)) {
            activeThreads.decrementAndGet();
            return;
        }

        executor.submit(() -> {
            try {
                // URLからコンテンツを取得
                String content = fetchContent(url);
                // リンクを抽出
                Set<String> links = extractLinks(content);

                // 新しいリンクをキューに追加
                links.stream()
                    .filter(link -> !visitedUrls.contains(link))
                    .forEach(link -> {
                        urlQueue.offer(link);
                        activeThreads.incrementAndGet();
                    });
            } catch (Exception e) {
                System.err.println("Error crawling " + url + ": " + e.getMessage());
            } finally {
                activeThreads.decrementAndGet();
            }
        });
    }

    private String fetchContent(String url) {
        // HTTP要求の実装
        return "Simulated content";
    }

    private Set<String> extractLinks(String content) {
        // リンク抽出ロジックの実装
        return new HashSet<>();
    }
}

public class AdvancedWebCrawler extends ParallelWebCrawler {
    private final RateLimiter rateLimiter;
    private final MetricsCollector metrics;

    public class MetricsCollector {
        private final AtomicInteger successfulRequests = new AtomicInteger(0);
        private final AtomicInteger failedRequests = new AtomicInteger(0);

        public void recordSuccess() {
            successfulRequests.incrementAndGet();
        }

        public void recordFailure() {
            failedRequests.incrementAndGet();
        }

        public String getStats() {
            return String.format(
                "成功: %d, 失敗: %d", 
                successfulRequests.get(), 
                failedRequests.get()
            );
        }
    }
}

import java.awt.image.BufferedImage;
import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.RecursiveAction;

public class ParallelImageProcessor {
    private static final int THRESHOLD = 100_000; // ピクセル数のしきい値

    public class ImageProcessingTask extends RecursiveAction {
        private final BufferedImage image;
        private final int startX, startY, width, height;

        public ImageProcessingTask(BufferedImage image, 
                                 int startX, int startY, 
                                 int width, int height) {
            this.image = image;
            this.startX = startX;
            this.startY = startY;
            this.width = width;
            this.height = height;
        }

        @Override
        protected void compute() {
            if (width * height <= THRESHOLD) {
                processImageChunk();
            } else {
                subdivideAndProcess();
            }
        }

        private void processImageChunk() {
            for (int y = startY; y < startY + height; y++) {
                for (int x = startX; x < startX + width; x++) {
                    int rgb = image.getRGB(x, y);
                    int newRgb = applyFilter(rgb);
                    image.setRGB(x, y, newRgb);
                }
            }
        }

        private void subdivideAndProcess() {
            int halfWidth = width / 2;
            int halfHeight = height / 2;

            invokeAll(
                new ImageProcessingTask(image, startX, startY, 
                    halfWidth, halfHeight),
                new ImageProcessingTask(image, startX + halfWidth, startY, 
                    width - halfWidth, halfHeight),
                new ImageProcessingTask(image, startX, startY + halfHeight, 
                    halfWidth, height - halfHeight),
                new ImageProcessingTask(image, startX + halfWidth, 
                    startY + halfHeight, 
                    width - halfWidth, height - halfHeight)
            );
        }

        private int applyFilter(int rgb) {
            // フィルター処理の実装
            return rgb;
        }
    }
}

public class ImageFilters {
    // グレースケール変換
    public static int toGrayscale(int rgb) {
        int r = (rgb >> 16) & 0xFF;
        int g = (rgb >> 8) & 0xFF;
        int b = rgb & 0xFF;

        int gray = (r + g + b) / 3;
        return (gray << 16) | (gray << 8) | gray;
    }

    // ぼかしフィルター
    public static BufferedImage applyBlur(BufferedImage source) {
        int width = source.getWidth();
        int height = source.getHeight();
        BufferedImage result = new BufferedImage(
            width, height, BufferedImage.TYPE_INT_RGB);

        ForkJoinPool pool = new ForkJoinPool();
        pool.invoke(new ImageProcessingTask(source, result, 
            0, 0, width, height));

        return result;
    }
}

public class ParallelDataProcessor {
    private final ExecutorService executor;
    private final int batchSize;

    public ParallelDataProcessor(int threadCount, int batchSize) {
        this.executor = Executors.newFixedThreadPool(threadCount);
        this.batchSize = batchSize;
    }

    public <T> void processData(List<T> data, 
                              Consumer<T> processor) {
        List<List<T>> batches = splitIntoBatches(data);

        List<CompletableFuture<Void>> futures = batches.stream()
            .map(batch -> CompletableFuture.runAsync(() -> {
                for (T item : batch) {
                    processor.accept(item);
                }
            }, executor))
            .collect(Collectors.toList());

        CompletableFuture.allOf(
            futures.toArray(new CompletableFuture[0])
        ).join();
    }

    private <T> List<List<T>> splitIntoBatches(List<T> data) {
        List<List<T>> batches = new ArrayList<>();
        for (int i = 0; i < data.size(); i += batchSize) {
            batches.add(data.subList(i, 
                Math.min(i + batchSize, data.size())));
        }
        return batches;
    }
}

public class AdvancedDataProcessor {
    private final ExecutorService executor;
    private final BlockingQueue<DataBatch> workQueue;
    private final AtomicBoolean isProcessing;

    public class DataBatch {
        private final List<?> data;
        private final int batchId;

        public DataBatch(List<?> data, int batchId) {
            this.data = data;
            this.batchId = batchId;
        }
    }

    public void startProcessing() {
        int workerCount = Runtime.getRuntime().availableProcessors();
        for (int i = 0; i < workerCount; i++) {
            executor.submit(new DataProcessor());
        }
    }

    private class DataProcessor implements Runnable {
        @Override
        public void run() {
            while (isProcessing.get() || !workQueue.isEmpty()) {
                try {
                    DataBatch batch = workQueue.poll(
                        100, TimeUnit.MILLISECONDS);
                    if (batch != null) {
                        processBatch(batch);
                    }
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                    break;
                }
            }
        }

        private void processBatch(DataBatch batch) {
            // バッチ処理の実装
            try {
                // データ処理ロジック
                Thread.sleep(100); // シミュレーション用
            } catch (Exception e) {
                System.err.println("Error processing batch " + 
                    batch.batchId + ": " + e.getMessage());
            }
        }
    }
}

/**
 * 課題1: 並行処理のパフォーマンス比較
 * シングルスレッドと異なるスレッド数での処理時間を比較
 */
public class Exercise1 {
    public static void main(String[] args) {
        // データ準備
        List<Integer> numbers = IntStream.range(0, 1_000_000)
            .boxed().collect(Collectors.toList());

        // シングルスレッド処理
        long start = System.currentTimeMillis();
        processSequential(numbers);
        long singleThreadTime = System.currentTimeMillis() - start;

        // マルチスレッド処理（4スレッド）
        start = System.currentTimeMillis();
        processParallel(numbers, 4);
        long multiThreadTime = System.currentTimeMillis() - start;

        System.out.println("シングルスレッド時間: " + singleThreadTime + "ms");
        System.out.println("マルチスレッド時間: " + multiThreadTime + "ms");
    }

    private static void processSequential(List<Integer> numbers) {
        // 実装してください
    }

    private static void processParallel(List<Integer> numbers, int threadCount) {
        // 実装してください
    }
}

/**
 * 課題2: スレッドセーフなキャッシュの実装
 * 読み取り優先のキャッシュを実装
 */
public class Exercise2 {
    public interface ThreadSafeCache<K, V> {
        V get(K key);
        void put(K key, V value);
        void clear();
        int size();
    }

    // 実装してください
}

/**
 * 課題3: 生産者-消費者パターンの実装
 * ブロッキングキューを使用した実装
 */
public class Exercise3 {
    public interface MessageQueue<T> {
        void send(T message);
        T receive();
        boolean isEmpty();
    }

    // 実装してください
}

/**
 * プロジェクト1: 並行Webクローラー
 * - マルチスレッドによるWebページ取得
 * - データの並行処理
 * - 結果の集約
 */
public class WebCrawlerProject {
    public interface WebCrawler {
        void crawl(String startUrl, int depth);
        List<String> getVisitedUrls();
        Map<String, String> getPageContents();
    }
}

/**
 * プロジェクト2: 分散計算フレームワーク
 * - タスクの分割と配布
 * - 結果の収集と集約
 * - 障害復旧機能
 */
public class DistributedComputingProject {
    public interface ComputeNode {
        void submitTask(Task task);
        Result getResult();
        void join(NodeNetwork network);
        void leave(NodeNetwork network);
    }
}

/**
 * プロジェクト3: リアルタイムチャットシステム
 * - メッセージの非同期処理
 * - ユーザーセッション管理
 * - プッシュ通知
 */
public class ChatSystemProject {
    public interface ChatServer {
        void start(int port);
        void broadcast(Message message);
        void addUser(User user);
        void removeUser(User user);
    }
}

　4. 障害対応演習の実施