Unit 04

Introduction

A thread in Java is a lightweight subprocess and the smallest unit of execution. It represents a separate path of execution within a program. Threads run inside a process and share the same memory space.

Definition: A thread is an independent flow of control that allows multiple tasks to be executed simultaneously within a single program.

Key Features of Threads

Creation of Threads in Java

Threads can be created in two ways:

• By extending the Thread class
• By implementing the Runnable interface

Example — Using Thread Class

class MyThread extends Thread {
    public void run() {
        System.out.println("Thread is running...");
    }

    public static void main(String args[]) {
        MyThread t1 = new MyThread();
        t1.start();  // starts the thread
    }
}

Explanation

• A class MyThread extends the Thread class.
• The run() method defines the task to be executed.
• The start() method creates a new thread and calls run() internally.

The life cycle of a thread represents the different states a thread passes through during its execution. It is controlled by the JVM.

States of a Thread

Thread priority determines the order in which threads are scheduled for execution by the CPU. Each thread has a priority value between 1 to 10.

Priority Constants

Methods for Thread Priority

Example

class MyThread extends Thread {
    public void run() {
        System.out.println("Running: " + Thread.currentThread().getName());
    }

    public static void main(String args[]) {
        MyThread t1 = new MyThread();
        MyThread t2 = new MyThread();

        t1.setPriority(8);
        t2.setPriority(3);

        t1.start();
        t2.start();
    }
}

Explanation

• Two threads are created with different priorities.
• Thread t1 has priority 8, t2 has priority 3.
• Thread with higher priority (t1) is more likely to execute first.

Introduction to Packages

A package in Java is a collection of related classes, interfaces, and sub-packages. It acts as a container to organise code into a hierarchical structure.

Definition: A package is a namespace that organises a set of related classes and interfaces.

Types of Packages

Advantages of Packages

Package Naming

A package is declared at the beginning of a Java file using:

package package_name;

Naming Conventions

• Usually written in lowercase letters.
• Should match the directory structure exactly.
• Can be hierarchical — e.g., com.example.project
• Java is case-sensitive, so package name must match folder name exactly.

The import statement is used to access classes from other packages.

import package_name.*;

import package_name.class_name;

Example Program

package mypack;

import java.util.*;        // import entire package
import java.util.Scanner;  // import specific class

class Test {
    public static void main(String args[]) {
        Scanner sc = new Scanner(System.in);
        System.out.println("Enter number:");
        int n = sc.nextInt();
        System.out.println(n);
    }
}

Explanation

• package defines the package name for this file.
• import java.util.* imports all classes from java.util.
• import java.util.Scanner imports only the Scanner class.

Introduction

Package specification in Java refers to the process of declaring, defining, and organising a package so that classes and interfaces can be grouped and used efficiently.

Steps for Package Specification

package package_name;

java package_name.class_name

Example

package pack;

public class A {
    public void msg() {
        System.out.println("Hello");
    }
}

• The file is saved inside a folder named pack.
• The class A is public so it can be accessed from other packages.
• To run: java pack.A