Added all example

Author: androidcodehunter

.classpath

@@ -0,0 +1,6 @@
+<?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.7"/>
+	<classpathentry kind="output" path="bin"/>
+</classpath>

.project

@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>JavaThread</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>

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

@@ -0,0 +1,11 @@
+eclipse.preferences.version=1
+org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled
+org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.7
+org.eclipse.jdt.core.compiler.codegen.unusedLocal=preserve
+org.eclipse.jdt.core.compiler.compliance=1.7
+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.7

bin/com/javathread/anonymous/AnonymousMainClass$1.class

@@ -0,0 +1,23 @@
+package com.javathread.anonymous;
+
+public class AnonymousMainClass {
+
+	public static void main(String[] args) {
+
+		new Thread(new Runnable() {
+
+			@Override
+			public void run() {
+				try {
+					for (int i = 0; i < 5; i++) {
+						System.out.println("I am an anonymous Thread");
+						Thread.sleep(3000);
+					}
+				} catch (InterruptedException e) {
+					e.printStackTrace();
+				}
+			}
+		}).start();
+
+	}
+}

bin/com/javathread/anonymous/AnonymousMainClass.class

@@ -0,0 +1,20 @@
+package com.javathread.extending;
+
+
+public class ExtendingMainClass {
+	public static void main(String[] args) {
+		ExtendingThread thread = new ExtendingThread();
+		thread.start();
+		
+// If you want to see how each thread works, you can
+		// uncover it
+		/*try {
+			for (int i = 0; i < 5; i++) {
+				System.out.println("From Main Class Thread");
+				Thread.sleep(5000);
+			}
+		} catch (InterruptedException e) {
+			e.printStackTrace();
+		}*/
+	}
+}

bin/com/javathread/extending/ExtendingMainClass.class

@@ -0,0 +1,18 @@
+package com.javathread.extending;
+
+public class ExtendingThread extends Thread {
+
+	@Override
+	public void run() {
+		super.run();
+		try {
+			for (int i = 0; i < 5; i++) {
+				System.out.println("I am an extending thread");
+				sleep(3000);
+			}
+
+		} catch (InterruptedException e) {
+			e.printStackTrace();
+		}
+	}
+}

bin/com/javathread/extending/ExtendingThread.class

@@ -0,0 +1,18 @@
+package com.javathread.runnable;
+
+
+public class RunnableClass implements Runnable {
+
+	@Override
+	public void run() {
+		try {
+			for (int i = 0; i < 5; i++) {
+				System.out.println("Im from Runnable Interface");
+				Thread.sleep(3000);
+			}
+		} catch (InterruptedException e) {
+			e.printStackTrace();
+		}
+	}
+
+}

bin/com/javathread/runnable/RunnableClass.class

@@ -0,0 +1,32 @@
+package com.javathread.runnable;
+
+import java.util.logging.Handler;
+
+
+public class RunnableMain {
+	public static void main(String[] args) {
+	/*	You can only use this or
+	 * below code for this solution
+	 * 
+	 * try {
+			for (int i = 0; i < 5; i++) {
+				System.out.println("asf");
+				Thread.sleep(2000);
+			}
+		} catch (InterruptedException e) {
+			e.printStackTrace();
+		}*/
+	
+			RunnableClass runnable = new RunnableClass();
+		new Thread(runnable).start();
+		
+		try {
+			for (int i = 0; i < 5; i++) {
+				System.out.println("I am from runnable main");
+				Thread.sleep(3000);
+			}
+		} catch (InterruptedException e) {
+			e.printStackTrace();
+		}
+	}
+}

bin/com/javathread/runnable/RunnableMain.class

@@ -0,0 +1,27 @@
+package com.javathread.synchronize;
+
+public class MyThread extends Thread {
+	private int threadId;
+	private TargetClass target;
+
+	public MyThread(int threadId, TargetClass target) {
+		this.threadId = threadId;
+		this.target = target;
+	}
+
+	@Override
+	public void run() {
+		super.run();
+
+		synchronized (target) {
+			try {
+				sleep(2000);
+			} catch (InterruptedException e) {
+				e.printStackTrace();
+			}
+			target.call(threadId);
+		}
+
+	}
+
+}

bin/com/javathread/synchronize/MyThread.class

@@ -0,0 +1,16 @@
+package com.javathread.synchronize;
+
+public class SynchronizeMain {
+	public static void main(String[] args) {
+		TargetClass target = new TargetClass();
+
+		MyThread t1 = new MyThread(1, target);
+		MyThread t2 = new MyThread(2, target);
+		MyThread t3 = new MyThread(3, target);
+
+		t1.start();
+		t2.start();
+		t3.start();
+	}
+
+}

bin/com/javathread/synchronize/SynchronizeMain.class

@@ -0,0 +1,10 @@
+package com.javathread.synchronize;
+
+public class TargetClass {
+	
+	public void call(int threadId)
+	{
+		System.out.println("Calling from Thread"+ threadId);
+	}
+
+}