멀티스레딩

class Processor extends Thread{
  
  private boolean running = false;
  private volatile int counter = 0;
	
  @override
  public void run(){
    
    while(running){
      System.out.println("hello");
      counter++; 
    }
  }
}

public class App{
  
  public static void main(String[] args){
    Processor proc1 = new Processor();
    Processor proc2 = new Processor();
    
    proc1.start();
    proc2.start();
    // proc1 스레드가 counter++ 연산하는 도중에 proc2 스레드가 counter++ 연산을 실행한다면?
    // proc1 스레드가 메인메모리에 증가된 값을 쓰기전에 proc2 스레드가 값을 읽어 증가시켜 
    // 결국 같은 값을 메인메모리에 쓰게 된다. 이런 경우 synchronized 키워드가 필요하다. 
  }
}

import java.util.ArrayList;
import java.util.List;
import java.util.Random;

public class Worker {

	private Random random = new Random();

	private List<Integer> list1 = new ArrayList<Integer>();
	private List<Integer> list2 = new ArrayList<Integer>();

  	// list1만 접근한다.
	public synchronized void stageOne() {
			try {
				Thread.sleep(1);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			list1.add(random.nextInt(100));
	}

  	// list2만 접근한다.
	public synchronized void stageTwo() {
			try {
				Thread.sleep(1);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			list2.add(random.nextInt(100));
	}

  // 두 스레드가 같은 인스턴스를 공유하므로 한 스레드가 고유 락을 획득하면
  // 다른 스레드는 락을 획득한 스레드가 락을 반납할 때까지 기다려야 한다.
  // thread-1.stageOne(), thread-2-stageTwo()가 불가능하다.
  // stageOne(), stageTwo()는 접근하는 객체가 다른데
  // thread-1이 stageOne()을 처리하는 동안 thread-2가 stageTwo()를 처리하면 
  // 처리속도가 빨라질 수 있다.
	public void process() {
		for (int i = 0; i < 1000; i++) {
			stageOne();
			stageTwo();
		}
	}

	public void main() {
		System.out.println("Starting ...");

		long start = System.currentTimeMillis();

		Thread t1 = new Thread(new Runnable() {
			public void run() {
				process();
			}
		});

		Thread t2 = new Thread(new Runnable() {
			public void run() {
				process();
			}
		});

		t1.start();
		t2.start();

		try {
			t1.join();
			t2.join();
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}

		long end = System.currentTimeMillis();

    // Time taken: 5203 (약 5초 소요됨)
		System.out.println("Time taken: " + (end - start)); 
		System.out.println("List1: " + list1.size() + "; List2: "
				+ list2.size());
	}
}

public class App {

	public static void main(String[] args) {

		Worker worker = new Worker();
		worker.main();
	}

}

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

class Processor implements Runnable {

    private int id;

    public Processor(int id){
        this.id = id;
    }
    @Override
    public void run(){
        System.out.println(Thread.currentThread().getName() + " : Started : " + id);

        // do Something
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + " : Completed : " + id);
    }

}

public class App{

    public static void main(String[] args) {

        ExecutorService executor = Executors.newFixedThreadPool(2);

        for(int i=1; i<=10; i++){
            executor.execute(new Processor(i));
//            executor.submit(new Processor(i));
        }

        // 더 이상 새로운 task를 받지 않음
        executor.shutdown();

        try {
            // shutdown() 호출한 후 남은 task들이 timeout 시간내로 끝나길 기다린다.
            executor.awaitTermination(1, TimeUnit.MINUTES);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("All tasks completed");

    }
}

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;

public class CountDownLatchTest {

    public static void main(String[] args) throws InterruptedException {

        CountDownLatch latch = new CountDownLatch(5); // count 초기값 설정

        for(int i=0; i<5; i++){
            new Thread(new Processors(latch)).start();
        }
        
        latch.await(); // count == 0 까지 기다린다
        latch.await(1, TimeUnit.SECONDS); // timeout 설정가능하다
  			while(true){
           if(latch.getCount() == 3){ // 현재 카운트를 확인하여 모든 작업이 끝나기전에 동작을 실행할 수 있다
                // do something...
                break;
           }
        }
        System.out.println("All Completed");
    }
}

class Processors implements Runnable{

    CountDownLatch latch;

    public Processors(CountDownLatch latch){
        this.latch = latch;
    }

    @Override
    public void run() {
        System.out.println("Starting Someting");
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("Finished Something");

        latch.countDown(); // 스레드가 작업이 끝났음을 알린다
    }
}