Manager / worker / updated data

[John Vorwald]

I'm trying to learn / understand concurrency threads.
I expect to have a GUI start a SwingWorker, and the SwingWorker manages a number of worker threads, and some data is updated periodically.
I would like the manager to start the workers, then have data appear, then have the data updated after a period.
When the data is updated, I would like to have the workers utilize the new data in a controlled manner.
Also, the manager should be able to interrupt the worker threads.
The following code has minimal synchronization, and I'm not sure it's in the correct places. How should the code be modified so that the workers are notified that the data is being updated, and also so that the workers transition to the new data in a controlled manner.

public class GetDataPublish
{

    /**
     * @param args
     */
    public static void main( String[] args )
    {
        final int nWorkers = 20;
        Manager manager = new Manager(nWorkers);
        try {
            manager.start();
        } finally {
            System.out.printf( "Leaving main\n" );
        }
    }

}

class Manager extends Thread {
    
    private final List<Worker> workers;

    public Manager( int aNWorkers )
    {
        workers = new LinkedList<Worker>();
        for (int i=0; i<aNWorkers; i++) {
            Worker worker = new Worker();
            workers.add( worker );
        }
        this.setName( "Thread-Manager" );
    }

    @Override
    public void run()
    {
        // Generate some data

        Data data = new Data(workers);

        Random rand = new Random();
        int iw=0;
        for (Worker w: workers) {
            w.initalize(data, rand);
            iw++;
            w.setName( String.format( "Thread-W%d", iw ) );
        }
    
        // Start workers
        for (Worker w: workers) {
            w.start();
        }
        
        // Let the worker run for a time
        try
        {
            Thread.sleep( 500 );
            data.generate();
            Thread.sleep( 500 );
            data.generate();
            Thread.sleep( 500 );
            for (Worker w: workers) {
                w.interrupt();
            }
            
        }
        catch ( InterruptedException e )
        {
            e.printStackTrace();
        }
        
    }
}

class Data {

    private final List<Worker> workers;
    private Date lastDate;
    private Boolean hasData;
    List<Integer> data;
    SimpleDateFormat df;
    int dataStart;
    public Data( List<Worker> aWorkers )
    {
        workers = aWorkers;
        lastDate = new Date();
        hasData = false;
        df = new SimpleDateFormat("HH:MM:ss.SSS");
        data = new LinkedList<Integer>();
        dataStart = 0;
    }

    public void generate()
    {
        
        Calendar cal = Calendar.getInstance();
        cal.setTime( lastDate );
        cal.add( Calendar.HOUR, 3 );
        lastDate.setTime( cal.getTimeInMillis() );
        
        synchronized (this) {
            hasData = true;
            data.clear();
            dataStart++;
            for (int i=0; i<10; i++) {
                data.add( new Integer(i+dataStart) );
            }
        }
        
    }
    
    @Override
    public String toString()
    {
        StringBuilder str = new StringBuilder();
        str.append( " " );

        String msg;
        synchronized (this) {
            for (int is = 0; is<this.dataStart; is++) {
                str.append( '*' );
            }
            
            msg = String.format( "Time (%s) has data (%s) %s", 
                                        df.format( lastDate ), hasData, str.toString() ); 
        }
        return msg;
    }
    
    synchronized public Data clone() {
        Data copy = new Data(workers);
        for (Integer dd:this.data) {
            copy.data.add( dd );
        }
        copy.dataStart = this.dataStart;
        copy.data = this.data;
        copy.hasData = this.hasData;
        return copy;
    }

    public boolean hasData()
    {
        return hasData;
    }
    
}

class Worker extends Thread {

    @Override
    public void run()
    {
        
        SimpleDateFormat df2 = new SimpleDateFormat("HH:MM:ss.SSS");
        try
        {
            while ( true ) {
                Data d = data.clone();
                if (d.hasData()) {
                    int results = process(d);
                    System.out.printf( "%s has sum %d at %s, %s\n", 
                                       this.getName(), results, df2.format( new Date() ), d.toString() );
                } else {
                    System.out.printf( "%s has no data at %s, %s\n", 
                                       this.getName(), df2.format( new Date() ), d.toString() );
                }
                if (Thread.interrupted()) {
                    throw new InterruptedException();
                }
                Thread.sleep( 100 );
            }
        }
        catch ( InterruptedException e )
        {
            System.out.printf( "%s was interrupted at %s\n", 
                               this.getName(), df2.format( new Date() ) );
        }
        
    }
    
    private int process( Data aD )
    {
        int sum=0;
        for (Integer id:aD.data) {
            sum+=id;
        }
        return sum;
        
    }

    public boolean pauseRequested()
    {
        // TODO Auto-generated method stub
        return false;
    }

    Data data;
    Random rand;

    public void initalize( Data aData, Random aRand )
    {
        data = aData;
        rand = aRand;
    }
    
}