Source Code : Coordinates threads for multi-threaded operations
Java Is Open Source Programming Language You Can Download From Java and Java Libraries From http://www.oracle.com.
Click Here to download
We provide this code related to title for you to solve your developing problem easily. Libraries which is import in this program you can download from http://www.oracle.com.
Click Here or search from google with Libraries Name you get jar file related it
Coordinates threads for multi-threaded operations
/* Copyright (C) 2005-2008 by Peter Eastman
This program is free software; you can redistribute it and/or modify it under the
terms of the GNU General Public License as published by the Free Software
Foundation; either version 2 of the License, or (at your option) any later version.
This program is distributed in the hope that it will be useful, but WITHOUT ANY
WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
PARTICULAR PURPOSE. See the GNU General Public License for more details. */
import java.util.concurrent.atomic.*;
import java.util.*;
/**
* This class coordinates threads for multi-threaded operations. The execution model
* provided by this class is a single "task" (e.g. tracing a ray through a single pixel)
* which must be executed many times. The task is parameterized by a single index
* (e.g. the column containing the pixel).
* <p>
* To use this class, pass it an object which implements the Task interface. It
* automatically creates an appropriate number of threads based on the number of
* available processors. When you call run(), the task is repeatedly executed by
* the worker threads, with the index running
* over the desired range. You may invoke run() any number of times (e.g. once
* for each row of the image). Finally, call finish() to clean up the worker threads.
*/
public class ThreadManager
{
private int numIndices;
private AtomicInteger nextIndex;
private Thread thread[];
private HashSet<Thread> waitingThreads;
private Task task;
private Object controller;
private boolean controllerWaiting;
/**
* Create a new uninitialized ThreadManager. You must invoke setNumIndices() and setTask()
* to initialize it before calling run().
*/
public ThreadManager()
{
this(0, null);
}
/**
* Create a new ThreadManager.
*
* @param numIndices the number of values the index should take on (from 0 to numIndices-1)
* @param task the task to perform
*/
public ThreadManager(int numIndices, Task task)
{
this.numIndices = numIndices;
this.task = task;
nextIndex = new AtomicInteger(numIndices);
controller = new Object();
controllerWaiting = false;
waitingThreads = new HashSet<Thread>();
}
/**
* Create and start the worker threads. This is invoked the first time run() is called.
*/
private void createThreads()
{
// Create a worker thread for each processor.
thread = new Thread [Runtime.getRuntime().availableProcessors()];
for (int i = 0; i < thread.length; i++)
{
thread[i] = new Thread("Worker thread "+(i+1)) {
public void run()
{
// Repeatedly perform the task until we are finished.
while (true)
{
try
{
int index = nextIndex();
task.execute(index);
}
catch (InterruptedException ex)
{
task.cleanup();
return;
}
catch (Exception ex)
{
cancel();
ex.printStackTrace();
}
}
}
};
thread[i].start();
}
}
/**
* Set the number of values the index should take on. This must be invoked from the same
* thread that instantiated the ThreadManager and that calls run().
*/
public void setNumIndices(int numIndices)
{
this.numIndices = numIndices;
nextIndex.set(numIndices);
}
/**
* Set the Task to be executed by the worker threads. If another Task has already been set,
* that one is discarded immediately and cleanup() will never be invoked on in. This method
* must be invoked from the same thread that instantiated the ThreadManager and that calls run().
*/
public void setTask(Task task)
{
this.task = task;
}
/**
* Perform the task the specified number of times. This method blocks until all
* occurrences of the task are completed. If the current thread is interrupted
* while this method is in progress, all of the worker threads will be interrupted
* and disposed of.
*/
public void run()
{
controllerWaiting = false;
nextIndex.set(0);
waitingThreads.clear();
if (thread == null)
createThreads();
// Notify all the worker threads, then wait for them to finish.
synchronized (this)
{
notifyAll();
}
synchronized (controller)
{
try
{
controllerWaiting = true;
controller.wait();
}
catch (InterruptedException ex)
{
finish();
}
}
}
/**
* Cancel a run which is in progress. Calling this method does not interrupt any tasks that
* are currently executing, but it prevents any more from being started until the next time
* run() is called.
*/
public void cancel()
{
nextIndex.set(numIndices);
}
/**
* Dispose of all the worker threads. Once this has been called, do not call run() again.
*/
public void finish()
{
if (thread != null)
for (int i = 0; i < thread.length; i++)
thread[i].interrupt();
}
private int nextIndex() throws InterruptedException
{
int index;
while ((index = nextIndex.getAndIncrement()) >= numIndices)
{
// Wait until run() is called again.
synchronized (this)
{
waitingThreads.add(Thread.currentThread());
if (waitingThreads.size() == thread.length)
{
while (!controllerWaiting)
wait(1);
synchronized (controller)
{
controller.notify();
}
}
wait();
}
}
return index;
}
/**
* This interface defines a task to be performed by the worker threads.
*/
public static interface Task
{
/**
* Execute the task for the specified index.
*/
public void execute(int index);
/**
* This is called once from each worker thread when finish() is called. It gives a chance
* to do any necessary cleanup.
*/
public void cleanup();
}
}
Thank with us
