Notes

//global variable.
Optional executionStatus = Optional.empty();

/********** STAGE 1: PRODUCER ***********************/
Map<String, Integer> columnName= new HashMap<String, Integer>();
Set<String> journeyID = new LinkedHashSet<String>();

FileInputStream readExcel = new FileInputStream(pathOfExcel);
XSSFWorkbook readBook= new XSSFWorkbook(readExcel);
XSSFSheet readSheet = readBook.getSheet("New_Device_Management"); //Input sheet name to be referred.


//Traversing through rows
Row firstRow = readSheet.getRow(0); //First row is header

int minValueForIteration = firstRow.getFirstCellNum(); //getFirst column index
int maxValueForIteration = firstRow.getLastCellNum(); //getLast column index
for(int i=minValueForIteration; i<maxValueForIteration; i++)
{
Cell valueOfCell = firstRow.getCell(i);
//Mapping column name to index since position of column may not be same
columnName.put(valueOfCell.getStringCellValue(), valueOfCell.getColumnIndex());
}


columnName.forEach((k,v)->
System.out.println("Key " + k + " | value" + v)
);


Iterator<Row> rowIterator = readSheet.rowIterator();//Iterate through rows

//Execution Status column Iteration starts here
//Journey of respective row with execution status as "Yes" is stored.
//Set initiated stores the value avoiding duplicate element.
//Size of set determines the number of thread to be initiated and Name of thread
rowIterator.forEachRemaining(x-> {
//ExecutionStatus must be a global variable.
executionStatus = Optional.ofNullable(x.getCell(columnName.get("ExecutionStatus")).toString());
if("yes".equalsIgnoreCase((String) executionStatus.get()))
{
journeyID.add(x.getCell(columnName.get("Journey")).toString());

}

});

System.out.println("Number of Thread to be initiated - " + journeyID.size());


/************STAGE 2: Thread Pool Executor ********/

//Intial core pool size - 2. Assuming min two thread always run. If it is lesser, a new thread shall get created to handle it.
//Max Pool size- decided based on size of set.
//Max duration for a thread to stay idle - 30 minutes.
// Thread that can be queued - 2
//if CorepoolSize and MaxpoolSize are same-> it is fixed thread count concept.
ThreadFactory threadFactory = Executors.defaultThreadFactory();//Created to alter threadname, priority etc.
ThreadPoolExecutor executorPool = new ThreadPoolExecutor(2, journeyID.size(), 30, TimeUnit.MINUTES, new ArrayBlockingQueue<Runnable>(3), threadFactory);

//Print all this Logs in debug mode.
System.out.println("Pool Size - " + executorPool.getCorePoolSize());
System.out.println("Core Pool Size - " + executorPool.getPoolSize());
System.out.println("Max allocated size - " + executorPool.getMaximumPoolSize());
System.out.println("is thread idle?" + executorPool.prestartCoreThread()); //Returns true or false based on thread idle state. Thread starts based on task submitted to executor.

Iterator<String> threadName = journeyID.iterator();
while(threadName.hasNext())
{
//At a time only 3 threads can run considering memory management.,
Runnable executeThread = new ThreadConcept(threadName.next());
executorPool.execute(executeThread);
}

/***********Stage 3: Operation **********/

//With thread name as primary key one has to iterate through the cells.

/*********** STage 4 : Reporting ***********/

//Flush and close method of reporting to be invoked here

/***********Stage 5: Termination ************/
//Terminator to be called after reporting is completed.
try{
executorPool.shutdown();
while (!executorPool.isTerminated()) {
System.out.println("Finished All Threads");
}
}catch(RejectedExecutionException E){
System.out.println("Task cannot be accepted due to shut down");
}