Verzeichnis VL04_09 erweitert

VL04_04/CallByRefArray-C/bin/.gitignore

-/inf3/

VL04_09/ThreadDurchVererbung_0/.classpath

+<?xml version="1.0" encoding="UTF-8"?>
+<classpath>
+	<classpathentry kind="src" path="src" />
+	<classpathentry kind="con"
+		path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.8" />
+	<classpathentry kind="output" path="bin" />
+</classpath>

VL04_09/ThreadDurchVererbung_0/.project

+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>ThreadDurchVererbung_0</name>
+	<comment></comment>
+	<projects>
+	</projects>
+	<buildSpec>
+		<buildCommand>
+			<name>org.eclipse.jdt.core.javabuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+	</buildSpec>
+	<natures>
+		<nature>org.eclipse.jdt.core.javanature</nature>
+	</natures>
+</projectDescription>

VL04_09/ThreadDurchVererbung_0/.settings/org.eclipse.jdt.core.prefs

+eclipse.preferences.version=1
+org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled
+org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.8
+org.eclipse.jdt.core.compiler.codegen.unusedLocal=preserve
+org.eclipse.jdt.core.compiler.compliance=1.8
+org.eclipse.jdt.core.compiler.debug.lineNumber=generate
+org.eclipse.jdt.core.compiler.debug.localVariable=generate
+org.eclipse.jdt.core.compiler.debug.sourceFile=generate
+org.eclipse.jdt.core.compiler.problem.assertIdentifier=error
+org.eclipse.jdt.core.compiler.problem.enumIdentifier=error
+org.eclipse.jdt.core.compiler.source=1.8

VL04_09/ThreadDurchVererbung_0/src/MyThreads/MainProg.java

+package MyThreads;
+/** Das Programm zeigt, wie das Betriebssystem (die Java VM) verschiedenen Threads 
+* Rechenzeit zuordnet. 
+* 
+* <p>Der Main-Thread des Programms gibt hierzu über eine Endlosschleife 
+* Sternchen auf der Konsole aus. Parallel hierzu wird ein zweiter Thread gestartet, der 
+* auf eine Eingabe von der Tastatur wartet und ein eigegebene Zeichen wieder auf der Konsole
+* ausgibt, sobald die Returntaste gedrückt wird.
+* 
+* <p>Es ist zu erkennen, dass die Ausgabe des Echos der Tastatureingabe offenbar die Ausgabe der
+* Sternchen kurzzeitig unterbricht.
+*
+* @author Steddin
+* @version 2.00, 2020-01-06
+*/
+public class MainProg {
+	public static void main(String[] args) {
+		MyThreadClass myThread = new MyThreadClass();
+		myThread.start();
+		int kk = 0;
+		while (true) {
+			if ((kk%10_000_000) == 0) {
+				System.out.print("*");
+			}
+			kk++;
+			if (kk%100_000_000==0) {
+				System.out.print("\n");
+			}
+		}
+	}
+}
+
+
+

VL04_09/ThreadDurchVererbung_0/src/MyThreads/MyThreadClass.java

+package MyThreads;
+import java.util.Scanner;
+
+public class MyThreadClass extends Thread {
+
+	public void run() {
+		Scanner myScanner = new Scanner(System.in);
+		int ii = 0;
+		while (true) {
+			ii = myScanner.nextInt();
+			System.out.println("\nEingabe: " + ii);		
+		}
+	}
+}
+
+

VL04_09/ThreadDurchVererbung_1/.classpath

+<?xml version="1.0" encoding="UTF-8"?>
+<classpath>
+	<classpathentry kind="src" path="src"/>
+	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.8"/>
+	<classpathentry kind="output" path="bin"/>
+</classpath>

VL04_09/ThreadDurchVererbung_1/.project

+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>ThreadDurchVererbung_1</name>
+	<comment></comment>
+	<projects>
+	</projects>
+	<buildSpec>
+		<buildCommand>
+			<name>org.eclipse.jdt.core.javabuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+	</buildSpec>
+	<natures>
+		<nature>org.eclipse.jdt.core.javanature</nature>
+	</natures>
+</projectDescription>

VL04_09/ThreadDurchVererbung_1/.settings/org.eclipse.jdt.core.prefs

+eclipse.preferences.version=1
+org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled
+org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.8
+org.eclipse.jdt.core.compiler.codegen.unusedLocal=preserve
+org.eclipse.jdt.core.compiler.compliance=1.8
+org.eclipse.jdt.core.compiler.debug.lineNumber=generate
+org.eclipse.jdt.core.compiler.debug.localVariable=generate
+org.eclipse.jdt.core.compiler.debug.sourceFile=generate
+org.eclipse.jdt.core.compiler.problem.assertIdentifier=error
+org.eclipse.jdt.core.compiler.problem.enumIdentifier=error
+org.eclipse.jdt.core.compiler.source=1.8

VL04_09/ThreadDurchVererbung_1/src/inf3/MyInputClass.java

+package inf3;
+/** Thread wartet auf eine Eingabe von der Tastatur. Der Thread bricht mit einer Exception ab,
+ * wenn Zeichen eingegeben werden, die keine Zahlen sind, so dass die Zahlenkonvertierung fehlschlägt.
+ */
+import java.util.Scanner;
+
+public class MyInputClass extends Thread {
+
+	public void run() {
+		Scanner myScanner = new Scanner(System.in);
+		int ii = 0;
+		while (true) {
+			ii = myScanner.nextInt();
+			System.out.println("\nEingabe: " + ii);		
+		}
+	}
+}
+
+

VL04_09/ThreadDurchVererbung_1/src/inf3/MyOutputClass.java

+package inf3;
+public class MyOutputClass extends Thread {
+	private String text;
+	private final int COUNT;
+	
+	MyOutputClass(String text, int count)
+	{
+		this.text = text;
+		COUNT = count;
+	}
+	
+	public void run() {
+		long kk = 0;
+		int ll = COUNT;
+		while (true) {
+			if (kk++ % 10_000_000 == 0) {
+				if (ll != 0) {					
+					System.out.print(text + ll + " ");
+					ll--;
+				} else {
+					System.out.println(text + ll + "newline ");
+					ll=COUNT;
+				}
+			}
+		}		
+	}
+}
+
+
+
+
+

VL04_09/ThreadDurchVererbung_1/src/inf3/ThreadDurchVererbung_1.java

+package inf3;
+/** Programm zur Demonstration von zeitgleich laufenden Threads. 
+ * 
+ * <ul>
+ * 	<li> Das Programm liest von der Konsole Text ein (Thread1) und gibt über zwei
+ *       weitere Threads unterschiedliche Texte auf der Konsole aus (Thread2 und 3)
+ *       </li>
+ *  <li> Man erkennt, dass das OS bzw. die JVM die Ausführung der Threads koordiniert
+ *       und dabei keine spezielle Reihenfolge beachtet. Dies ist möglicherweise auf 
+ *       entsprechende Optimierungsstrategien zurückzuführen.
+ *       </li> 
+ *  <li> Es soll über den Taskmanager beobachtet werden, wieviele Threads und Prozesse
+ *       vor, während und nach dem Aufruf des Programmes angezeigt werden und wie die 
+ *       Belastung der CPU ausfällt.
+ *       </li>        
+ * </ul>
+ * @author stedS
+ * @version 2.0 (2020-01-06) Ausgabe verändert
+ * @version 1.0 (2016-01-11) 
+ */
+public class ThreadDurchVererbung_1 {
+
+	public static void main(String[] args) {
+		final int COUNT = 5;
+		MyInputClass myThread1 = new MyInputClass();
+		MyOutputClass myThread2 = new MyOutputClass("Hallo", COUNT);
+		MyOutputClass myThread3 = new MyOutputClass("Meti", COUNT);
+		myThread1.start();
+		myThread2.start();
+		myThread3.start();
+	}
+}
+
+