'Back-End/Java_1'에 해당되는 글 48건

Call a run() directly instead start()

- Each thread starts in a separate call stack, like this

- Invoking the run() from main thread, the run() method goes onto the current call stack 

1. Problem

public class directRn extends Thread{ public void run(){ for(int i = 0; i<5;i++){ try{ Thread.sleep(500); }catch(InterruptedException e){ System.out.println(e); } System.out.println(i); } } public static void main(String[]args){ directRn t1 = new directRn(); directRn t2 = new directRn(); t1.run(); t2.run(); } }

- There is no context-switching 

- t1 and t2 will be treated as normal object not thread object

Sleeping a thread

- It is used to sleep a thread for the specified amount of time

1. Syntax

- public static void sleep(long miliseconds)throws InterruptedExceptioin

- public static void sleep(long miliseconds, int nanos)throws InterruptedException

2. Example

public class Sleeping extends Thread{ public void run(){ for(int i = 1; i<5;i++){ try{ Thread.sleep(500); }catch(InterruptedException e){ System.out.println(e); } System.out.println(i); } } public static void main(String[]args){ Sleeping t1 =new Sleeping(); Sleeping t2 =new Sleeping(); t1.start(); t2.start(); } }

- At a time only one thread is executed

- If you sleep a thread for the specified time, the thread schedular pick up another thread

Thread Scheduler

1. What is it?

- Thread scheduler is the part of the JVM that decides which thread should run

- Only one thread at a time can run in a single process

- The Thread scheduler mainly uses preemptive or time slicing scheduling to schedule the threads

2. Different between preemptive and time slicing

1) preemptive

- The highest priority task executes until it enters the waiting or dead states

- A higher priority task comes into existence

2) time slicing

- A task executes for a predefined slice of time and then reenters the pool of ready tasks

- The scheduler then determines which task should execute next, based on priority and other factors

Creating thread

- There are two way to create a thread

1) By extending Thread class

2) By implementing Runnable interface

1. Runnable interface

- Runnable interface have only one method named run()

1) run()

- It is used to perform action for a thread

2. Starting a thread

1) start()

- It is used to start a newly created thread

- It performs following task

a. A new thread starts(with new callstack)

b. The thread moves from New State to the Runnable state

c. When the thread gets a chance to execute, its target run() mehtod will run

3. By extending Thread class

public class ByExtending extends Thread{ public void run(){ System.out.println("Thread is running"); } public static void main(String[] args){ ByExtending t1 = new ByExtending(); t1.start(); } }

4. By implementing Runnable interface

public class ByImplement implements Runnable{ public void run(){ System.out.println("Thread is running"); } public static void main(String[]args){ ByImplement m1 = new ByImplement(); Thread t1 = new Thread(m1); t1.start(); } }  

- If you are not extending the Thread class, your class object would not be treated as a thread object

- you need to explicitely create Thread class object