Object-Oriented Programming SWE211

Object-Oriented Programming SWE211

• Course is taught by Walaa H. Elashmawi
• Contact email: [email protected]

Multithreading and Sharing Objects

• Multithreading involves multiple tasks executing concurrently within a program
• Each thread has a beginning and an end
• Threads are not static code, but dynamic processes of executing code

Introduction

• Threads are separate activities within a program
• Threads can monitor keyboard input, track mouse movement, and update the screen concurrently
• Each task (like keyboard monitoring or mouse tracking) can be a separate thread
• Threads execute code dynamically, not just statically

Single Threaded Program

• Most programs written before understanding threading only have one thread (started by main method)
• A single thread executes in a linear, sequential manner from start to finish

Multithreaded Program

• A multithreaded program allows multiple threads to run concurrently
• Threads can be visualized as independent boxes with a main thread at the top running multiple threads concurrently

Concurrent System - Threads Concept

• A collection of activities/tasks occurring simultaneously
• Each task can be turned into a thread
• Multiple threads can run genuinely concurrently on multiple processors
• Threads share the CPU with other threads through allocating time slices
• The operating system distributes time to the threads

Main Thread

• The default thread in every Java program
• The Java Virtual Machine uses the main thread to execute program statements
• Example shown finds the specified main thread

Creating Threads

• Threads are treated as objects in Java
• Thread classes are located in the java.lang library
• Defining methods to create, destroy, and edit threads is possible

Defining Thread Classes

• Can be done by inheriting from the Thread class

• Preferred if you need to inherit only from the Thread class

• Java does not support multiple inheritance

• Can be done by implementing the Runnable interface

• Preferred when you want to inherit from other classes besides the Thread class

Runnable methods

• The run() method must be overridden to define the thread's task

Inherit From the Thread Class

• Define a class to be extended from the Thread class and make run method specific
• Create an instance of the class
• Use thr1.start() to start the thread

An Example program

• Demonstrates a basic thread creation
• Demonstrates how the thread is started

Implementing the Runnable Interface

• Define a runnable class by implementing the Runnable interface and overriding the run method
• Create an instance of the class and a Thread for it
• Start the thread by calling its start() method

An Example program (Runnable implementation)

• Demonstrates a runnable class creation and start thread

Thread States

• A thread can be in one of five states: New, Ready, Running, Blocked, or Finished.

Movement between states

• The Java system controls the switch in between states.
• The start() method moves a thread into the runnable state.
• Threads can be interrupted, yielding CPU time or blocked because of input / output processing
• In blocked state, the thread stays there until some event occurs to allow it to finish its execution

wait(), notify(), and notifyAll

• These are object methods used for thread communication.
• Must be used within synchronized blocks

Thread Methods

• The Thread class in java has methods for various functionalities

Other Methods

• A series of methods in Thread class for accessing current thread, sleep, and interrupts

Thread Priority

• Each thread has a default priority (Thread.NORM_PRIORITY)
• You can change the priority using setPriority()
• Some constants for priority values (MIN_PRIORITY, MAX_PRIORITY, NORM_PRIORITY)

Thread Priority program

• An example demonstrating how priority works to show differences in thread output results. Thread output shows differences in order of thread execution when using thread priorities.

Shared Objects

• Problems arise when threads access and modify shared data simultaneously
• Inconsistent states can occur if multiple threads try to update the same shared data simultaneously

Synchronization & Locks

• To address shared object problems, synchronize access to shared data with the synchronized keyword.
• It implements a lock to control access.

Synchronization Example

• Modifying the example code above using synchronized blocks corrects the output problem by forcing serialization of access.

If one thread tries to read the data and other thread tries to update the same data

• Incorrect states may arise as a result of the threads working on the same data simultaneously.
• Synchronizing could prevent this.

Shared account object between 3 threads (Example)

• Three threads (MyThread, YourThread, HerThread) access a shared account object and perform operations

Monitor (shared object access)

• A mechanism to manage access to shared objects in Java
• It synchronizes operations to prevent concurrent problems

Synchronizing Statements vs. Methods

• Synchronizing blocks of code vs synchronized methods. Shows how statements in class can be converted for synchornization
• The methods are similar in effect, but the latter is cleaner.

isAlive(), interrupt(), and isInterrupted()

• Methods for managing thread's state and interrupting threads

Other Notes

• Includes example program outputs in detailed explanations.