Ausgabe auf der Konsole bei Nebenläufigkeit, Threads und Synchronisation

[BlubBlub]

also die aufgabenstellung ist wie folgt:

Sie sind von einer Firma beauftragt worden, eine neue Druckerverwaltung zu erstellen. Schreiben Sie ein Java-
Programm, das die folgende Situationen simuliert und den Zugang und die Abarbeitung von Druckaufträgen ausgibt:
Die Angestellten der Firma teilen sich einen Drucker. Dabei belegen die Angestellten den Drucker für eine bestimmte
Zeit exklusiv. Es gibt an zufälligen Zeitpunkten „Druckaufträge“ im Umfang von zufälliger Seitenzahl im Auftrag von
zufälligen Angestellten. Der Drucker druckt drei Blätter pro Sekunde.


meine lösung:

public class Druckerverwaltung
{
	private static int mitarbeiteranzahl;
	
	public static void main(String[] args) 
	{
		mitarbeiteranzahl = (int)(Math.random()*10+1);
		Drucker printer = new Drucker();
		System.out.println("Kontrollausgabe (Mitarbeiteranzahl: " + mitarbeiteranzahl + ")");
		System.out.println();
		
		for(int i = 1; i <= mitarbeiteranzahl; i++)
		{
			new Thread(new Mitarbeiter(i, printer)).start();
		}
	}
	
	public static int getMitarbeiteranzahl(){return mitarbeiteranzahl;}
}

public class Mitarbeiter implements Runnable
{
	int nr;
	int seiten;
	Drucker printer;
	
	Mitarbeiter(int nr, Drucker printer)
	{
		this.nr = nr;
		this.printer = printer;
		seiten = (int)(Math.random()*40+1);
	}
	
	public void run()
	{
		printer.druckAuftrag(nr, seiten);	
		printer.drucken();
	}
	
}

public class Drucker extends Thread
{
	int[] auftrag = new int[Druckerverwaltung.getMitarbeiteranzahl()];
	
	public synchronized void druckAuftrag(int nr, int seitenanzahl)
	{
		try
		{
			sleep( (int)(Math.random()*5+1)*1000 );
		}
		catch(InterruptedException e){}
		
		System.out.println("Mitarbeiter mit der Nr. " + nr + " hat einen Druckauftrag erteilt     Seitenanzahl: " + seitenanzahl);
		System.out.println();
		auftrag[nr-1] = seitenanzahl; 
	}
	
	public synchronized void drucken()
	{
		int mitarbeiterNr;
		
		do
		{
			mitarbeiterNr = (int)(Math.random()*Druckerverwaltung.getMitarbeiteranzahl()+1);
		}
		while( !(auftrag[mitarbeiterNr-1]>0) );
		
		int druckdauer = auftrag[mitarbeiterNr-1]/3;
		
		
		System.out.println("Drucken des Auftrags von Mitarbeiter Nr. "
							+ mitarbeiterNr + "    Seitenanzahl: " + (auftrag[mitarbeiterNr-1]) 
							+ "   Dauer des Druckvorgangs: " + druckdauer + " Sekunden");
		
		try
		{
			System.out.print("Druckvorgang gestartet!    Countdown: ");
			
			for(int i = druckdauer; i > 0; i--)
			{
				System.out.print(i + "  ");
				sleep(1000);
			}
			System.out.println();
		}
		catch(InterruptedException e){}
		
		System.out.println("Druckvorgang abgeschlossen!");
		System.out.println();
		
		auftrag[mitarbeiterNr-1] = 0;	
	}
}

Beispielausgabe:

Kontrollausgabe (Mitarbeiteranzahl: 5)

Mitarbeiter mit der Nr. 1 hat einen Druckauftrag erteilt Seitenanzahl: 22

Drucken des Auftrags von Mitarbeiter Nr. 1 Seitenanzahl: 22 Dauer des Druckvorgangs: 7 Sekunden
Druckvorgang gestartet! Countdown: 7 6 5 4 3 2 1
Druckvorgang abgeschlossen!

Mitarbeiter mit der Nr. 4 hat einen Druckauftrag erteilt Seitenanzahl: 16

Drucken des Auftrags von Mitarbeiter Nr. 4 Seitenanzahl: 16 Dauer des Druckvorgangs: 5 Sekunden
Druckvorgang gestartet! Countdown: 5 4 3 2 1
Druckvorgang abgeschlossen!

Mitarbeiter mit der Nr. 5 hat einen Druckauftrag erteilt Seitenanzahl: 14

Mitarbeiter mit der Nr. 3 hat einen Druckauftrag erteilt Seitenanzahl: 19

Drucken des Auftrags von Mitarbeiter Nr. 5 Seitenanzahl: 14 Dauer des Druckvorgangs: 4 Sekunden
Druckvorgang gestartet! Countdown: 4 3 2 1
Druckvorgang abgeschlossen!

Mitarbeiter mit der Nr. 2 hat einen Druckauftrag erteilt Seitenanzahl: 12

Drucken des Auftrags von Mitarbeiter Nr. 2 Seitenanzahl: 12 Dauer des Druckvorgangs: 4 Sekunden
Druckvorgang gestartet! Countdown: 4 3 2 1
Druckvorgang abgeschlossen!

Drucken des Auftrags von Mitarbeiter Nr. 3 Seitenanzahl: 19 Dauer des Druckvorgangs: 6 Sekunden
Druckvorgang gestartet! Countdown: 6 5 4 3 2 1
Druckvorgang abgeschlossen!

-----------------------------------------------------------------------------------

das Programm funktioniert eigentlich wunderbar denk ich.

Mein Problem:
Ich hab das Programm mehrfach ausprobiert, dabei ist mir aufgefallen dass es immer
nur zu solchen ausgaben kommt:

(als beispiel)

Drucken des Auftrags von Mitarbeiter Nr. 5 Seitenanzahl: 14 Dauer des Druckvorgangs: 4 Sekunden
Druckvorgang gestartet! Countdown: 4 3 2 1
Druckvorgang abgeschlossen!

Mitarbeiter mit der Nr. 2 hat einen Druckauftrag erteilt Seitenanzahl: 12


aber es kommt nie zu solch einer ausgabe:

(als beispiel)

Drucken des Auftrags von Mitarbeiter Nr. 5 Seitenanzahl: 14 Dauer des Druckvorgangs: 4 Sekunden
Druckvorgang gestartet! Countdown: 4 3 2 1

Mitarbeiter mit der Nr. 2 hat einen Druckauftrag erteilt Seitenanzahl: 12

Druckvorgang abgeschlossen!


Dabei sind die zwei synchronisierten methoden unabhängig voneinander, so dass die eine synchronisierte methode schon ihre ausgabe machen könnte während die andere noch ihren countdown macht. aber dazu kommt es nie, es wird jedesmal gewartet bis die synchronisierte methode die den countdown durchführt alle ihre ausgaben komplett ausgeführt hat, bevor die andere synchronisierte methode ihre ausgaben macht.
Also erst wenn "Druckvorgang abgeschlossen" ausgegeben wurde gibt die andere synchronisierte methode ihren text aus.

Bedeutet es, dass die synchronisierten methoden sich immer gegenseitig aufhalten was die ausgabe betrifft?
wenn ja dann würden die threads ja nicht wirklich parallel ausgeführt werden im hinblick auf die ausgabe zumindest.

 

[Michael...]

aber es kommt nie zu solch einer ausgabe:
(als beispiel)

Drucken des Auftrags von Mitarbeiter Nr. 5 Seitenanzahl: 14 Dauer des Druckvorgangs: 4 Sekunden
Druckvorgang gestartet! Countdown: 4 3 2 1

Mitarbeiter mit der Nr. 2 hat einen Druckauftrag erteilt Seitenanzahl: 12

Druckvorgang abgeschlossen!

Wenn ich mich nicht irre, ist sobald eine synchronisierte Methode eines Objekts aufgerufen wird, das komplette Objekt und somit alle anderen Methoden für weitere Threads gesperrt.

Ansonsten ist dein Konzept ein bisschen merkwürdig. In deinem Beispiel übergibt der Mitarbeiter einen Druckauftrag und stößt anschließend das Drucken an. Eigentlich müsste es doch so sein, dass der Mitarbeiter einen Druckauftrag an den Drucker übergibt und dieser kümmert sich selbst darum wann und wie der Auftrag ausgeführt wird.

 

[BlubBlub]

Wenn ich mich nicht irre, ist sobald eine synchronisierte Methode eines Objekts aufgerufen wird, das komplette Objekt und somit alle anderen Methoden für weitere Threads gesperrt.

okay, das wusste ich nicht, ich dachte dass nur die eine synchronisierte methode dann gesperrt ist, die anderen aber weiterhin zugänglich sind.

Ansonsten ist dein Konzept ein bisschen merkwürdig. In deinem Beispiel übergibt der Mitarbeiter einen Druckauftrag und stößt anschließend das Drucken an. Eigentlich müsste es doch so sein, dass der Mitarbeiter einen Druckauftrag an den Drucker übergibt und dieser kümmert sich selbst darum wann und wie der Auftrag ausgeführt wird.

ja das stimmt, aber mir fiel nichts besseres ein, wie ich es sonst erreichen kann, dass die drucker nachdem sie einen auftrag erhalten haben, erst nach einer zufälligen zeit diesen ausführen.
würde ich die printer.drucken(); Methode , die in der Klasse Mitarbeiter ist,
in die Klasse Drucker legen und zwar ans Ende der synchronisierte methode druckAuftrag(..) , dann würde der drucker zwar das drucken aufrufen aber dann wäre die aufgabenstellung nicht erfüllt, weil dann der druckauftrag sofort abgearbeitet wird und zwar in der reihenfolge in der die aufträge eingegangen sind und nicht in einer beliebigen reihenfolge.
falls jemand ne idee hat wie man das anders lösen könnte, wäre ich sehr an dieser idee interessiert.

 

[Ariol]

import java.util.concurrent.ConcurrentLinkedQueue;

public class Printer extends Thread
{
	ConcurrentLinkedQueue<Printjob>	jobs	= new ConcurrentLinkedQueue<Printjob>();

	public void addJob(Printjob printjob)
	{
		System.out.println("Mitarbeiter mit der Nr. " + printjob.getEmployeeID() + " hat einen Druckauftrag erteilt     Seitenanzahl: " + printjob.getPageCount() + "\n");
		jobs.offer(printjob);
	}

	public void run()
	{
		while (true)
		{
			while (!jobs.isEmpty())
			{
				print(jobs.poll());
			}

			try
			// No jobs - wait a sec
			{
				sleep(100);
			}
			catch (InterruptedException e)
			{/* IGNORE */
			}
		}
	}

	private void print(Printjob printjob)
	{
		int pageCount = printjob.getPageCount();
		int employeeID = printjob.getEmployeeID();
		int printTime = (int) Math.ceil(pageCount / 3.0);

		System.out.println("Drucken des Auftrags von Mitarbeiter Nr. " + employeeID + "    Seitenanzahl: " + pageCount + "   Dauer des Druckvorgangs: " + printTime + " Sekunden");

		System.out.print("Druckvorgang gestartet!    Countdown: ");
		for (int i = printTime; i > 0; i--)
		{
			System.out.print(i + "  ");
			try
			{
				sleep(1000);
			}
			catch (InterruptedException e)
			{/* IGNORE */
			}
		}
		System.out.println();

		System.out.println("Druckvorgang abgeschlossen!\n");
	}
}

public class Employee extends Thread
{
    int employeeID;
    int pageCount;
    int waittime;
    Printer printer;
    
    Employee(int nr, Printer printer)
    {
        this.employeeID = nr;
        this.printer = printer;
        pageCount = (int)(Math.random()*40+1);
        waittime = (int) ((Math.random() * 5+1) * 1000);
    }
    
    public void run()
    {
    	try
  		{
  			sleep(waittime);
  		}
  		catch (InterruptedException e)
  		{
  		}
    	Printjob printjob = new Printjob(employeeID,pageCount);
        printer.addJob(printjob);   
    }
    
}

public class Printjob
{
	private int employeeID;
	private int pageCount;
	
	
	public Printjob(int employeeID, int pageCount)
	{
		this.employeeID = employeeID;
		this.pageCount = pageCount;
	}

	public int getEmployeeID()
	{
		return employeeID;
	}

	public int getPageCount()
	{
		return pageCount;
	}
}

public class Main
{
    private static int employeeCount;
    
    public static void main(String[] args) 
    {
        employeeCount = 20;//(int)(Math.random()*10+1);
        Printer printer = new Printer();
        
        System.out.println("Kontrollausgabe (Mitarbeiteranzahl: " + employeeCount + ")\n");
        
        printer.start();
        System.out.println("Drucker wurde gestartet\n");
        
        for(int i = 1; i <= employeeCount; i++)
        {
            new Thread(new Employee(i, printer)).start();
        }
    }
}

Die Queue ist threadsicher. Evtl. passt aber auch eine andere von diesen hier besser:
Galileo Computing :: Java ist auch eine Insel (8. Auflage) – 12.7 Queues (Schlangen) und Deques

 

[BlubBlub]

erstmals danke für deinen lösungsvorschlag.

ich seh da aber einige schwierigkeiten bei deiner lösung.

1. Endet das Programm nie auf grund der while(true) schleife in der Klasse Printer,
hab das erkannt als ich das Programm mal gestartet hab.
2. Im Aufgabentext steht "Dabei belegen die Angestellten den Drucker
für eine bestimmte
Zeit exklusiv.". So wie ich das verstehe bedeutet es, dass immer nur ein Angestellter
einen Druckauftrag in die Queue legen kann. Da deine Methode addjob(...) aber nicht
synchronisiert ist können alle Arbeiter auch zur selben Zeit einen Druckauftrag
abgegeben.

Ich nehme mal an es entstehen aber keine Fehler beim reinschreiben in die
Queue, falls grad zwei arbeiter oder mehr gleichzeitig in die queue schreiben,
weil die Queue wie du gesagt hast threadsicher ist.
3. Dadurch das du die Queue als Datenstruktur verwendest, werden die Druckaufträge
nach der Reihenfolge ihres Auftrag gedruckt. Wer zuerst einen Auftrag
gegeben hat, dessen Auftrag wird zuerst gedruckt.
Aber in der Aufgabenstellung war verlangt, dass die Druckaufträge in zufälliger
Reihenfolge abgearbeitet werden unbeachtet, wer zuerst einen Auftrag
erteil hat. "Es gibt an zufälligen Zeitpunkten „Druckaufträge“ im Umfang von zufälliger Seitenzahl im Auftrag von
zufälligen Angestellten. "

 

[Ariol]

...
1. Endet das Programm nie auf grund der while(true) schleife in der Klasse Printer,
hab das erkannt als ich das Programm mal gestartet hab.
...

Hab ich nicht drauf geachtet, ist aber auch schnell gelöst:

private boolean isRunning=false;
.....
public void run()
{
     isRunning=true;
     while(isRunning)
     {
          while (!jobs.isEmpty() && isRunning)
          {
....

public void shutdown()
{
    isRunning=false;
}

...
2. Im Aufgabentext steht "Dabei belegen die Angestellten den Drucker
für eine bestimmte
Zeit exklusiv.". So wie ich das verstehe bedeutet es, dass immer nur ein Angestellter
einen Druckauftrag in die Queue legen kann. Da deine Methode addjob(...) aber nicht
synchronisiert ist können alle Arbeiter auch zur selben Zeit einen Druckauftrag
abgegeben.
...

Ok, das mit dem exclusiv hab ich tatsächlich überlesen.
Na, dann mach doch aus ConcurrentLinkedQueue eine "normale" Queue + synchronized-Böcke auf diese. (Ohne Gewähr und Gewehr....)

z.B.:

public void addJob(Printjob printjob)
{
        synchronized(jobs)
        {
                System.out.println("Mitarbeiter mit der Nr. " + printjob.getEmployeeID() + " hat einen Druckauftrag erteilt     Seitenanzahl: " + printjob.getPageCount() + "\n");
                jobs.offer(printjob);
        }
}

[JAVA=19]
synchronized(jobs)
{
print(jobs.poll());
}
[/code]

...
Ich nehme mal an es entstehen aber keine Fehler beim reinschreiben in die
Queue, falls grad zwei arbeiter oder mehr gleichzeitig in die queue schreiben,
weil die Queue wie du gesagt hast threadsicher ist.
...

Genau, dafür gibt es diese Queue.

...
3. Dadurch das du die Queue als Datenstruktur verwendest, werden die Druckaufträge
nach der Reihenfolge ihres Auftrag gedruckt. Wer zuerst einen Auftrag
gegeben hat, dessen Auftrag wird zuerst gedruckt.
Aber in der Aufgabenstellung war verlangt, dass die Druckaufträge in zufälliger
Reihenfolge abgearbeitet werden unbeachtet, wer zuerst einen Auftrag
erteilt hat. "Es gibt an zufälligen Zeitpunkten „Druckaufträge“ im Umfang von
zufälliger Seitenzahl im Auftrag von zufälligen Angestellten. "
...

1. Die Aufträge gehen an beliebiegen Zeitpunkten (Employee.waittime) mit zufälliger Seitenzahl (Employee.pageCount) und von unterschiedlichen Angestellten ein (Main.main())
2. In deiner Aufgabenbeschreibung steht nichts von einer Reihenfolge unabhängig vom Eingang des Auftrags
3. Würde so ein Verhalten auch keinen wirklichen Sinn machen, wenn nicht zusätzlich eine andere Regel in Kraft tritt (kleinste Anzahl Seiten z.B.)

 

[BlubBlub]

Hab ich nicht drauf geachtet, ist aber auch schnell gelöst:

private boolean isRunning=false;
.....
public void run()
{
     isRunning=true;
     while(isRunning)
     {
          while (!jobs.isEmpty() && isRunning)
          {
....

public void shutdown()
{
    isRunning=false;
}

ok da steht leider nicht wo die shutdown methode verwendet wird und wann.
aber ich denk mal das ist dann in etwa so gedacht.

Die Main Klasse wird in der for Schleife um einen Befehlt incJobCounter() erweitert:

        for(int i = 1; i <= employeeCount; i++)
        {
            new Employee(i, printer).start();
            Printer.incJobCounter();
        }

Die Printer Klasse sieht dann so aus:

import java.util.concurrent.ConcurrentLinkedQueue;
 
public class Printer extends Thread
{
    ConcurrentLinkedQueue<Printjob> jobs    = new ConcurrentLinkedQueue<Printjob>();
    private boolean isRunning = false;
    private static int jobCounter;
    
    public void addJob(Printjob printjob)
    {
    	synchronized(jobs)
    	{
    		System.out.println("Mitarbeiter mit der Nr. " + printjob.getEmployeeID() + " hat einen Druckauftrag erteilt     Seitenanzahl: " + printjob.getPageCount() + "\n");
    		jobs.offer(printjob); // legt das element in die queue rein
    	}
    }
 
    public void run()
    {
    	isRunning =  true;
        while (isRunning)
        {
            while (!jobs.isEmpty())
            {
            	synchronized(jobs)
            	{
            		print(jobs.poll()); // gibt das head element heraus und entfernt es aus der queue 
            	}
            }
 
            try
            // No jobs - wait a sec
            {
                sleep(1000);
            }
            catch (InterruptedException e)
            {/* IGNORE */
            }
        }
    }
 
    private void print(Printjob printjob)
    {
        int pageCount = printjob.getPageCount();
        int employeeID = printjob.getEmployeeID();
        int printTime = (int) Math.ceil(pageCount / 3.0);
 
        System.out.println("Drucken des Auftrags von Mitarbeiter Nr. " + employeeID + "    Seitenanzahl: " + pageCount + "   Dauer des Druckvorgangs: " + printTime + " Sekunden");
 
        System.out.print("Druckvorgang gestartet!    Countdown: ");
        for (int i = printTime; i > 0; i--)
        {
            System.out.print(i + "  ");
            try
            {
                sleep(1000);
            }
            catch (InterruptedException e)
            {/* IGNORE */
            }
        }
        System.out.println();
 
        System.out.println("Druckvorgang abgeschlossen!\n");
        
        jobCounter--;
        if(jobCounter == 0)
        	shutdown();
    }
    
    public void shutdown(){isRunning = false;}
    public static void incJobCounter(){jobCounter++;}
}

Wenn ich eine funktion habe beispielsweise public void synchronized addJob(Printjob printjob)
bedeutet es, dass nur ein thread sich zu einer zeit in dieser methode befinden kann.

du hast aber die synchronisation anders notiert:

    public void addJob(Printjob printjob)
    {
    	synchronized(jobs)
    	{
    		System.out.println("Mitarbeiter mit der Nr. " + printjob.getEmployeeID() + " hat einen Druckauftrag erteilt     Seitenanzahl: " + printjob.getPageCount() + "\n");
    		jobs.offer(printjob); // legt das element in die queue rein
    	}
    }

und diese notation kenn ich nicht, kannst du mir das ein wenig erläutern.
bedeutet es dass jeder thread zur gleichen zeit in die addjob() methode rein kann
aber nur ein thread in den synchronisierten teil der methode gelangen kann.
würde also beispielsweise vor dem synchronized ein befehl System.out.print("test") stehen, dann würden alle threads diese ausgabe zur gleichen zeit machen können?
und dann versteh ich nicht den paramter "jobs" , den die synchronized methode "synchronized(jobs)" übergeben bekommt. woher kommt die parameter übergabe und was bedeutet sie?

Na, dann mach doch aus ConcurrentLinkedQueue eine "normale" Queue + synchronized-Böcke auf diese. (Ohne Gewähr und Gewehr....)

Okay die Queue werde ich dann gegen eine normal queue noch austauschen, schaue mir später in der api mal an, ob ich schon eine normal fertige queue finde , weil wenn ich nach Queue suche dann bekomm ich ein interface und eine queue selbst zu implementieren ist mir zu aufwändig für dieses programm.

[*]Die Aufträge gehen an beliebiegen Zeitpunkten (Employee.waittime) mit zufälliger Seitenzahl (Employee.pageCount) und von unterschiedlichen Angestellten ein (Main.main())
[*]In deiner Aufgabenbeschreibung steht nichts von einer Reihenfolge unabhängig vom Eingang des Auftrags

ok da hast du recht.


Was mir jetzt aufgefallen ist, ist dass entweder gedruckt wird oder ein auftrage angenommen wird. beides gleichzeitig funktioniert aber nicht mehr durch die synchronized teile. aber ich denke mal es wäre ziemlich kompliziert das so hinzubekommen das beides gleichzeitig geht und die anderen anforderungen der aufgabenstellung dennoch einzuhalten. wird ja auch nicht expliziet danach verlangt das beides gleichzeitig möglich sein soll, von da aus werd ich mir über dieses detail keinen kopf mehr machen.

 

[Ariol]

ok da steht leider nicht wo die shutdown methode verwendet wird und wann.
aber ich denk mal das ist dann in etwa so gedacht.

Die Main Klasse wird in der for Schleife um einen Befehlt incJobCounter() erweitert:

Dort wo man es halt braucht. Evtl. wäre es besser einfach shutdown am Ende der main()-Methode aufzurufen und die shutdown() und die addJob() entsprechend abzuändern:

private boolean shutdown = false;

....

 public boolean addJob(Printjob printjob)
    {
        if(shutdown)
               return false;
        synchronized(jobs)
        {
            System.out.println("Mitarbeiter mit der Nr. " + printjob.getEmployeeID() + " hat einen Druckauftrag erteilt     Seitenanzahl: " + printjob.getPageCount() + "\n");
            jobs.offer(printjob); // legt das element in die queue rein
        }
            return true;
    }

....

public void shutdown(){
     shutdown = true;
     while(jobCounter > 0)
     {
            try{
                sleep(100);          
            }
            catch (InterruptedException e)
            {/* IGNORE */
            }
     }
     isRunning = false; 
}

Wenn ich eine funktion habe beispielsweise public void synchronized addJob(Printjob printjob)
bedeutet es, dass nur ein thread sich zu einer zeit in dieser methode befinden kann.

du hast aber die synchronisation anders notiert:

    public void addJob(Printjob printjob)
    {
    	synchronized(jobs)
    	{
    		System.out.println("Mitarbeiter mit der Nr. " + printjob.getEmployeeID() + " hat einen Druckauftrag erteilt     Seitenanzahl: " + printjob.getPageCount() + "\n");
    		jobs.offer(printjob); // legt das element in die queue rein
    	}
    }

und diese notation kenn ich nicht, kannst du mir das ein wenig erläutern.
bedeutet es dass jeder thread zur gleichen zeit in die addjob() methode rein kann
aber nur ein thread in den synchronisierten teil der methode gelangen kann.
würde also beispielsweise vor dem synchronized ein befehl System.out.print("test") stehen, dann würden alle threads diese ausgabe zur gleichen zeit machen können?
und dann versteh ich nicht den paramter "jobs" , den die synchronized methode "synchronized(jobs)" übergeben bekommt. woher kommt die parameter übergabe und was bedeutet sie?

Das ist keine Methode sondern ein Block. Dieser sperrt nur den kritischen Bereich.
Deine Ahnung ist also richtig.

Genaueres findest du hier: Galileo Computing :: Java ist auch eine Insel (8. Auflage) – 11.5 Synchronisation über kritische Abschnitte

Okay die Queue werde ich dann gegen eine normal queue noch austauschen, schaue mir später in der api mal an, ob ich schon eine normal fertige queue finde , weil wenn ich nach Queue suche dann bekomm ich ein interface und eine queue selbst zu implementieren ist mir zu aufwändig für dieses programm.

Versuch mal

Queue<PrintJob> jobs = new LinkedList<PrintJob>();

Alle Codeschnipsel wurden ohne IDE erstellt und nicht getestet

 

[BlubBlub]

alles klar vielen danke für die vielen tipps und die hilfe, das hat mir echt weitergeholfen.