diff --git a/Technology/ThreadsDemo/.classpath b/Technology/ThreadsDemo/.classpath index fb50116..57bca72 100644 --- a/Technology/ThreadsDemo/.classpath +++ b/Technology/ThreadsDemo/.classpath @@ -1,6 +1,10 @@ + + + + + - diff --git a/Technology/ThreadsDemo/.settings/org.eclipse.core.resources.prefs b/Technology/ThreadsDemo/.settings/org.eclipse.core.resources.prefs new file mode 100644 index 0000000..99f26c0 --- /dev/null +++ b/Technology/ThreadsDemo/.settings/org.eclipse.core.resources.prefs @@ -0,0 +1,2 @@ +eclipse.preferences.version=1 +encoding/=UTF-8 diff --git a/Technology/ThreadsDemo/.settings/org.eclipse.jdt.core.prefs b/Technology/ThreadsDemo/.settings/org.eclipse.jdt.core.prefs new file mode 100644 index 0000000..8c9943d --- /dev/null +++ b/Technology/ThreadsDemo/.settings/org.eclipse.jdt.core.prefs @@ -0,0 +1,14 @@ +eclipse.preferences.version=1 +org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled +org.eclipse.jdt.core.compiler.codegen.targetPlatform=17 +org.eclipse.jdt.core.compiler.codegen.unusedLocal=preserve +org.eclipse.jdt.core.compiler.compliance=17 +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.enablePreviewFeatures=disabled +org.eclipse.jdt.core.compiler.problem.enumIdentifier=error +org.eclipse.jdt.core.compiler.problem.reportPreviewFeatures=warning +org.eclipse.jdt.core.compiler.release=enabled +org.eclipse.jdt.core.compiler.source=17 diff --git a/Technology/ThreadsDemo/src/ExtendingThreads.java b/Technology/ThreadsDemo/src/ExtendingThreads.java new file mode 100644 index 0000000..9146478 --- /dev/null +++ b/Technology/ThreadsDemo/src/ExtendingThreads.java @@ -0,0 +1,14 @@ + +public class ExtendingThreads extends Thread { + + private String myString=""; + + public ExtendingThreads( String initString ) { + myString = initString; + } + + public void run() { + System.out.println( "ExtendingThreads (" + myString + ")"); + } + +} diff --git a/Technology/ThreadsDemo/src/ImplementingRunnable.java b/Technology/ThreadsDemo/src/ImplementingRunnable.java new file mode 100644 index 0000000..b2c4052 --- /dev/null +++ b/Technology/ThreadsDemo/src/ImplementingRunnable.java @@ -0,0 +1,22 @@ + +public class ImplementingRunnable implements Runnable{ + + private String myString=""; + + public ImplementingRunnable( String initString ) { + myString = initString; + } + + public void run() { + System.out.println( "ImplementingRunnable (" + myString + ")" ); + // The next section of dead code shows how a thread may be set sleeping + if (false) { + try { + Thread.sleep(5000); // mS + } catch (InterruptedException e) { + e.printStackTrace(); + } + } + } + +} diff --git a/Technology/ThreadsDemo/src/Level1Interface.java b/Technology/ThreadsDemo/src/Level1Interface.java deleted file mode 100644 index 9c0a156..0000000 --- a/Technology/ThreadsDemo/src/Level1Interface.java +++ /dev/null @@ -1,26 +0,0 @@ -// -// Demo of thread starting a thread -// - -public class Level1Interface implements Runnable { - - private String MyString; - - public Level1Interface(String InitString) { - MyString = InitString; - } - - @Override - public void run() { - System.out.println(MyString + " Interface"); - ThreadsExtend myThreadA = new ThreadsExtend( MyString + "A" ); - myThreadA.start(); - try { - myThreadA.join(); - } catch (InterruptedException e) { - // TODO Auto-generated catch block - e.printStackTrace(); - } - System.out.println(MyString + " Interface...Done"); - } -} diff --git a/Technology/ThreadsDemo/src/ThreadStartingThread.java b/Technology/ThreadsDemo/src/ThreadStartingThread.java new file mode 100644 index 0000000..f5ec000 --- /dev/null +++ b/Technology/ThreadsDemo/src/ThreadStartingThread.java @@ -0,0 +1,23 @@ + +public class ThreadStartingThread implements Runnable{ + + private String myString=""; + + public ThreadStartingThread( String initString ) { + myString = initString; + } + + @Override + public void run() { + System.out.println( "ThreadStartingThread (" + myString + ")" ); + ExtendingThreads myThreadA = new ExtendingThreads( "ThreadStartingThread " + myString ); + myThreadA.start(); + try { + myThreadA.join(); + } catch (InterruptedException e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } + } + +} diff --git a/Technology/ThreadsDemo/src/ThreadsDemo.java b/Technology/ThreadsDemo/src/ThreadsDemo.java index fd1639f..58cf06a 100644 --- a/Technology/ThreadsDemo/src/ThreadsDemo.java +++ b/Technology/ThreadsDemo/src/ThreadsDemo.java @@ -1,23 +1,42 @@ +// Karsten Jeppesen, UCN +// There are 3 ways to start threads. +// This demo will show two of the options +// - by extending the Thread class and overriding its run() method +// - by implementing the Runnable interface +// public class ThreadsDemo { public static void main(String[] args) { - ThreadsExtend myThreadA = new ThreadsExtend("A"); - ThreadsExtend myThreadB = new ThreadsExtend("B"); - ThreadsExtend myThreadC = new ThreadsExtend("C"); - Runnable myRunnableD = new ThreadsInterface("D"); - Runnable myRunnableE = new ThreadsInterface("E"); - Runnable myRunnableF = new Level1Interface("F"); + System.out.println("Main"); + + // Extending the Thread class will oc result in a thread + ExtendingThreads myThreadA = new ExtendingThreads("A"); + ExtendingThreads myThreadB = new ExtendingThreads("B"); + ExtendingThreads myThreadC = new ExtendingThreads("C"); + + // implementing the runnable interface will require an additional call to threads + Runnable myRunnableD = new ImplementingRunnable("D"); + Runnable myRunnableE = new ImplementingRunnable("E"); + Runnable myRunnableF = new ImplementingRunnable("F"); + Runnable myRunnableL = new ThreadStartingThread("L"); + + // Here we inject the runnable into the thread class + Thread myThreadD = new Thread( myRunnableD ); + Thread myThreadE = new Thread( myRunnableE ); + Thread myThreadF = new Thread( myRunnableF ); + Thread myThreadL = new Thread( myRunnableL ); + + // Starting all threads. Note that sequence can not be guaranteed. myThreadA.start(); myThreadB.start(); myThreadC.start(); - Thread myThreadD = new Thread( myRunnableD ); myThreadD.start(); - Thread myThreadE = new Thread( myRunnableE ); myThreadE.start(); - Thread myThreadF = new Thread( myRunnableF ); myThreadF.start(); + myThreadL.start(); + // Waiting for all threads to complete is considered best practice try { myThreadA.join(); myThreadB.join(); @@ -25,10 +44,12 @@ public class ThreadsDemo { myThreadD.join(); myThreadE.join(); myThreadF.join(); + myThreadL.join(); } catch (InterruptedException e) { - // TODO Auto-generated catch block e.printStackTrace(); } - System.out.println("Main Done..."); + + System.out.println("Main... Done"); } + } diff --git a/Technology/ThreadsDemo/src/ThreadsExtend.java b/Technology/ThreadsDemo/src/ThreadsExtend.java deleted file mode 100644 index 791bf1f..0000000 --- a/Technology/ThreadsDemo/src/ThreadsExtend.java +++ /dev/null @@ -1,20 +0,0 @@ - -public class ThreadsExtend extends Thread { - private String MyString; - - public ThreadsExtend ( String InitString ) { - MyString = InitString; - } - - - public void run() { - try { - Thread.sleep(5000); - } catch (InterruptedException e) { - // TODO Auto-generated catch block - e.printStackTrace(); - } - System.out.println(MyString + " running"); - } - -} diff --git a/Technology/ThreadsDemo/src/ThreadsInterface.java b/Technology/ThreadsDemo/src/ThreadsInterface.java deleted file mode 100644 index 2314e6b..0000000 --- a/Technology/ThreadsDemo/src/ThreadsInterface.java +++ /dev/null @@ -1,15 +0,0 @@ - -public class ThreadsInterface implements Runnable { - - private String MyString; - - public ThreadsInterface(String InitString) { - MyString = InitString; - } - - @Override - public void run() { - System.out.println(MyString + " Interface"); - } - -}