added demon, priority

Author: connectaman

.idea/workspace.xml

@@ -132,8 +132,8 @@ It is used to develop rich internet applications. It uses a light-weight user in
 |[Create Thread](https://github.com/connectaman/Java_Notes_and_Programs/blob/master/src/Multithreading/CreateThread.md)|
 |[Thread Sleep](https://github.com/connectaman/Java_Notes_and_Programs/blob/master/src/Multithreading/ThreadSleep.md)|
 |[run() Method](https://github.com/connectaman/Java_Notes_and_Programs/blob/master/src/Multithreading/RunMethod.md)|
-|[]()|
-|[]()|
+|[Join]()|
+|[Naming a thread]()|
 |[]()|
 |[]()|
 |[]()|

README.md

@@ -0,0 +1,93 @@
+### Daemon Thread in Java
+
+Daemon thread in java is a service provider thread that provides services to the user thread. Its life depend on the mercy of user threads i.e. when all the user threads dies, JVM terminates this thread automatically.
+
+There are many java daemon threads running automatically e.g. gc, finalizer etc.
+
+You can see all the detail by typing the jconsole in the command prompt. The jconsole tool provides information about the loaded classes, memory usage, running threads etc.
+
+##### Points to remember for Daemon Thread in Java
+
+
+   - It provides services to user threads for background supporting tasks. It has no role in life than to serve user threads.
+   - Its life depends on user threads.
+   - It is a low priority thread.
+   
+-------
+
+##### Why JVM terminates the daemon thread if there is no user thread?
+
+The sole purpose of the daemon thread is that it provides services to user thread for background supporting task. If there is no user thread, why should JVM keep running this thread. That is why JVM terminates the daemon thread if there is no user thread.
+
+##### Methods for Java Daemon thread by Thread class
+
+The java.lang.Thread class provides two methods for java daemon thread.
+
+|No.|	Method|	Description|
+|-----|------|--------|
+|1)	|public void setDaemon(boolean status)	|is used to mark the current thread as daemon thread or user thread.|
+|2)	|public boolean isDaemon()	|is used to check that current is daemon.|
+
+
+---------
+
+##### Simple example of Daemon thread in java
+
+```java
+    public class TestDaemonThread1 extends Thread{  
+     public void run(){  
+      if(Thread.currentThread().isDaemon()){//checking for daemon thread  
+       System.out.println("daemon thread work");  
+      }  
+      else{  
+      System.out.println("user thread work");  
+     }  
+     }  
+     public static void main(String[] args){  
+      TestDaemonThread1 t1=new TestDaemonThread1();//creating thread  
+      TestDaemonThread1 t2=new TestDaemonThread1();  
+      TestDaemonThread1 t3=new TestDaemonThread1();  
+      
+      t1.setDaemon(true);//now t1 is daemon thread  
+        
+      t1.start();//starting threads  
+      t2.start();  
+      t3.start();  
+     }  
+    }  
+```
+Output
+```
+daemon thread work
+user thread work
+user thread work
+```
+
+--------
+
+##### Note: If you want to make a user thread as Daemon, it must not be started otherwise it will throw IllegalThreadStateException.
+
+
+```java
+    class TestDaemonThread2 extends Thread{  
+     public void run(){  
+      System.out.println("Name: "+Thread.currentThread().getName());  
+      System.out.println("Daemon: "+Thread.currentThread().isDaemon());  
+     }  
+      
+     public static void main(String[] args){  
+      TestDaemonThread2 t1=new TestDaemonThread2();  
+      TestDaemonThread2 t2=new TestDaemonThread2();  
+      t1.start();  
+      t1.setDaemon(true);//will throw exception here  
+      t2.start();  
+     }  
+    }  
+```
+```
+Output:exception in thread main: java.lang.IllegalThreadStateException
+```
+
+
+--------
+

src/Multithreading/DemonThread.md

@@ -0,0 +1,54 @@
+### The join() method
+
+The join() method waits for a thread to die. In other words, it causes the currently running threads to stop executing until the thread it joins with completes its task.
+
+##### Syntax
+
+public void join()throws InterruptedException
+public void join(long milliseconds)throws InterruptedException
+
+```java
+    class TestJoinMethod1 extends Thread{  
+     public void run(){  
+      for(int i=1;i<=5;i++){  
+       try{  
+        Thread.sleep(500);  
+       }catch(Exception e){System.out.println(e);}  
+      System.out.println(i);  
+      }  
+     }  
+    public static void main(String args[]){  
+     TestJoinMethod1 t1=new TestJoinMethod1();  
+     TestJoinMethod1 t2=new TestJoinMethod1();  
+     TestJoinMethod1 t3=new TestJoinMethod1();  
+     t1.start();  
+     try{  
+      t1.join();  
+     }catch(Exception e){System.out.println(e);}  
+      
+     t2.start();  
+     t3.start();  
+     }  
+    }  
+```
+Output
+```
+       1
+       2
+       3
+       4
+       5
+       1
+       1
+       2
+       2
+       3
+       3
+       4
+       4
+       5
+       5
+```
+
+--------
+

src/Multithreading/Join.md

@@ -0,0 +1,42 @@
+### Naming Thread and Current Thread
+
+##### Naming Thread
+
+The Thread class provides methods to change and get the name of a thread. By default, each thread has a name i.e. thread-0, thread-1 and so on. By we can change the name of the thread by using setName() method. The syntax of setName() and getName() methods are given below:
+
+    public String getName(): is used to return the name of a thread.
+    public void setName(String name): is used to change the name of a thread.
+
+
+##### Example
+```java
+    class TestMultiNaming1 extends Thread{  
+      public void run(){  
+       System.out.println("running...");  
+      }  
+     public static void main(String args[]){  
+      TestMultiNaming1 t1=new TestMultiNaming1();  
+      TestMultiNaming1 t2=new TestMultiNaming1();  
+      System.out.println("Name of t1:"+t1.getName());  
+      System.out.println("Name of t2:"+t2.getName());  
+       
+      t1.start();  
+      t2.start();  
+      
+      t1.setName("Hello");  
+      System.out.println("After changing name of t1:"+t1.getName());  
+     }  
+    }  
+```
+
+
+--------
+Output
+```
+Output:Name of t1:Thread-0
+       Name of t2:Thread-1
+       id of t1:8
+       running...
+       After changeling name of t1:Hello
+       running..
+```

src/Multithreading/NamingThread.md

@@ -0,0 +1,48 @@
+### Priority of a Thread (Thread Priority):
+
+Each thread have a priority. Priorities are represented by a number between 1 and 10. In most cases, thread schedular schedules the threads according to their priority (known as preemptive scheduling). But it is not guaranteed because it depends on JVM specification that which scheduling it chooses.
+
+#### 3 constants defined in Thread class:
+
+
+   1- public static int MIN_PRIORITY
+   
+   2- public static int NORM_PRIORITY
+   
+   3- public static int MAX_PRIORITY
+   
+   
+---------
+
+##### Example of priority of a Thread:
+
+```java
+class TestMultiPriority1 extends Thread{  
+ public void run(){  
+   System.out.println("running thread name is:"+Thread.currentThread().getName());  
+   System.out.println("running thread priority is:"+Thread.currentThread().getPriority());  
+  
+  }  
+ public static void main(String args[]){  
+  TestMultiPriority1 m1=new TestMultiPriority1();  
+  TestMultiPriority1 m2=new TestMultiPriority1();  
+  m1.setPriority(Thread.MIN_PRIORITY);  
+  m2.setPriority(Thread.MAX_PRIORITY);  
+  m1.start();  
+  m2.start();  
+   
+ }  
+}    
+```
+Output
+```
+        running thread name is:Thread-0
+       running thread priority is:10
+       running thread name is:Thread-1
+       running thread priority is:1
+```
+
+
+
+   
+