Threads and synchronization

Hej eksperter

Jeg har fået en skoleopgave, som jeg har lidt svært ved at få knækket.

Som det fremgår af overskriften, handler opgaven Thread prg.

Jeg har fået udleveret noget kode, som jeg skulle omskrive, så klasserne Student, Sec og Boss gør brug af Threads.

Jeg synes det er lidt af en udfordring at holde styre på eksekveringsforløbet når der eksekveres concurrent.

Derfor har jeg også svært ved at overskue, hvad der bør lockes i programmet. Mit umiddelbare gæt er, at det er hensigtsmæssigt at locke arraylisten "tasks" i klassen Secretary.

Er det korrekt? Hvordan implementerer jeg dette mest hensigtsmæssigt - er det evt. ved at bruge: List list = Collections.synchronizedList(new ArrayList(...));

----

Udover overstående skal jeg også løse følgende:

b)  Enhance the code such that if there are no jobs for the secretary she will wait() for jobs

        ----> dette jeg har indsat en kommentar i koden, med et forsøg på at løse dette, men det er givetvis forkert. Håber I har nogle kommentarer. (mit gæt forudsætter at det er tasks der skal lockes  - og det har jeg endnu ikke gjort)

c)  Enhance the code in such a way that sometimes the boss can give flowers to the secretary. When he does, she will be so happy that she processes her jobs 3 times faster than usual for the next 10 seconds
        -----> denne problemstilling ved jeg ikke rigtig hvordan jeg skal få løst. Ideer modtages med kyshånd :D

Koden:
------
package lectureCode;

import java.util.Random;

class Task {
    String task;
    public Task(String task) { this.task = task; }
    public String toString() { return task; }
}

class Boss extends Thread {
    Secretary secretary;
    Random bossRan;
   
    Boss(Secretary secretary) {
        this.secretary = secretary;
        bossRan = new Random();
    }
   
    public void run(){
        while(true){
            try { Thread.sleep(bossRan.nextInt(10000)); }catch(InterruptedException e){}
            work();
        }
    }
   
    void work() {
        secretary.receive(new Task("(boss) write a letter"));
        secretary.receive(new Task("(boss) clean my desk"));
        // task.notify();
    }
}

class Student extends Thread {
    Secretary secretary;
    Random studRan;
   
    Student(Secretary secretary) {
        this.secretary = secretary;
        studRan = new Random();
    }
   
    public void run(){
        while(true){
            try { Thread.sleep(studRan.nextInt(10000)); }catch(InterruptedException e){}
            work();
        }
    }
   
    void work() {
        secretary.receive(new Task("(student) Do my homework"));
        secretary.receive(new Task("(student) proof-read my assignment"));
        //task.notify();// notifys the sec because s
    }
}

class Secretary extends Thread {
   
    java.util.ArrayList<Task> tasks = new java.util.ArrayList<Task>();   
   
    public void receive(Task task) {
        tasks.add(task);
    }

    public void run(){
        goToWork();
    }
   
    public void goToWork() {
        while(true) {
            if(tasks.size() > 0) {
                Task t = tasks.remove(0);
                System.out.println("working on '" + t + "'..");       
                try { Thread.sleep(1000); }catch(InterruptedException e){}
                System.out.println(tasks.size() + " tasks left...");
            }   
//            else
//                try {task.wait(); }catch(InterruptedException e){}
        }
    }
       
    public static void main(String[] args) {
        Secretary jane = new Secretary();
        Student john = new Student(jane);
        Boss mrDoe = new Boss(jane);

        john.start();
        mrDoe.start();
        jane.start();
           
    }
}
   
På forhånd tak!