public class StackDemo{
    public static int runStatic(int i, long l, float f, Object o, byte b){
        return 0;
    }

    public int runInstance(char c, short s, boolean b){
        return 0;
    }
}

public class AppMain{ //运行时，jvm把appmain的信息都放入方法区
    public static void main(String[] args){ //main方法本身放入方法区
        Sample test1 = new Sample("测试1"); //test1引用，所以放到栈区，Sample是自定义对象应该放到堆里面
        Sample test2 = new Sample("测试2");

        test1.printName();
        test2.printName();
    }
}

public class Sample{ //运行时，jvm把appmain的信息都放入方法区
    private String name; //new Sample实例后，name引用放入栈区里name对象放入堆里
    public Sample(String name){
        this.name = name;
    }

    //print方法本身放入方法区里
    public void printName(){
        System.out.println(name);
    }
    
}

public class Server{
	private ThreadPoolExecutor executor;

	public Server(){
		executor = (ThreadPoolExecutor) Executors.newCachedThreadPool();
	}

	public void executeTask(Task task){
		System.out.printf("Server: A new task has arrived\n");
		executor.execute(task);
		System.out.printf("Server: Pool Size: %d\n",executor.getPoolSize());
		System.out.printf("Server: Active Count: %d\n",executor.getActiveCount());
		System.out.printf("Server: Completed Tasks: %d\n",executor.getCompletedTaskCount());
	}

	public void endServer(){
		executor.shutdown();
	}
}

public class Main{
	public static void main(String[] args){
		Server server = new Server();
		for(int i = 0; i < 100; i++){
			Task task = new Task("Task " + i);
			server.executeTask(task);
		}
		server.endServer();
	}
}

public class Server{
	private ThreadPoolExecutor executor;
	
	public Server(){
		executor = (ThreadPoolEexcutor)Executors.newFixedThreadPool(5);
	}

	public void executeTask(Task task){
		System.out.printf("Server: A new task has arrived\n");
		executor.execute(task);
		System.out.printf("Server: Pool Size: %d\n", executor.getPoolSize());
		System.out.printf("Server: Active Count: %d\n", executor.getActiveCount());
		System.out.printf("Server: Task Count: %d\n",executor.getTaskCount());
		System.out.printf("Server: Completed Task: %d\n", executor.getCompletedTaskCount());
	}

	public void endService(){
		executor.shutdown();
	}
}

public class Task implements Runnable{
	private Date initDate;
	private String name;

	public Task(String name){
		initDate = new Date();
		this.name = name;
	}

	@Override
	public void run(){
		System.out.printf("%s: Task %s : Created on: %s\n", Thread.currentThread().getName(), name, initDate);
		System.out.printf("%s: Task %s: Started on: %s\n", Thread.currentThread().getName(), name, new Date());

		try{
			Long duration = (long)(Math.random() * 10);
			System.out.printf("%s: Task %s: Doing a task during %d seconds\n", Thread.currentThread().getName(), name, duration);
			TimeUnit.SECONDS.sleep(duration);
		}catch(InterruptedException e){
			e.printStackTrace();
		}

		System.out.printf("%s: Task %s: Finished on: %s\n", Thread.currentThread().getName(), new Date(), name);
	}
}

public class Main{
	public static void main(String[] args){
		Server server = new Server();
		for(int i = 0; i < 100; i++){
			Task task = new Task("Task " + i);
			server.executeTask(task);
		}
		server.endServer();
	}
}

public class FactorialCalculator implements Callable<Integer>{
	//存储任务计算的数字
	private Integer number;

	public FactorialCalculator(Integer number){
		this.number = number;
	}

	@Override
	public Integer call() throws Exception{
		int num, result;
		num = number.intValue();
		result = 1;

		if((num == 0 || (num == 1)){
			result = 1;
		}else{
			for(int i = 2; i <= number; i++){
				result *= i;
				Thread.sleep(20);
			}
		}
		System.out.printf("%s: %d\n", Thread.currentThread().getName(), result);
		return result;
	}
}

public class Main{
	public static void main(String[] args){
		ThreadPoolExecutor executor = (ThreadPoolExecutor) Executors.newFixedThreadPool(2);
		//创建一个Future<Integer>类型的列表对象resultList
		List<Future<Integer>> resultList = new ArrayList<>();
		Random random = new Random();
		for(int i = 0; i < 10; i++){
			Integer number = new Integer(random.nextInt(10));
			FactorialCalculator calculator = new FactorialCalculator(number);
			Future<Integer> result = executor.submit(calculator);
			resultList.add(result);
		}

		do{
			//任务完成的数量
			System.out.printf("Main: Number of Completed Tasks: %d\n",executor.getCompletedTaskCount());
			//遍历10个Future对象，通过isDone()输出任务是否完成
			for(int i = 0;i < resultList.size(); i++){
				Future<Integer> result = resultList.get(i);
				System.out.printf("Main: Task %d: %s\n", result.isDone());
			}
			try{
				Thread.sleep(50);
			}catch(InterruptedException e){
				e.printStackTrace();
			}
			
		}while(executor.getCompletedTaskCount()<resultList.size());
		System.out.printf("Main: Results\n");
		for(int i = 0 ; i < resultList.size(); i++){
			Future<Integer> result = resultList.get(i);
			Integer number = null;
			try{
				number = result.get();
			}catch(InterruptedException e){
				e.printStackTrace();
			}catch(ExecutionException e){
				e.printStackTrace();
			}
			System.out.printf("Core: Task %d: %d\n",i,number);
		}
		executor.shutdown();
	}
}

public class TaskValidator implements Callable<String>{
	private UserValidator validator;
	private String user;
	private String password;
	public TaskValidator(UserValidator validator,String user, String password){
		this.validator = validator;
		this.user = user;
		this.password = password;
	}

	@Override
	public String call() throws Exception{
		if(!validator.validate(user, password)){
			//如果用户没有通过UserValidator验证，抛出Exception
			System.out.printf("%s: The user has not been found\n",validator.getName());
			throw new Exception("Error validating user");
		}
		System.out.printf("%s: The user has been found\n",validator.getName());
		return validator.getName();
	}
}

public class Main{
	public static void main(String[] args){
		String username = "test";
		String password = "test";

		UserValidator ldapValidator = new UserValidator("LDAP");
		UserValidator dbValidator = new UserValidator("DateBase");

		TaskValidator ldapTask = new TaskValidator(ldapValidator, username, password);

		TaskValidator dbTask = new TaskValidator(dbValidator, username, password);

		List<TaskValidator> taskList = new ArrayList<>();
		taskList.add(ldapTask);
		taskList.add(dbTask);

		ExecutorService executor = (ExecutorService)Executors.newCachedThreadPool();
		String result;
		try{
			result = executor.invokeAny(taskList);
			System.out.printf("Main: Result: %s\n",result);
		}catch(InterruptedException e){
			e.printStackTrace();
		}catch(ExecutionException e){
			e.printStackTrace();
		}

		executor.shutdown();
		System.out.printf("Main: End of the Execution\n");

	}
}

public class Task implements Callable<Result>{
	private String name;
	public Task(String name){
		this.name = name;
	}

	@Override
	public Result call() throws Exception{
		System.out.printf("%s: Staring\n", this.name);

		try{
			Long duration = (long)(Math.random()*10);
			System.out.printf("%s: Waiting %d seconds for results.\n", this.name,duration);
			TimeUnit.SECONDS.sleep(duration);
		}catch(InterruptedException e){
			e.printStackTrace();
		}
		int value = 0;
		for(int i = 0; i < 5; i++){
			value += (int)(Math.random()*100);
		}

		Result result = new Result();
		result.setName(this.name);
		result.setValue(value);
		System.out.printf("%s: Ends\n", this.name);

		return result;
	}
}

public class Main{
	public static void main(String[] args){
		ExecutorService executor = (ExecutorService)Executors.newCachedThreadPool();
		List<Task> taskList = new ArrayList();
		for(int i = 0; i < 3; i++){
			Task task = new Task("Task-" + i);
			taskList.add(task);
		}

		List<Future<Result>> resultList = null;
		try{
			resultList = executor.invokeAll(taskList);
		}catch(InterruptedException e){
			e.printStackTrace();
		}
		executor.shutdown();

		System.out.printf("Core: Printing the results\n");
		for(int i = 0 ; i < resultList.size(); i++){
			Future<Result> future = resultList.get(i);
			try{
				Result result=future.get();
				System.out.printf("%s: %s\n",result.getName(),result.getValue());
			}catch(InterruptedException | ExecutionException){
				e.printStackTrace();
			}
		}
	}
}

public class Task implements Callable<String>{
	private String name;
	public Task(String name){
		this.name = name;
	}

	@Override
	public String call() throws Exception{
		System.out.printf("%s: Starting at : %sn", name, new Date());
		return "Hello World";
	}
}

public class Main{
	public static void main(String[] args){
		ScheduledExecutorService executor = (ScheduledExecutorService)Executors.newScheduledThreadPool(1);
		System.out.printf("Main: Starting at: %sn", new Date());
		for(int i = 0; i < 5; i++){
			Task task = new Task("Task " + i);
			executor.schedule(task, i + 1, TimeUnit.SECONDS);
		}
		executor.shutdown();
		try{
			executor.awaitTermination(1, TimeUnit.DAYS);
		}catch(InterruptedException e){
			e.printStackTrace();
		}
		System.out.printf("Core: Ends at : %sn", new Date());
	}
}

public class Task implements Runnable{
	private String name;
	public Task(String name){
		this.name = name;
	}
	@Override
	public void run(){
		System.out.printf("%s: Executed at: %s\n", new Date());
	}
}

public class Main{
	ScheduledExecutorService executor = Executors.newScheduledThreadPool(1);
	System.out.printf("Main: Starting at: %s\n", new Date());

	Task task = new Task("Task");
	ScheduledFuture<?> result = executor.scheduleAtFixedRate(task, 1, 2, TimeUnit.SECONDS);

	for(int i = 0; i < 10; i++){
		System.out.printf("Main: Delay: %d\n", result.getDelay(TimeUnit.MILLISECONDS));
		try{
			TimeUnit.MILLISECONDS.sleep(500);
		}catch(InterruptedException e){
			e.printStackTrace();
		}
	}

	executor.shutdown();
	System.out.printf("Main: No More tasks at: %s\n", new Date());
	try{
		TimeUnit.SECONDS.sleep(5);
	}catch(InterruptedException e){
		e.printStackTrace();
	}

	System.out.printf("Main: Finished at: %s\n", new Date());
}

public class Task implements Callable<String>{
	@Override
	public String call() throws Exception{
		while(true){
			System.out.printf("Task: Test\n");
			Thread.sleep(100);
		}
	}
}

public class Main{
	public static void main(String[] args){
		ThreadPoolExecutor executor = (ThreadPoolExecutor)Executors.newCachedThreadPool();

		Task task = new Task();

		System.out.printf("Main: Executing the Task\n");

		Future<String> result = executor.submit(task);

		try{
			TimeUnit.SECONDS.sleep(2);
		}catch(InterruptedException e){
			e.printStackTrace();
		}

		System.out.printf("Main: Cancelling the Task\n");
		result.cancel(true);

		System.out.printf("Main: Cancelled: %s\n", result.isCancelled());
		System.out.printf("Main: Done: %s\n", result.isDone());

		executor.shutdown();
		System.out.printf("Main: The executor has finished\n");
	}
}

public class ExecutableTask implements Callable<String>{
	 private String name;
	 public ExecutableTask(String name){
	 	this.name = name;
	 }

	 @Override
	 public String call() throws Exception{
	 	try{
	 		Long duration = (long)(Math.random()*10);
	 		System.out.printf("%s: Waiting %d seconds for results.n",this.name, duration);
	 		TimeUnit.SECONDS.sleep(duration);
	 	}catch(InterruptedException e){

	 	}
	 	return "Hello world. I'm " + name;
	 }

	 public String getName(){
	 	return name;
	 }
}

public class ResultTask extends FutureTask<String>{
	private String name;
	public ResultTask(Callable<String> callable){
		super(callable);
		this.name = ((ExecutableTask) callable).getName();
	}

	@Override
	protected void done(){
		if(isCancelled()){
			System.out.printf("%s: Has been cancelled\n",name);
		}else{
			System.out.printf("%s: Has finished\n",name);
		}
	}
}

public class Main{
	public static void main(String[] args){
		ExecutorService executor = (ExecutorService)Executors.newCachedThreadPool();
		ResultTask resultTasks[] = new ResultTask[5];
		for(int i =0 ;i < 5; i++){
			ExecutableTask executableTask = new ExecutableTask("Task " + i);
			resultTasks[i] = new ResultTask(executableTask);
			executor.submit(resultTasks[i]);
		}

		try{
			TimeUnit.SECONDS.sleep(5);
		}catch(InterruptedException e){
			e.printStackTrace();
		}

		for(int i = 0; i < resultTasks.length; i++){
			resultTasks[i].cancel(true);
		}

		for(int i = 0; i < resultTasks.length; i++){
			try{
				if(!resultTasks[i].isCancelled()){
					System.out.printf("%s\n",resultTasks[i].get());
				}
			}catch(InterruptedException | ExecutionException e){
				e.printStackTrace();
			}
		}

		executor.shutdown();
	}
}

public class ReportGenerator implements Callable<String>{
	private String sender;
	private String title;
	public ReportGenerator(String sender, String title){
		this.sender = sender;
		this.title = title;
	}

	@Override
	public String call() throws Exception{
		try{
			Long duration = (long) (Math.random() * 10);
			System.out.printf("%s_%s: ReportGenerator: Generating a report during %d seconds\n",this.sender, this.title, duration);
			TimeUnit.SECONDS.sleep(duration);
		}catch(InterruptedException e){
			e.printStackTrace();
		}
		String ret = sender + ": " + title;
		return ret;
	}
}

public class ReportProcessor implements Runnable{
	private CompletionService<String> service;
	private boolean end;
	public ReportProcessor(CompletionService<String> service){
		this.service = service;
		end = false;
	}

	@Override
	public void run(){
		while(!end){
			try{
				Future<String> result = service.poll(20, TimeUnit.SECONDS);
				if(result){
					String report = result.get();
					System.out.printf("ReportReceiver: Report Recived: %s\n", report);
				}
			}catch(InterruptedException e){
				e.printStackTrace();
			}catch(ExecutionException e){
				e.printStackTrace();
			}
		}
	}

	public void setEnd(boolean end){
		this.end = end;
	}
}

public class ReportRequest implements Runnable{
	private String name;
	private CompletionService<String> service;

	public ReportRequest(String name, CompletionService<String> service){
		this.name = name; 
		this.service = service;
	}

	@Override
	public void run(){
		ReportGenerator reportGenerator = new ReportGenerator(name, "Report");
		service.submit(reportGenerator);
	}
}

public static void main(String[] args){
	ExecutorService executor = (ExecutorService)Executors.newCachedThreadPool();
	CompletionService<String> service = new ExecutorCompletionService<>(executor);

	ReportRequest faceRequest = new ReportRequest("Face", service);
	ReportRequest onlineRequest = new ReportRequest("Online", service);
	Thread faceThread = new Thread(faceRequest);
	Thread onlineThread = new Thread(onlineRequest);

	ReportProcessor processor = new ReportProcessor(service);
	Thread senderThread = new Thread(processor);

	System.out.printf("Main: Starting the Threads\n");
	faceThread.start();
	onlineThread.start();
	senderThread.start();

	try{
		System.out.printf("Main: Waiting for the report generators.\n");
		faceThread.join();
		onlineThread.join();
	}catch(InterruptedException e){
		e.printStackTrace();
	}

	System.out.printf("Main: Shuting down the executor.\n");
	executor.shutdown();
	try{
		executor.awaitTermination(1, TimeUnit.DAYS);
	}catch(InterruptedException e){
		e.printStackTrace();
	}

	processor.setEnd(true);
	System.out.printf("Main: Ends\n");
}

public class RejectedTaskController implements RejectedExecutionHandler{
	@Override
	public void rejectedExecution(Runnable r, ThreadPoolExecutor executor){
		System.out.printf("RejectedTaskController: The task %s has been rejected\n",r.toString());
		System.out.printf("RejectedTaskController: %s\n",executor.toString());
		System.out.printf("RejectedTaskController: Terminating: %s\n",executor.isTerminating());
		System.out.printf("RejectedTaksController: Terminated: %s\n",executor.isTerminated());
	}
}

public class Task implements Runnable{
	private String name;
	public Task(String name){
		this.name = name;
	}

	@Override
	public void run(){
		System.out.printf("Task %s : Starting\n", name);
		try{
			Long duration = (long)(Math.random()* 10);
			System.out.printf("Task %s: ReportGenerator: Generating a report during %d seconds\n",name , duration);
			TimeUnit.SECONDS.sleep(duration);
		}catch(InterruptedException e){
			e.printStackTrace();
		}
		System.out.printf("Task %s: Ending\n", name);
	}

	public String toString(){
		return name;
	}
}

public class Main{
	public static void main(String[] args){
		RejectedTaskController controller = new RejectedTaskController();
		ThreadPoolExecutor executor = (ThreadPoolExecutor)Executors.newCachedThreadPool();
		executor.setRejectedExecutionHandler(controller);

		System.out.printf("Main: Starting.\n") ;
		for(int i = 0; i < 3; i++){
			Task task = new Task("Task" + i);
			executor.submit(task);
		}

		System.out.printf("Main: Shuting down the Executor.\n");
		executor.shutdown(); 

		System.out.printf("Main: Sending another Task\n");
		Task task = new Task("RejectedTask");
		executor.submit(task);

		System.out.printf("Main: End.\n"); 

	}
}

public class PrintQueue{
    private final Semaphore semaphore;

    public PrintQueue(){
        semaphore = new Semaphore(1); //创建二进制信号量
    }

    public void printJob(Object document){
        try{
            semaphore.acquire();
            
            Long duration = (long)(Math.random() * 10);
            System.out.printf("%s: PrintQueue: Printing a Job during %d seconds\n", Thread.currentThread().getName(),duration);
            TimeUnit.SECONDS.sleep(duration);
        }catch(InterruptedException e){
            e.printStackTrace();
        }finally{
            semaphore.release();
        }
    }
}

public class Job implements Runnable{
    private PrintQueue printQueue;

    public Job(PrintQueue printQueue){
        this.printQueue = printQueue;
    }

    @Override
    public void run(){
        System.out.printf("%s: Going to print a job\n",Thread.currentThread().getName());
        printQueue.printJob(new Object());
        System.out.printf("%s: The document has been printed\n", Thread.currentThread().getName());
    }
}

public class Main{
    public static void main(String[] args){
        PrintQueue printQueue = new PrintQueue();

        Thread thread[] = new Thread[10];
        for(int i = 0; i < 10; i++){
            thread[i] = new Thread(new Job(printQueue)，"Thread " + i);
        }
    ｝
}

public class PrintQueue{
    private Semaphore semaphore;

    private boolean freePrinters[];

    private Lock lockPrinters;

    public PrintQueue(){
        semaphore = new Semaphore(3);
        freePrinters = new boolean[3];
        for(int i = 0; i < 3; i++){
            freePrinters[i] = true;
        }
        lockPrinters = new ReentrantLock();
    }

    public void printJob(Object document){
        try{
            semaphore.acquire();
            int assignedPrinter = getPrinter();
            Long duration = (long)(Math.random()*10);
			System.out.printf("%s: PrintQueue: Printing a Job in Printer %d during %d seconds\n",Thread.currentThread().getName(),assignedPrinter,duration);
			TimeUnit.SECONDS.sleep(duration);

            freePrinters[assignedPrinter] = true;
        }catch(InterruptedException e){
            e.printStackTrace();
        }finally{
            semaphore.release();
        }
    }

    private int getPrinter(){
        int ret = -1;

        try{
            lockPrinters.lock();
            for(int i = 0; i < freePrinters.length; i++){
                if(freePrinters[i]){
                    ret = i;
                    freePrinters[i] = false;
                    break;
                }
            }
        }catch(Exception e){
            e.printStackTrace();
        }finally{
            lockPrinters.unlock();
        }
    }
}

public class Job implements Runnable{
    private PrintQueue printQueue;

    public Job(PrintQueue printQueue){
        this.printQueue = printQueue;
    }

    @Override
    public void run(){
		System.out.printf("%s: Going to print a job\n",Thread.currentThread().getName());
		printQueue.printJob(new Object());
		System.out.printf("%s: The document has been printed\n",Thread.currentThread().getName());	
    }   
}

public class Main{
    public static void main(String[] args){
        PrintQueue printQueue = new PrintQueue();
        Thread thread[] = new Thread[12];
        for(int i = 0; i < 12; i++){
            thread[i] = new Thread(new Job(printQueue), "Thread " + i);
        }
        for(int i = 0;i < 12; i++){
            thread[i].start();
        }
    }
}

public class Videoconference implements Runnable{
    private final CountDownLatch controller;

    public Videoconference(int number){
        controller = new CountDownLatch(number);
    }

    public void arrive(String name){
        System.out.printf("%s has arrived.\n",name);
        controller.countDown();
        System.out.printf("VideoConference: Waiting for %d participants.\n", controller.getCount());
    }

    @Override
    public void run(){
        System.out.printf("VideoConference: Initialization: %d participants.\n", controller.getCount());
        try{
            controller.await();
            System.out.printf("VideoConference: All the participants have come\n");
            System.out.printf("VideoConference: Let's start...\n");
        }catch(InterruptedException e){
            e.printStackTrace();
        }
    }
}

public class Participant implements Runnable{
    private Videoconference conference;
    private String name;
    
    public Participant(Videoconference conference,String name){
        this.conference = conference;
        this.name = name;
    }
    
    @Override
    public void run(){
        Long duration = (long)(Math.random()*10);
        try{
            TimeUnit.SECONDS.sleep(duration);
        }catch(InterruptedException e){
            e.printStackTrace();
        }
        conference.arrive(name);
    }
}

public class Main{
    public static void main(String[] args){
        Videoconference conference = new Videoconference(10);
        Thread threadConference = new Thread(conference);
        threadConference.start();

        for(int i = 0; i < 10; i++){
            Participant p = new Participant (conference, "Participant " + i);
            Thread t = new Thread(p);
            t.start();
        }
    }
}

public class MatrixMock{
    private int data[][]; //二维数组data
    
    //矩阵的行数 每行的长度 寻找的数字
    public MatrixMock(int size, int length, int number){
        int counter = 0;
        data = new int[size][length];
        Random random = new Random();
        for(int i = 0 ;i < size; i++){
            for(int j = 0; j < length; j++){
                data[i][j] = random.nexInt(10);
                if(data[i][j] == number){
                    counter++;
                }
            }
        }
        System.out.printf("Mock: There are %d ocurrences of number in generated data.\n", counter, number);
    ｝
    
    public int[] getRow(int row){
        if((row >= 0) && (row < data.length)){
            return data[row];
        }
        return null;
    }   
}

public class Results{
    private int data[];

    public Results(int size){
        data = new int[size];
    }

    public void setData(int position,int value){
        data[position] = value;
    }

    public int[] getData(){
        return data;
    }
}

pubilc class Searcher implements Runnable{
    private int firstRow;
    private int lastRow;
    private MatrixMock mock;
    private Results results;
    private int number;
    private final CyclicBarrier barrier;

    public Search(int firstRow,int lastRow,MatrixMock mock,Results results, int number,CyclicBarrier barrier){
        this.firstRow = firstRow;
        this.lastRow = lastRow;
        this.mock = mock;
        this.results = results;
        this.number = number;
        this.barrier = barrier;
    }

    @Override
    public void run(){
        int counter;
        System.out.printf("%s: Processing lines from %d to %d.\n", Thread.currentThread().getName(),firstRow, lastRow);
        for(int i = firstRow; i < lastRow; i++){
            int row[] = mock.getRow(i);
            counter = 0;
            for(int j = 0; j < row.length; j++){
                if(row[j] == number){
                    counter++;
                }
            }
            results.setData(i, counter);
        }
        System.out.printf("%s: Lines processed.\n",Thread.currentThread().getName());

        try{
            barrier.await();
        }catch(InterruptedException e){
            e.printStackTrace();
        }catch(BrokenBarrierException e){
            e.printStackTrace();
        }
    }
}

public class Grouper implements Runnable{
    private Results results;

    public Grouper(Results results){
        this.results = results;
    }

    @Override
    public void run(){
        int finalResult = 0;
        System.out.println("Grouper: Processing results...\n");
        int data[] = results.getData();
        for(int number : data){
            finalResult += number;
        }
        System.out.printf("Grouper: Total result: %d.\n",finalResult);
    }
}

public class Main{
    public static void main(String[] args){
        final int ROWS = 10000;
        final int NUMBERS = 1000;
        final int SEARCH = 5;
        final int PARTICIPANTS = 5;
        final int LINES_PARTICIPANT = 2000;
        MatrixMock mock = new MatrixMock(ROWS, NUMBERS, SEARCH);
        Results results = new Results(ROWS);
        Grouper grouper = new Grouper(results);
        CyclicBarrier barrier = new CyclicBarrier(PARTICIPANTS, grouper);
        Searcher searchers[] = new Searcher[PARTICIPANTS];
        for(int i = 0; i < PARTICIPANTS; i++){
            searchers[i] = new Searcher(i*LINES_PARTICIPANT, (i*LINES_PARTICIPANT)+LINES_PARTICIPANT, mock, results,5, barrier);
            Thread thread = new Thread(searchers[i]);
            thread.start();
        }
        System.out.printf("Main: The main thread has finished.\n");
    }
}

public class Main{
	public static void main(String[] args){
		Phaser phaser = new Phaser(3);

		FileSearch system  = new FileSearch("C:\\XXX", "log", phaser);
		FileSearch apps = new FileSearch("C:\\XXXX", "log", phaser);
		FileSearch documents = new FileSearch("C:\\XXXXX","log", phaser);

		Thread systemThread = new Thread(system, "System");
		systemThread.start();

		Thread appsThread = new Thread(apps, "Apps");
		appsThread.start();

		Thread documentsThread = new Thread(documents, "Documents");
		documentsThread.start();

		try{
			systemThread.join();
			appsThread.join();
			documentsThread.join();
		}catch(InterruptedException e){
			e.printStackTrace();
		}
		System.out.printf("Terminated: %s\n", phaser.isTerminated());
	}
}

public class MyPhaser extends Phaser{
	@Override
	protected boolean onAdvance(int phase, int registeredParties){
		switch(phase){
			case 0:
				return studentsArrived();

			case 1:
				return finishFirstExercise();

			case 2:
				return finishSecondExercise();

			case 3:
				return finishExam();

			default:
				return true;
		}
	}

	private boolean studentsArrived(){
		System.out.printf("Phaser: The exam are going to start. The students are ready.\n");
		System.out.printf("Phaser: We have %d students.\n",getRegisteredParties());
		return false;
	}

	private boolean finishFirstExercise() {
		System.out.printf("Phaser: All the students has finished the first exercise.\n");
		System.out.printf("Phaser: It's turn for the second one.\n");
		return false;
	}

	private boolean finishSecondExercise() {
		System.out.printf("Phaser: All the students has finished the second exercise.\n");
		System.out.printf("Phaser: It's turn for the third one.\n");
		return false;
	}

	private boolean finishExam() {
		System.out.printf("Phaser: All the students has finished the exam.\n");
		System.out.printf("Phaser: Thank you for your time.\n");
		return true;
	}

}

public class Student implements Runnable{
	private Phaser phaser;

	public Student(Phaser phaser){
		this.phaser = phaser;
	}

	public void run(){
		System.out.printf("%s: Has arrived to do the exam. %s\n",Thread.currentThread().getName(),new Date());
		phaser.arriveAndAwaitAdvance();
		System.out.printf("%s: Is going to do the first exercise. %s\n",Thread.currentThread().getName(),new Date());
		doExercise1();

		System.out.printf("%s: Has done the first exercise. %s\n",Thread.currentThread().getName(),new Date());
		phaser.arriveAndAwaitAdvance();
		System.out.printf("%s: Is going to do the second exercise. %s\n",Thread.currentThread().getName(),new Date());
		doExercise2();

		System.out.printf("%s: Has done the second exercise. %s\n",Thread.currentThread().getName(),new Date());
		phaser.arriveAndAwaitAdvance();
		System.out.printf("%s: Is going to do the third exercise. %s\n",Thread.currentThread().getName(),new Date());
		doExercise3();
		System.out.printf("%s: Has finished the exam. %s\n",Thread.currentThread().getName(),new Date());
		phaser.arriveAndAwaitAdvance();
	}

	private void doExercise1() {
		try {
			Long duration=(long)(Math.random()*10);
			TimeUnit.SECONDS.sleep(duration);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}

	private void doExercise2() {
		try {
			Long duration=(long)(Math.random()*10);
			TimeUnit.SECONDS.sleep(duration);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}

	private void doExercise3() {
		try {
			Long duration=(long)(Math.random()*10);
			TimeUnit.SECONDS.sleep(duration);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}	
}

public class Main {

	public static void main(String[] args) {
		MyPhaser phaser=new MyPhaser();

		Student students[]=new Student[5];
		for (int i=0; i<students.length; i++){
			students[i]=new Student(phaser);
			phaser.register();
		}

		Thread threads[]=new Thread[students.length];
		for (int i=0; i<students.length; i++) {
			threads[i]=new Thread(students[i],"Student "+i);
			threads[i].start();
		}
		
		for (int i=0; i<threads.length; i++) {
			try {
				threads[i].join();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		
		System.out.printf("Main: The phaser has finished: %s.\n",phaser.isTerminated());
		
	}

}

public class Producer implements Runnable{
	private List<String> buffer;
	private final Exchanger<List<String>> exchanger;
	public Producer(List<String> buffer, Exchanger<List<String>> exchanger){
		this.buffer = buffer;
		this.exchanger = exchanger;
	}


	@Override
	public void run(){
		int cycle = 1;
		for(int i = 0 ; i  < 10 ; i++){
			System.out.printf("Producer: Cycle %d\n", cycle);

			for(int j = 0; j < 10; j++){
				String message = "Event " + ((i*10) + j);
				System.out.printf("Producer: %s\n", message);
				buffer.add(message);
			}
			
			try{
				buffer = exchanger.exchange(buffer);
			}catch(InterruptedException e){
				e.printStackTrace();
			}

			System.out.printf("Producer: %d\n", buffer.size());
			cycle++;
		}

	}
}