자바 Concurrent 라이브러리 - swsuh93/study GitHub Wiki

package test;

import java.util.ArrayList;
import java.util.List;
import java.util.Random;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.Exchanger;

public class ExchangerTest {  
	 
    private static final int FULL = 5;
    private static final int COUNT = FULL * 2;
    private static final Random random = new Random();
   
    private static volatile int sum = 0;
    
    private static Exchanger<List<Integer>> exchanger = new Exchanger<List<Integer>>();
   
    private static CountDownLatch stopLatch = new CountDownLatch(2);
 
    private static List<Integer> initiallyEmptyBuffer;
    private static List<Integer> initiallyFillBuffer;
   
    private static class FillingLoop implements Runnable {
        public void run() {
            List<Integer> currentBuffer = initiallyFillBuffer;
            try {
                for (int i = 0; i < COUNT; i++) {
                    if (currentBuffer == null)
                        break;
                   
                    Integer item = random.nextInt(100);
                    System.out.println("Item Added: " + item);
                    currentBuffer.add(item);
                   
                    if (currentBuffer.size() == FULL) {
                        currentBuffer = exchanger.exchange(currentBuffer);
                    }
                }
            } catch (InterruptedException ex) {
                System.out.println("Bad exchange on filling side");
            }
            stopLatch.countDown();
        }
    }  
 
    private static class EmptyingLoop implements Runnable {
        public void run() {
            List<Integer> currentBuffer = initiallyEmptyBuffer;
            try {
                for (int i = 0; i < COUNT; i++) {
                    if (currentBuffer == null)
                        break;
 
                    if (currentBuffer.isEmpty()) {
                        currentBuffer = exchanger.exchange(currentBuffer);
                    }
                    
                    Integer item = currentBuffer.remove(0);
                    System.out.println("Item Got: " + item);
                    sum += item.intValue();
                   
                }
            } catch (InterruptedException ex) {
                System.out.println("Bad exchange on emptying side");
            }
            stopLatch.countDown();
        }
    }  
 
    public static void main(String args[]) {
        initiallyEmptyBuffer = new ArrayList<Integer>();
        initiallyFillBuffer = new ArrayList<Integer>();
   
        new Thread(new FillingLoop()).start();
        new Thread(new EmptyingLoop()).start();
   
        try {
            stopLatch.await();
        } catch (InterruptedException ex) {
            ex.printStackTrace();
        }
        System.out.println("Sum of all items is.... " + sum);
    }
}

package test;

import java.util.List;
import java.util.Vector;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.FutureTask;

public class PreLoader {

	private final FutureTask<List<String>> task1 
		= new FutureTask<List<String>>(new MyCallable());
	private final FutureTask<List<String>> task2
		= new FutureTask<List<String>>(new MyCallable());
	private final FutureTask<List<String>> task3
		= new FutureTask<List<String>>(new MyCallable());
	private final FutureTask<List<String>> task4
		= new FutureTask<List<String>>(new MyCallable());
	private final FutureTask<List<String>> task5
		= new FutureTask<List<String>>(new MyCallable());
	
	ExecutorService es = Executors.newFixedThreadPool(5);
	
	public void testGO() throws Exception{
		es.submit(task1);
		Thread.sleep(300);
		
		es.submit(task2);
		Thread.sleep(300);
		
		es.submit(task3);
		Thread.sleep(300);
		
		es.submit(task4);
		Thread.sleep(300);
		
		es.submit(task5);
		
		PrintTest(task2);
		PrintTest(task5);
		PrintTest(task4);
		PrintTest(task3);
		PrintTest(task1);
		
		Thread.sleep(20000);
		
		es.shutdown();
	} //End Of testGo
	
	private void PrintTest(FutureTask<List<String>> tempTask){
		List<String> k = null;
		try {
			k = tempTask.get();
		} catch (InterruptedException e) {
			System.out.println("Exception : "+e.getMessage());
		} catch (ExecutionException e) {
			System.out.println("Exception : "+e.getMessage());
		} //End Of try
		
		for(String l : k){
			System.out.println(l);
		}
	} //End Of printTest
	
    public static void main(String[] args) {

    	PreLoader preloader = new PreLoader();
    	
    	try {
			preloader.testGO();
		} catch (Exception e) {
			System.out.println(e.getMessage());
		} //End Of try
    	
    } //End Of main
    
} //End Of Class



class MyCallable implements Callable<List<String>>{

	@Override
	public List<String> call() throws Exception {
		List<String> ret = new Vector<String>();
		
		for (int i = 0; i < 10; i++) {
			String temp = "안녕하세요 " + Thread.currentThread() + " 번 입니다.";

			Thread.sleep(300);

			ret.add(temp);
		}
		return ret;
	}
}

package test;

import java.util.Random;
import java.util.concurrent.Semaphore;

public class SemaphoreTest {

    private static final Random rd = new Random(10000);

    static class Log {
           public static void debug(String strMessage) {
           System.out.println(Thread.currentThread().getName()  + " : " + strMessage);
          }
      }

    class SemaphoreResource extends Semaphore {

          private static final long serialVersionUID = 1L;

          public SemaphoreResource(final int permits) {
                 super(permits);
          }

         public void use() throws InterruptedException {

                acquire(); // 세마포어 리소스 확보

               try {
                      doUse();
               } finally {
                     release(); // 세마포어 리소스 해제
                     Log.debug("Thread 종료 후 남은  permits: " +   this.availablePermits());
              }
           }

         protected void doUse() throws InterruptedException {

              // 임의의 프로그램을 실행하는데 거리는 가상의 시간
             int sleepTime = rd.nextInt(500);
             Thread.sleep(sleepTime); // 런타임 시간 설정
             Log.debug(" Thread 실행..................." + sleepTime);

                            /** something logic **/
            }
      }

   class MyThread extends Thread {

          private final SemaphoreResource resource;

          public MyThread(String threadName, SemaphoreResource resource) {
                 this.resource = resource;
                 this.setName(threadName);
          }

          @Override
           public void run() {
                try {
                    resource.use();
                } catch (InterruptedException e) {
                } finally { }
           }

      }

   public static void main(String... s) {

        System.out.println("Test Start...");
        SemaphoreResource resource =  new SemaphoreTest().new SemaphoreResource(4);

       for (int i = 0; i < 20; i++) {
              new SemaphoreTest().new MyThread("Thread-" + i, resource) .start();
        }

    }

}