Scribd
Upload
11 views4 pages

Creating Threads in Java Examples

The document contains 6 problems related to creating and using threads in Java. Problem 1 creates a thread by extending Thread and using the sleep() method. Problem 2 creates a thread by extending Thread to compare with Problem 3. Problem 3 creates a thread by implementing Runnable instead of extending Thread. Problem 4 also implements Runnable but calls run() directly instead of using start() to compare with Problem 3. Problem 5 creates 3 threads and uses join() to wait for the first thread to finish before starting the others. Problem 6 is similar but uses a timeout with join().

Uploaded by

Jesmin Mostafa
Copyright
© All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as DOCX, PDF, TXT or read online on Scribd
11 views4 pages

Creating Threads in Java Examples

The document contains 6 problems related to creating and using threads in Java. Problem 1 creates a thread by extending Thread and using the sleep() method. Problem 2 creates a thread by extending Thread to compare with Problem 3. Problem 3 creates a thread by implementing Runnable instead of extending Thread. Problem 4 also implements Runnable but calls run() directly instead of using start() to compare with Problem 3. Problem 5 creates 3 threads and uses join() to wait for the first thread to finish before starting the others. Problem 6 is similar but uses a timeout with join().

Uploaded by

Jesmin Mostafa
Copyright
© All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as DOCX, PDF, TXT or read online on Scribd

• Problem 01: Thread : Create thread by extending Thread class with sleep() method

package threadexamp;

class ex1 extends Thread{


@Override
public void run()
{
for(int i=0;i<5;i++)
{
try{
[Link](500);
}catch(Exception e){

}
[Link](i);
}

public class ThreadExamp {

public static void main(String[] args) {


ex1 t1=new ex1();
ex1 t2=new ex1();
[Link]();
[Link]();

}
• Problem 02: Thread : Create thread by extending Thread class for comparing with problem 3

class test1 extends Thread{

@Override
public void run()
{
[Link]("Run method executed by child Thread");

public static void main(String[] args) {


test1 t1=new test1();
[Link]();

[Link]("Main method executed by main thread");


}
}

Problem 03: Thread : Create thread by implementing Runnable interface


class Test implements Runnable {
@Override
public void run()
{
[Link]("Run method executed by child Thread");
}
public static void main(String[] args)
{

Test t = new Test();

Thread t1 = new Thread(t);

[Link]();
[Link]("Main method executed by main thread");
}
}
Problem 04: Thread : Create thread by implementing Runnable interface for comparing with Problem 03
where run() executing following thread rule(main() method will be executed first then others). But in
Problem 04 run() executing in normal sequence also run() executing following thread rule when passing
object through thread.
class Test implements Runnable {
@Override
public void run()
{
[Link]("Run method executed by child Thread");
}
public static void main(String[] args)
{

Test t = new Test();


[Link]();
Thread t1 = new Thread(t);
[Link]();
[Link]("Main method executed by main thread");
}
}

Problem 05: Thread : Create thread and use join() method

class Joinmethod extends Thread{

public void run(){


for(int i=1;i<=5;i++){
try{
[Link](500);
}catch(Exception e){[Link](e);}
[Link](i);
}
}
public static void main(String args[]){
Joinmethod t1=new Joinmethod();
Joinmethod t2=new Joinmethod();
Joinmethod t3=new Joinmethod();
[Link]();
try{
[Link]();
}catch(Exception e){[Link](e);}

[Link]();
[Link]();
}
}
Problem 06: Thread : Create thread and use join() method

class Joinmethod extends Thread{

public void run(){


for(int i=1;i<=5;i++){
try{
[Link](500);
}catch(Exception e){[Link](e);}
[Link](i);
}
}
public static void main(String args[]){
Joinmethod t1=new Joinmethod();
Joinmethod t2=new Joinmethod();
Joinmethod t3=new Joinmethod();
[Link]();
try{
[Link](1500);
}catch(Exception e){[Link](e);}

[Link]();
[Link]();
}
}

Common questions

Powered by AI

Partial joining with a specified time in the join() method affects program flow by allowing the current thread to wait only for a specified duration for another thread to finish. If the referenced thread doesn't complete within this period, the waiting thread resumes execution. This approach provides greater flexibility in designing systems that must remain responsive or make progress even if certain operations take longer than expected. It offers a balance between strict sequential execution and full concurrency .

Using the Runnable interface generally facilitates better code reusability and maintenance because Runnable decouples the thread execution behavior from the actual task logic, allowing the same task implementation to be executed by different threads or utilized in non-threaded contexts. This promotes separation of concerns, making it easier to test, maintain, and extend code. By contrast, extending the Thread class ties both behavior and execution, making it less versatile for reuse in diverse application scenarios .

Not handling exceptions within threaded methods in Java can lead to uncontrolled termination of threads, resulting in inconsistent application states, resource leaks, or incomplete task execution. Such shortcomings can affect program reliability, as unexpected thread deaths may leave critical resources locked or shared data in a corrupted state, potentially causing data loss or application crashes. Effective exception handling is critical in multithreading to ensure robust error recovery and system resiliency .

Using the sleep() method inside a thread's run() method pauses the execution of the thread for a specified period, allowing other threads to execute. This can be useful for managing resources and ensuring more balanced CPU utilization. However, sleep() can throw an InterruptedException, which must be handled either with a try-catch statement or propagated with a throws clause. Proper exception handling is required to manage potential interruptions or changes in execution flow .

The sleep() method can significantly affect thread prioritization and system performance by intentionally pausing thread execution, allowing other threads of equal or lower priority a chance to execute. This can improve overall system responsiveness and efficiency by ensuring resource distribution is not heavily skewed towards more frequently executing threads. However, overuse or misuse may lead to underutilized CPU time slices or introduce latency in time-sensitive operations, thus requiring careful balance and consideration in performance-critical applications .

When extending Thread, the main method typically executes first, then creates and starts new threads which execute their run methods independently. Conversely, when implementing Runnable, the main method also begins first, but the execution of the run method can be directly invoked, or managed through a Thread object, allowing more control over the sequence, such as delaying its execution explicitly. This structured division allows clearer separation between thread logic and thread usage, favoring the Runnable approach in synchronized or sequential processing needs .

Direct invocation of the run() method executes the method in the calling thread context rather than creating a new concurrent execution thread. This results in the run method being executed sequentially and immediately within the main thread, which differs from the typical asynchronous execution pattern expected with threads. This can be useful for debugging or when thread-like behavior is not necessary, but it negates the benefits of concurrent execution, potentially causing performance bottlenecks if not managed carefully .

Implementing the Runnable interface is more advantageous when your class needs to perform multiple tasks simultaneously and extends another class, as Java does not support multiple inheritance. By implementing Runnable, a class can inherit from another superclass and still be able to run as a thread, thus supporting more flexible design architectures and maximizing code reuse .

Creating threads with the Runnable interface supports better error handling and resource allocation because it separates the task logic from the thread creation itself, allowing for centralized management of error handling strategies and optimized allocation of resources. This structure makes it easier to encapsulate and reuse error handling logic and resource management protocols across different parts of an application, contributing to more coherent and controlled thread lifecycle management .

Calling the join() method on a thread ensures that the current thread will wait for the termination of the specified thread before continuing its execution. This method influences the thread execution sequence by guaranteeing that the specified thread completes its execution before the join() call returns, which can be useful for managing the order of operations or ensuring certain threads complete before starting others .

You might also like