Java-Programm nur einmal starten - Versionsgeschichte

L-ectron-x: /* Einleitung */

2026-07-01T14:39:34Z

Einleitung

← Nächstältere Version		Version vom 1. Juli 2026, 14:39 Uhr
Zeile 16:		Zeile 16:
	* eine Kombination aus all dem.		* eine Kombination aus all dem.

	Jede der Lösungen bietet Vorteile, wie auch Nachteile in der Praxis. In unserem Artikel [https://~~www.~~java-blog-buch.de/d-java-anwendung-nur-einmal-~~ausfuhren~~/ Java-Anwendung nur einmal ausführen - Java-Blog-Buch] wurden die wichtigsten beschrieben.		Jede der Lösungen bietet Vorteile, wie auch Nachteile in der Praxis. In unserem Artikel [https://java-blog-buch.bytes4fun.de/d-java-anwendung-nur-einmal-ausfuehren/ Java-Anwendung nur einmal ausführen - Java-Blog-Buch] wurden die wichtigsten beschrieben.

	Demnach ist einer der größten Nachteile beim Einsatz von Lock-Dateien, dass man mit einer bereits gestarteten Anwendung nicht kommunizieren kann. Man kann die laufende Instanz bspw. nicht sichtbar machen, wenn sie gerade verdeckt ist. Das Gleiche trifft auf die Port-Sperrung zu. Im schlimmsten Fall passiert also gar nichts und/oder der Bildschirm bleibt unverändert, wenn man versucht, das gewünschte Programm ein weiteres Mal zu starten.		Demnach ist einer der größten Nachteile beim Einsatz von Lock-Dateien, dass man mit einer bereits gestarteten Anwendung nicht kommunizieren kann. Man kann die laufende Instanz bspw. nicht sichtbar machen, wenn sie gerade verdeckt ist. Das Gleiche trifft auf die Port-Sperrung zu. Im schlimmsten Fall passiert also gar nichts und/oder der Bildschirm bleibt unverändert, wenn man versucht, das gewünschte Programm ein weiteres Mal zu starten.

L-ectron-X: /* Zusammenspiel Server und Client */

2020-05-02T14:31:35Z

Zusammenspiel Server und Client

← Nächstältere Version		Version vom 2. Mai 2020, 14:31 Uhr
Zeile 358:		Zeile 358:
	<syntaxhighlight lang="java">		<syntaxhighlight lang="java">
	try {		try {
			System.out.println(frame.getTitle() + " is starting... ");
	Server server = new Server(frame, port);		Server server = new Server(frame, port);
	} catch (RemoteException \| AlreadyBoundException ex) {		} catch (RemoteException \| AlreadyBoundException ex) {
Zeile 364:		Zeile 365:
	Client client = new Client(frame.getTitle(), port);		Client client = new Client(frame.getTitle(), port);
	boolean isRunning = client.isRunningAnotherInstance();		boolean isRunning = client.isRunningAnotherInstance();
	System.out.println("~~Remote object~~ " + (~~isRunning ? "is" : "is not"~~) + " ~~available~~.");		System.out.println("The second instance of " + frame.getTitle() + " is ended.");
	if (isRunning) {		if (isRunning) {
	client.showRunningInstance();		client.showRunningInstance();
Zeile 371:		Zeile 372:
	} catch (RemoteException re) {		} catch (RemoteException re) {
	System.err.out(re);		System.err.out(re);
			JOptionPane.showMessageDialog(null,
			frame.getTitle() + " kann nicht gestartet werden, weil der Port " + port + " bereits von einer anderen Anwendung benutzt wird!",
			re.getClass().getName(),
			JOptionPane.ERROR_MESSAGE);
			System.out.println(frame.getTitle() + " is ended.");
			System.exit(0);
	}		}
	}		}
Zeile 381:		Zeile 388:
	server.shutDown();		server.shutDown();
	server = null;		server = null;
			System.out.println(frame.getTitle() + " is down.");
	} catch (RemoteException \| NotBoundException ex) {		} catch (RemoteException \| NotBoundException ex) {
	System.err.out(ex);		System.err.out(ex);

L-ectron-X: /* Implementierung der Remote-Funktionen */

2020-05-02T14:25:31Z

Implementierung der Remote-Funktionen

← Nächstältere Version		Version vom 2. Mai 2020, 14:25 Uhr
Zeile 203:		Zeile 203:
	@Override		@Override
	public boolean isRunningAnotherInstance() throws RemoteException {		public boolean isRunningAnotherInstance() throws RemoteException {
	System.out.println("~~Another~~ instance ~~is already running~~.");		System.out.println("A second instance of " + frame.getTitle() + " was started.");
	return true;		return true;
	}		}
Zeile 215:		Zeile 215:
	@Override		@Override
	public void showRunningInstance() throws RemoteException {		public void showRunningInstance() throws RemoteException {
	System.out.println("The instance that is already running is displayed.");		System.out.println("The instance of " + frame.getTitle() + " that is already running is displayed.");
	frame.pack();		frame.pack();
	frame.setLocationRelativeTo(null);		frame.setLocationRelativeTo(null);

L-ectron-X: /* Implementieren des Servers */

2020-05-02T14:23:21Z

Implementieren des Servers

← Nächstältere Version		Version vom 2. Mai 2020, 14:23 Uhr
Zeile 262:		Zeile 262:
	this.bindName = frame.getTitle();		this.bindName = frame.getTitle();
	LocateRegistry.createRegistry(port);		LocateRegistry.createRegistry(port);
			System.out.println(bindName+" listening on port " + port + "...");

	task = new RemoteTaskImpl(frame);		task = new RemoteTaskImpl(frame);
	RemoteTask stub = (RemoteTask) UnicastRemoteObject.exportObject(this.task, 0);		RemoteTask stub = (RemoteTask) UnicastRemoteObject.exportObject(this.task, 0);
	~~//RemoteServer.setLog(System.out);~~

	Registry registry = LocateRegistry.getRegistry();		Registry registry = LocateRegistry.getRegistry();
	registry.bind(this.bindName, stub);		registry.bind(this.bindName, stub);

	System.out.println("Remote object ~~stored in~~ RMI registry.");		System.out.println("Remote object bound to RMI registry.");
	}		}

Zeile 283:		Zeile 283:
	Registry registry = LocateRegistry.getRegistry();		Registry registry = LocateRegistry.getRegistry();
	registry.unbind(this.bindName);		registry.unbind(this.bindName);
			System.out.println("All services have ended.");
	}		}

L-ectron-X: /* Implementierung der Remote-Funktionen */

2020-05-02T14:14:02Z

Implementierung der Remote-Funktionen

← Nächstältere Version		Version vom 2. Mai 2020, 14:14 Uhr
Zeile 173:		Zeile 173:

	<syntaxhighlight lang="java">		<syntaxhighlight lang="java">
	import java.awt.~~Window~~;		import java.awt.Frame;
	import java.rmi.RemoteException;		import java.rmi.RemoteException;

Zeile 180:		Zeile 180:
	*/		*/
	public class RemoteTaskImpl implements RemoteTask {		public class RemoteTaskImpl implements RemoteTask {
	private final ~~Window window~~;		private final Frame frame;


	/**		/**
Zeile 187:		Zeile 186:
	* die in den Fokus des Benutzers geholt werden soll, wenn eine weitere gleichartige Anwendung		* die in den Fokus des Benutzers geholt werden soll, wenn eine weitere gleichartige Anwendung
	* gestartet werden sollte.		* gestartet werden sollte.
	* @param ~~window~~ Die Benutzeroberfläche der "ersten" Instanz.		* @param frame Die Benutzeroberfläche der "ersten" Instanz.
	*/		*/
	public RemoteTaskImpl(~~Window window~~) {		public RemoteTaskImpl(Frame frame) {
	this.~~window~~ = ~~window~~;		this.frame = frame;
	}		}

Zeile 217:		Zeile 216:
	public void showRunningInstance() throws RemoteException {		public void showRunningInstance() throws RemoteException {
	System.out.println("The instance that is already running is displayed.");		System.out.println("The instance that is already running is displayed.");
	~~window~~.pack();		frame.pack();
	~~window~~.setLocationRelativeTo(null);		frame.setLocationRelativeTo(null);
	~~window~~.setVisible(true);		frame.setVisible(true);
	~~window~~.toFront();		frame.toFront();
	}		}
	}		}

L-ectron-X am 2. Mai 2020 um 14:09 Uhr

2020-05-02T14:09:09Z

← Nächstältere Version		Version vom 2. Mai 2020, 14:09 Uhr
Zeile 3:		Zeile 3:

	=Einleitung=		=Einleitung=
	Unter bestimmten Umständen kann es gewünscht sein, dass nur eine aktive Instanz eines Programms auf einem Rechner ~~ausführbar ist~~. Sollte das Programm ein weiteres Mal aufgerufen werden, soll die gerade aktive, unsichtbare Instanz des Programms in den Fokus des ~~Bedieners~~ geholt werden. Es stellt sich also die Frage: Wie kann überprüft werden, ob ein Programm schon läuft und ~~dann das zweite Starten~~ verhindert werden?		Unter bestimmten Umständen kann es gewünscht sein, dass nur eine aktive Instanz eines Programms auf einem Rechner ausgeführt wird. Sollte das Programm ein weiteres Mal aufgerufen werden, soll die gerade aktive, (unsichtbare) Instanz des Programms in den Fokus des Benutzers geholt werden.

			'''Es stellt sich also die Frage: Wie kann überprüft werden, ob ein Programm schon läuft und anschließend ein weiterer Start verhindert werden?'''

	Jedes Java-Programm wird in einer eigenen virtuellen Maschine (VM) gestartet, somit sind sie räumlich voneinander getrennt.		Jedes Java-Programm wird in einer eigenen virtuellen Maschine (VM) gestartet, somit sind sie räumlich voneinander getrennt.
Zeile 16:		Zeile 18:
	Jede der Lösungen bietet Vorteile, wie auch Nachteile in der Praxis. In unserem Artikel [https://www.java-blog-buch.de/d-java-anwendung-nur-einmal-ausfuhren/ Java-Anwendung nur einmal ausführen - Java-Blog-Buch] wurden die wichtigsten beschrieben.		Jede der Lösungen bietet Vorteile, wie auch Nachteile in der Praxis. In unserem Artikel [https://www.java-blog-buch.de/d-java-anwendung-nur-einmal-ausfuhren/ Java-Anwendung nur einmal ausführen - Java-Blog-Buch] wurden die wichtigsten beschrieben.

	Demnach ist einer der größten Nachteile beim Einsatz von ~~Lockdateien~~, dass man mit einer bereits gestarteten Anwendung nicht kommunizieren kann. Man kann die laufende Instanz bspw. nicht sichtbar machen, wenn sie gerade verdeckt ist. Das Gleiche trifft auf die Port-Sperrung zu. Im schlimmsten Fall passiert also gar nichts und/oder der Bildschirm bleibt unverändert, wenn man versucht, das gewünschte Programm ein weiteres Mal zu starten.		Demnach ist einer der größten Nachteile beim Einsatz von Lock-Dateien, dass man mit einer bereits gestarteten Anwendung nicht kommunizieren kann. Man kann die laufende Instanz bspw. nicht sichtbar machen, wenn sie gerade verdeckt ist. Das Gleiche trifft auf die Port-Sperrung zu. Im schlimmsten Fall passiert also gar nichts und/oder der Bildschirm bleibt unverändert, wenn man versucht, das gewünschte Programm ein weiteres Mal zu starten.

	Client-/Server-Anwendungen sind meist etwas komplexer, können aber derartige Probleme lösen.		Client-/Server-Anwendungen sind meist etwas komplexer, können aber derartige Probleme lösen.

L-ectron-X: /* Implementierung der Remote-Funktionen */

2020-04-26T14:42:34Z

Implementierung der Remote-Funktionen

← Nächstältere Version		Version vom 26. April 2020, 14:42 Uhr
Zeile 215:		Zeile 215:
	public void showRunningInstance() throws RemoteException {		public void showRunningInstance() throws RemoteException {
	System.out.println("The instance that is already running is displayed.");		System.out.println("The instance that is already running is displayed.");
			window.pack();
	window.setLocationRelativeTo(null);		window.setLocationRelativeTo(null);
	window.setVisible(true);		window.setVisible(true);

L-ectron-X am 7. April 2020 um 14:34 Uhr

2020-04-07T14:34:50Z

← Nächstältere Version		Version vom 7. April 2020, 14:34 Uhr
Zeile 12:		Zeile 12:
	* einen Port sperren		* einen Port sperren
	* Client/Server-Anwendung		* Client/Server-Anwendung
	* eine Kombination aus ~~alle~~ dem.		* eine Kombination aus all dem.

	Jede der Lösungen bietet Vorteile, wie auch Nachteile in der Praxis. In unserem Artikel [https://www.java-blog-buch.de/d-java-anwendung-nur-einmal-ausfuhren/ Java-Anwendung nur einmal ausführen - Java-Blog-Buch] wurden die wichtigsten beschrieben.		Jede der Lösungen bietet Vorteile, wie auch Nachteile in der Praxis. In unserem Artikel [https://www.java-blog-buch.de/d-java-anwendung-nur-einmal-ausfuhren/ Java-Anwendung nur einmal ausführen - Java-Blog-Buch] wurden die wichtigsten beschrieben.
Zeile 165:		Zeile 165:
	</syntaxhighlight>		</syntaxhighlight>

	Die erste Methode wird also zur ~~Ermittelung~~ eines laufenden Servers benötigt, die Zweite, um die laufende (erste) Instanz sichtbar zu machen.		Die erste Methode wird also zur Ermittlung eines laufenden Servers benötigt, die Zweite, um die laufende (erste) Instanz sichtbar zu machen.

	==Implementierung der Remote-Funktionen==		==Implementierung der Remote-Funktionen==

L-ectron-X: /* Die Ausgangslage - ein einfaches Fenster */

2019-01-08T14:47:10Z

Die Ausgangslage - ein einfaches Fenster

← Nächstältere Version		Version vom 8. Januar 2019, 14:47 Uhr
Zeile 34:		Zeile 34:
	==Die Ausgangslage - ein einfaches Fenster==		==Die Ausgangslage - ein einfaches Fenster==
	Zunächst möchten wir eine einfache Anwendung erzeugen, die wir dann im weiteren Schritt mit den gewünschten Funktionen ausbauen.		Zunächst möchten wir eine einfache Anwendung erzeugen, die wir dann im weiteren Schritt mit den gewünschten Funktionen ausbauen.
	<syntaxhighlight lang="java">		<syntaxhighlight lang="java" line="true">
	import java.awt.*;		import java.awt.*;
	import java.awt.event.*;		import java.awt.event.*;
Zeile 108:		Zeile 108:
	Wir erzeugen also einen leeren {{JAPI\|JFrame}}.		Wir erzeugen also einen leeren {{JAPI\|JFrame}}.

	In Zeile 8 schalten wir das Standardverhalten des JFrames beim Beenden (Klick auf den Schließen-Button des Fensters) aus. Damit der JFrame geschlossen werden kann, implementieren wir anschließend (Zeile 9 bis Zeile 13) einen {{JAPI\|WindowListener}}, der für die Beendigung des Programms sorgt. Man könnte das auch auch einfacher lösen, in dem man in Zeile 8 <code>frame.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);</code> schreiben würde. Aber wie erwähnt wird bereits ein später benötigtes Verhalten hier implementiert.		In Zeile 15 schalten wir das Standardverhalten des JFrames beim Beenden (Klick auf den Schließen-Button des Fensters) aus. Damit der JFrame geschlossen werden kann, implementieren wir anschließend (Zeile 16 bis Zeile 20) einen {{JAPI\|WindowListener}}, der für die Beendigung des Programms sorgt. Man könnte das auch auch einfacher lösen, in dem man in Zeile 15 <code>frame.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);</code> schreiben würde. Aber wie erwähnt wird bereits ein später benötigtes Verhalten hier implementiert.

	In Zeile 15 fügen wir das in Zeile 21 bis Zeile 25 definierte {{JAPI\|JPanel}} in dem JFrame ein. Das JPanel sorgt hier erst mal nur für die Größe des JFrames bei der Ausgabe auf dem Bildschirm. Später werden wir noch Code für das JPanel hinzufügen, der die Demo anschaulicher machen wird.		In Zeile 25 fügen wir das in Zeile 31 bis Zeile 35 definierte {{JAPI\|JPanel}} in dem JFrame ein. Das JPanel sorgt hier erst mal nur für die Größe des JFrames bei der Ausgabe auf dem Bildschirm. Später werden wir noch Code für das JPanel hinzufügen, der die Demo anschaulicher machen wird.

	In Zeile 17 legen wir fest, dass die JVM unser Fenster dort auf dem Bildschirm positionieren wird, wie es den Regeln des Host-Systems zur Ausgabe von neuen Fenstern auf dem Bildschirm entspricht.		In Zeile 27 legen wir fest, dass die JVM unser Fenster dort auf dem Bildschirm positionieren wird, wie es den Regeln des Host-Systems zur Ausgabe von neuen Fenstern auf dem Bildschirm entspricht.

	Die exit()-Methode schließt unsere Anwendung, wenn der Benutzer auf den entsprechenden Fenster-Button klickt.		Die exit()-Methode schließt unsere Anwendung, wenn der Benutzer auf den entsprechenden Fenster-Button klickt.

L-ectron-X: /* Lösung des Problems */

2018-03-24T15:29:33Z

Lösung des Problems

← Nächstältere Version		Version vom 24. März 2018, 15:29 Uhr
Zeile 407:		Zeile 407:

	==Lösung des Problems==		==Lösung des Problems==
			{{In Arbeit}}

	{{Fragen stellen}}		{{Fragen stellen}}