import java.util.concurrent.Executor;

/**
 * Executor 인터페이스의 execute 메서드 사용 예제코드로 이 메서드의 목적은 작업(Runnable 객체)을 받아서 어떻게 실행할지 결정하는 것이다.
 * execute 메서드는 매개변수로 Runnable 태스크를 받고, 반환값이 없습니다(void 반환).
 * 이 메서드는 단순히 받은 태스크를 실행하는 기능을 가지며, 이 태스크의 실행을 스레드 풀에 위임하거나 즉시 실행할 수 있다.
 */
public class SimpleExecutorExample {

    public static void main(String[] args) {

        Executor executor = new CustomExecutor();

        // Runnable 태스크 생성 및 실행
        Runnable task1 = () -> {
            System.out.println("Running task 1 in: " + Thread.currentThread().getName());
        };

        Runnable task2 = () -> {
            System.out.println("Running task 2 in: " + Thread.currentThread().getName());
        };

        // 태스크를 Executor를 통해 실행
        executor.execute(task1);
        executor.execute(task2);
    }

    //Executor 인터페이스를 구현하며, execute 메서드 내에서 받은 Runnable 객체를 새로운 스레드에서 실행
    static class CustomExecutor implements Executor {
        @Override
        public void execute(Runnable task) {
            Thread newThread = new Thread(task);
            newThread.start();  // 새 스레드에서 Runnable 태스크 실행
        }
    }
}

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;

public class SimpleArrayBlockingQueueExample {

    public static void main(String[] args) {

        // ArrayBlockingQueue 에 용량 5로 초기화
        BlockingQueue<String> queue = new ArrayBlockingQueue<>(5);

        // 생산자 스레드
        Thread producer = new Thread(() -> {
            String[] events = {"First", "Second", "Third", "Fourth", "Fifth"};
            try {
                for (String event : events) {
                    queue.put(event); // 큐가 가득 찰 경우 블록됨
                    System.out.println("Produced: " + event);
                }
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        });

        // 소비자 스레드
        Thread consumer = new Thread(() -> {
            try {
                while (!Thread.currentThread().isInterrupted()) {
                    String event = queue.take(); // 큐가 비었을 경우 블록됨
                    System.out.println("Consumed: " + event);
                }
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        });

        producer.start();
        consumer.start();

        // 스레드를 종료하기 위한 코드..
    }
}

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;

public class SimpleLinkedBlockingQueueExample {

    public static void main(String[] args) {

        // LinkedBlockingQueue 인스턴스 생성
        BlockingQueue<String> queue = new LinkedBlockingQueue<>();

        // 생산자 스레드 생성 및 실행
        Thread producer = new Thread(() -> {
            String[] events = {"Event-1", "Event-2", "Event-3", "Event-4", "Event-5", "Event-6", "Event-7"};
            try {
                for (String event : events) {
                    queue.put(event);  // 큐에 이벤트 추가, 큐가 가득 차면 블록
                    System.out.println("Produced: " + event);
                }
                queue.put("END");  // 종료 신호로 "END" 이벤트 추가
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        });

        // 소비자 스레드 생성 및 실행
        Thread consumer = new Thread(() -> {
            try {
                while (true) {
                    String event = queue.take();  // 큐에서 이벤트 제거, 큐가 비어 있으면 블록
                    if ("END".equals(event)) {
                        break;  // "END" 이벤트 수신 시 종료
                    }
                    System.out.println("Consumed: " + event);
                }
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        });

        producer.start();
        consumer.start();
    }
}

import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

public class ScheduledTaskExample {
    public static void main(String[] args) {
        ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(1);

        Runnable task = () -> System.out.println("Task executed at: " + System.currentTimeMillis());

        // 5초 후에 작업 실행
        scheduler.schedule(task, 5, TimeUnit.SECONDS);

        // 10초 후에 시작하여 3초마다 반복 실행
        scheduler.scheduleAtFixedRate(task, 10, 3, TimeUnit.SECONDS);

        // 애플리케이션 종료 시 스케줄러 종료
        scheduler.schedule(() -> {
            System.out.println("Scheduler shutting down.");
            scheduler.shutdown();
        }, 60, TimeUnit.SECONDS);
    }
}

import java.util.concurrent.Semaphore;
import java.util.concurrent.TimeUnit;

/**
 * Semaphore(세마포어)를 활용하여 리소스에 대한 동시 접근을 제어하는 방법을 보여주는 예제 코드이다.
 * Semaphore 를 사용하여 리소스를 안전하게 공유하면서도 동시에 하나의 스레드만 작업을 수행하게 함으로써,
 * 리소스 충돌이나 데드락을 방지할 수 있다.
 */
public class SimpleSyncSemaphoreExample {

    public static void main(String[] args) {

        //최대 1초 동안 세마포어 허용을 시도합니다. 허용을 얻으면 true를 반환하고, 실패하면 false를 반환
        Semaphore semaphore = new Semaphore(1);  // 1개의 허용을 가진 세마포어

        Runnable longRunningTask = () -> {
            boolean permit = false;
            try {
                permit = semaphore.tryAcquire(1, TimeUnit.SECONDS);
                if (permit) {
                    System.out.println("Semaphore acquired");
                    Thread.sleep(5000); // 긴 작업 시뮬레이션
                } else {
                    System.out.println("Could not acquire semaphore");
                }
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            } finally {
                if (permit) {
                    semaphore.release();
                    System.out.println("Semaphore released");
                }
            }
        };

        new Thread(longRunningTask).start();
        new Thread(longRunningTask).start();
    }
}

import java.util.concurrent.CountDownLatch;

/**
 * CountDownLatch 를 사용하여 동기화 기법을 구현한 예제 코드이다.
 * 이 클래스는 여러 스레드가 동시에 실행되고 작업이 모두 완료할 때까지 기다리게 하는 데 사용되며,
 * 주로 멀티 스레드 프로그램에서 모든 스레드의 작업 완료를 동기화하는 데 적합하다.
 */
public class SimpleSyncCountDownLatchExample {

    public static void main(String[] args) {

        final int count = 3;    //스레드 갯수
        CountDownLatch latch = new CountDownLatch(count);

        for (int i = 1; i <= count; i++) {
            new Thread(() -> {
                System.out.println(Thread.currentThread().getName() + " started.");
                try {
                    Thread.sleep(1000);  // 시뮬레이션을 위해 각 스레드를 1초 동안 지연
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
                //latch.countDown(); 호출로 래치 카운트를 감소시키며
                //모든 스레드가 이 메서드를 호출하고 "finished" 메시지를 출력하면 래치 카운트는 0이 된다.
                latch.countDown();  // 래치 카운트를 감소
                System.out.println(Thread.currentThread().getName() + " finished.");
            }).start();
        }

        try {
            //#래치 대기
            //메인 스레드는 latch.await();를 호출하여 모든 스레드가 작업을 완료할 때까지 대기
            //모든 스레드가 countDown()을 호출하여 카운트가 0이 되면, await() 메서드 다음의 코드가 실행되어 "All threads have finished." 메시지를 출력
            latch.await();  // 모든 스레드가 완료될 때까지 대기
            System.out.println("All threads have finished.");
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }
}

package com.modern.java.practical.executor.example;

import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;

/**
 * CyclicBarrier 를 사용하여 멀티스레드 프로그래밍에서 동기화를 구현한 예제 코드이다.
 * CyclicBarrier 는 주어진 수의 스레드들이 모두 특정 지점에 도달할 때까지 기다리게 한 후,
 * 모든 스레드가 도착하면 지정된 작업을 실행하는 동기화 기구이다.
 * 이 예제는 세 개의 스레드가 각각 장벽에 도달하고, 모두 도달했을 때 추가 작업을 수행하는 과정을 보여준다.
 */
public class SimpleCyclicBarrierExample {

    public static void main(String[] args) {

        final int count = 3;

        //첫 번째는 파라미터는 장벽을 통과하기 위해 필요한 스레드 수(count)
        //두 번째는 모든 스레드가 장벽에 도달했을 때 실행될 작업
        CyclicBarrier barrier = new CyclicBarrier(count, () -> {
            // 모든 스레드가 도달하면 실행될 작업
            System.out.println("All parties are arrived at barrier, let's play");
        });

        //for 반복문을 사용하여 세 개의 스레드를 생성하고 시작
        //각 스레드는 CyclicBarrier 의 await() 메소드를 호출하여 장벽에서 대기
        //스레드는 "is waiting at barrier" 메시지를 출력하고, await() 호출을 통해 다른 스레드들도 장벽에 도달할 때까지 대기
        //모든 스레드가 장벽에 도달하면, CyclicBarrier 에 설정된 작업이 실행되고,
        //각 스레드는 "has crossed the barrier" 메시지를 출력한 후 await() 메소드로부터 반환된다.
        for (int i = 0; i < count; i++) {
            new Thread(() -> {
                try {
                    System.out.println(Thread.currentThread().getName() + " is waiting at barrier");
                    barrier.await();
                    System.out.println(Thread.currentThread().getName() + " has crossed the barrier");
                } catch (InterruptedException | BrokenBarrierException e) {
                    Thread.currentThread().interrupt();
                }
            }).start();
        }
    }
}

import java.util.concurrent.Phaser;

/**
 * Phaser 는 자바 컨커런트 API에서 제공하는 동기화 기구 중 하나로,
 * CyclicBarrier와 CountDownLatch의 기능을 합친 것과 유사하다.
 * Phaser 는 다단계 계산에서 여러 단계를 거쳐야 할 때 유용하게 사용될 수 있으며
 * 각 단계에서 특정 수의 스레드가 작업을 완료할 때까지 기다린 후 다음 단계로 넘어갈 수 있게 도와준다.
 */
public class SimpleSyncPhaserExample {

    public static void main(String[] args) {

        //new Phaser(1)은 메인 스레드가 이미 참여하고 있음을 의미. 초기 참가자 수를 '1'로 설정하여 현재(메인) 스레드를 포함
        final Phaser phaser = new Phaser(1);

        System.out.println("Starting");

        // 세 개의 스레드 생성 및 시작
        for (int i = 0; i < 3; i++) {
            int finalI = i + 1;
            Thread thread = new Thread(() -> {
                phaser.register();  // 스레드를 페이저에 등록, 각 스레드가 Phaser의 단계 관리에 포함

                //각 스레드는 3개의 단계(0, 1, 2)를 순차적으로 실행하면서 각 단계가 끝날 때마다
                //phaser.arriveAndAwaitAdvance()를 호출하여 다음 단계로 넘어가기 전에 모든 스레드의 단계 완료를 기다림
                for (int phase = 0; phase < 3; phase++) {
                    System.out.println("Thread " + finalI + " doing work for phase " + phase);
                    phaser.arriveAndAwaitAdvance();  // 현재 단계를 완료하고 다음 단계 전에 기다림
                }

                //각 스레드는 모든 단계를 완료한 후 phaser.arriveAndDeregister()를 호출하여 자신을 Phaser에서 해제
                //메인 스레드는 phaser.isTerminated()가 true가 될 때까지 (즉, 모든 스레드가 Phaser에서 해제될 때까지)
                //phaser.arriveAndAwaitAdvance()를 반복 호출하여 각 단계의 완료를 기다림
                phaser.arriveAndDeregister(); // 완료 후 등록 해제
            });
            thread.start();
        }

        // 모든 스레드의 단계가 끝날 때까지 기다리고 마지막 등록 해제
        while (!phaser.isTerminated()) {
            phaser.arriveAndAwaitAdvance(); // 메인 스레드가 각 단계를 완료하기를 기다림
        }
        System.out.println("All phases are completed.");
    }
}

import java.util.concurrent.Exchanger;

/**
 * Exchanger 는 자바의 java.util.concurrent 패키지에 있는 동기화 도구로,
 * 두 스레드 간에 데이터를 교환할 수 있도록 설계되었으며
 * 이 도구는 두 스레드가 데이터를 교환할 준비가 될 때까지 블록되도록 하여, 스레드 간의 안정적인 데이터 전달을 보장한다.
 * Exchanger 는 주로 사용자 상태, 버퍼 등을 교환하거나 재사용하는 데 유용하다.
 */
public class SimpleSyncExchangerExample {

    public static void main(String[] args) {
        Exchanger<String> exchanger = new Exchanger<>();

        //exchange(V x): 현재 스레드가 다른 스레드로부터 객체를 받을 때까지 기다리고 교환에 성공하면 상대 스레드로부터 받은 객체를 반환
        //exchange() 메서드를 호출할 때 자신의 데이터를 인자로 전달하고, 다른 스레드로부터 데이터를 받는다.
        //이 과정에서 두 스레드 모두 exchange() 메서드에서 블로킹될 수 있으며, 서로 교환할 준비가 되면 블로킹이 해제되고 데이터 교환이 이루어진다.

        // 스레드 A
        new Thread(() -> {
            try {
                String message = "Message from Thread A";
                // 스레드 A가 보낸 메시지와 스레드 B로부터 받은 메시지를 교환
                String response = exchanger.exchange(message);
                System.out.println("Thread A received: " + response);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }).start();

        // 스레드 B
        new Thread(() -> {
            try {
                String message = "Message from Thread B";
                // 스레드 B가 보낸 메시지와 스레드 A로부터 받은 메시지를 교환
                String response = exchanger.exchange(message);
                System.out.println("Thread B received: " + response);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }).start();
    }
}

package com.modern.java.practical.executor.example;

class SharedObject {
    private volatile int volatileCounter = 0;
    private int synchronizedCounter = 0;
    
    //volatile 변수를 사용한 메소드
    //메모리 가시성은 보장하지만 "경쟁 상태(race condition)"로 원장성을 보장하지 못함
    //=> 복잡한 계산이 아닌 간단한 상태감시 등 데이터 변경 사용
    public void incrementVolatileCounter() {
        volatileCounter++;  // 직접 메모리에서 읽고 쓰기 때문에 모든 스레드에게 가시적
    }

    //synchronized 블록을 사용한 메소드
    //incrementSynchronizedCounter 메소드는 스레드가 메소드에 진입할 때 락(lock)을 획득하고, 메소드를 완료할 때 락을 해제
    //=> 가시성과 원장성을 보장
    public synchronized void incrementSynchronizedCounter() {
        synchronizedCounter++;  // 이 메소드는 동기화되어 있으므로 한 번에 하나의 스레드만 접근 가능
    }

    public int getVolatileCounter() {
        return volatileCounter;
    }

    public int getSynchronizedCounter() {
        return synchronizedCounter;
    }
}

public class SimpleSyncMemoryConsistencyExample {

    public static void main(String[] args) throws InterruptedException {
        final SharedObject sharedObject = new SharedObject();
        Runnable incrementTask = () -> {
            for (int i = 0; i < 10000; i++) {
                sharedObject.incrementVolatileCounter();
                sharedObject.incrementSynchronizedCounter();
            }
        };

        Thread t1 = new Thread(incrementTask);
        Thread t2 = new Thread(incrementTask);
        t1.start();
        t2.start();

        t1.join();
        t2.join();

        System.out.println("Volatile counter value: " + sharedObject.getVolatileCounter());
        System.out.println("Synchronized counter value: " + sharedObject.getSynchronizedCounter());
    }
}

package com.modern.java.practical.executor.example;

/**
 * volatile 변수를 사용하여 status 라는 변수를 두 스레드 간의 상태 정보를 공유
 */
public class SimpleSyncVolatileExample {

    private volatile boolean status = true;  // 시작 상태는 true (계속 실행)

    public void execute() {
        Thread stateMonitor = new Thread(() -> {
            while (status) {  // status가 true인 동안 계속 루프
                // 여기에는 실제 작업 코드가 들어갈 수 있습니다.
                System.out.println("StateMonitor: Status Success");
            }
            System.out.println("StateMonitor: Status changed to false, stopping monitor.");
        });

        Thread stateChanger = new Thread(() -> {
            try {
                Thread.sleep(2000);  // 2초 대기
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
            status = false;  // status를 false로 변경
            System.out.println("StateChanger: Status set to false.");
        });

        stateMonitor.start();
        stateChanger.start();
    }

    public static void main(String[] args) {
        new SimpleSyncVolatileExample().execute();
    }
}