9.501
Multi-Threading and Thread Synchronization in Java

2024-02-14 · within a single process

class MyThread extends Thread {
    public void run() {
        // Thread's code here
    }
}

// Creating and starting a thread
MyThread myThread = new MyThread();
myThread.start();
class MyRunnable implements Runnable {
    public void run() {
        // Thread's code here
    }
}

// Creating and starting a thread using Runnable
MyRunnable myRunnable = new MyRunnable();
Thread thread = new Thread(myRunnable);
thread.start();
Thread daemonThread = new Thread(() -> {
    // Thread's code here
});
daemonThread.setDaemon(true);
daemonThread.start();
public synchronized void synchronizedMethod() {
    // Synchronized code here
}
synchronized (lockObject) {
    // Synchronized code here
}
private volatile boolean flag = false;
ExecutorService executor = Executors.newFixedThreadPool(4); // Creates a pool with 4 threads
ConcurrentMap<String, Integer> concurrentMap = new ConcurrentHashMap<>();
concurrentMap.put("key", 42);
int value = concurrentMap.get("key");
ExecutorService executor = Executors.newSingleThreadExecutor();
Future<Integer> future = executor.submit(() -> {
    // Compute a result
    return 42;
});

// Retrieve the result when it's available
int result = future.get();
ReentrantLock lock = new ReentrantLock();
lock.lock(); // Acquire the lock
try {
    // Synchronized code here
} finally {
    lock.unlock(); // Release the lock in a finally block
}
ReadWriteLock rwLock = new ReentrantReadWriteLock();
rwLock.readLock().lock(); // Acquire the read lock
try {
    // Read data
} finally {
    rwLock.readLock().unlock(); // Release the read lock
}
ReentrantLock lock = new ReentrantLock();
Condition condition = lock.newCondition();

// Thread 1
lock.lock();
try {
    while (!conditionMet) {
        condition.await(); // Wait until the condition is met
    }
    // Continue execution
} finally {
    lock.unlock();
}

// Thread 2
lock.lock();
try {
    // Change some state
    conditionMet = true;
    condition.signal(); // Signal waiting threads that the condition is met
} finally {
    lock.unlock();
}
// Producer-Consumer example using wait and notify
class SharedResource {
    private int data;
    private boolean newDataAvailable = false;

    public synchronized void produce(int value) {
        while (newDataAvailable) {
            try {
                wait(); // Wait until the data is consumed
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }
        data = value;
        newDataAvailable = true;
        notify(); // Signal that new data is available
    }

    public synchronized int consume() {
        while (!newDataAvailable) {
            try {
                wait(); // Wait until new data is produced
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }
        newDataAvailable = false;
        notify(); // Signal that the data has been consumed
        return data;
    }
}
BlockingQueue<Integer> queue = new LinkedBlockingQueue<>(10);

// Producer
queue.put(42);

// Consumer
int value = queue.take();
boolean success = queue.offer(42, 1, TimeUnit.SECONDS);
import java.io.*;
import java.net.*;
import java.util.concurrent.*;

public class MultiThreadedWebServer {
    private static final int PORT = 8080;
    private static final int THREAD_POOL_SIZE = 10;

    public static void main(String[] args) throws IOException {
        ServerSocket serverSocket = new ServerSocket(PORT);
        ExecutorService executorService = Executors.newFixedThreadPool(THREAD_POOL_SIZE);

        System.out.println("MultiThreaded Web Server started on port " + PORT);

        while (true) {
            Socket clientSocket = serverSocket.accept(); // Accept incoming client connections
            Runnable requestHandler = new RequestHandler(clientSocket);
            executorService.submit(requestHandler); // Delegate request handling to a thread
        }
    }
}

class RequestHandler implements Runnable {
    private Socket clientSocket;

    public RequestHandler(Socket clientSocket) {
        this.clientSocket = clientSocket;
    }

    @Override
    public void run() {
        try {
            handleRequest(clientSocket);
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                clientSocket.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    private void handleRequest(Socket clientSocket) throws IOException {
        // Read and process the HTTP request from the client
        BufferedReader in = new BufferedReader(new InputStreamReader(clientSocket.getInputStream()));
        PrintWriter out = new PrintWriter(clientSocket.getOutputStream(), true);

        String request;
        while ((request = in.readLine()) != null) {
            if (request.isEmpty()) {
                break; // End of request headers
            }
        }

        // Generate an HTTP response
        String response = "HTTP/1.1 200 OK\r\n" +
                          "Content-Type: text/html\r\n" +
                          "\r\n" +
                          "<html><body>Hello, World!</body></html>";

        // Send the response to the client
        out.println(response);

        // Close the streams and the socket
        in.close();
        out.close();
    }
}
public class SharedVariableExample {
    private static int sharedVariable = 0;

    public static void main(String[] args) {
        Thread thread1 = new Thread(() -> {
            sharedVariable = 42;
        });

        Thread thread2 = new Thread(() -> {
            int localValue = sharedVariable;
            System.out.println("Thread 2: Shared Variable = " + localValue);
        });

        thread1.start();
        thread2.start();
    }
}
public class HappensBeforeExample {
    private static int sharedVariable = 0;
    private static boolean flag = false;

    public static void main(String[] args) {
        Thread thread1 = new Thread(() -> {
            sharedVariable = 42;
            flag = true;
        });

        Thread thread2 = new Thread(() -> {
            if (flag) {
                System.out.println("Thread 2: Shared Variable = " + sharedVariable);
            }
        });

        thread1.start();
        thread2.start();
    }
}
public class SynchronizedMethodExample {
    private static int sharedVariable = 0;

    public synchronized static void increment() {
        sharedVariable++;
    }

    public static void main(String[] args) {
        Thread thread1 = new Thread(() -> {
            for (int i = 0; i < 1000000; i++) {
                increment();
            }
        });

        Thread thread2 = new Thread(() -> {
            for (int i = 0; i < 1000000; i++) {
                increment();
            }
        });

        thread1.start();
        thread2.start();

        try {
            thread1.join();
            thread2.join();
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }

        System.out.println("Shared Variable: " + sharedVariable);
    }
}
public class VolatileVariableExample {
    private static volatile boolean flag = false;

    public static void main(String[] args) {
        Thread thread1 = new Thread(() -> {
            flag = true;
        });

        Thread thread2 = new Thread(() -> {
            while (!flag) {
                // Spin-wait until flag becomes true
            }
            System.out.println("Thread 2: Flag is true.");
        });

        thread1.start();
        thread2.start();
    }
}
Thread myThread = new Thread(() -> {
    // Runnable code goes here
    System.out.println("Thread is running.");
});

myThread.start(); // Starts the thread
class MyThread extends Thread {
    @Override
    public void run() {
        // Custom thread code
        System.out.println("MyThread is running.");
    }
}

MyThread myThread = new MyThread();
myThread.start();
class MyRunnable implements Runnable {
    @Override
    public void run() {
        // Custom runnable code
        System.out.println("MyRunnable is running.");
    }
}

Thread myThread = new Thread(new MyRunnable());
myThread.start();

9.501Multi-Threading and Thread Synchronization in Java

Martin Schedlbauer

2024-02-14

Overview

Multi-Threading and Multi-Processing

Multi-Threading

Multi-Processing

Hybrid Architecture

Introduction to Multi-Threading in Java

Objectives

Understanding the Basics of Threads

Java’s Multi-Threading Support

Creating and Managing Threads

Objectives

Creating Threads in Java

Running Threads

Thread States and Lifecycle

Daemon Threads

Synchronization in Java

Objectives

Need for Synchronization

Synchronized Methods and Blocks

Intrinsic Locks (Monitor Locks)

The volatile Keyword

Thread Safety and Race Conditions

Objectives

Understanding Thread Safety

Identifying and Handling Race Conditions

Best Practices for Thread Safety

Using Java’s Concurrency Utilities

Objectives

java.util.concurrent Package Overview

Executors and Thread Pools

Concurrent Collections

Callable and Future

Advanced Synchronization Techniques

Objectives

Lock Objects and Lock Interfaces

Condition Variables

Thread Safety Patterns

Best Practices for Advanced Synchronization

Chapter 7: Thread Communication

Objectives

Thread Communication

Blocking Queues

Best Practices for Thread Communication and Blocking Queues

Multi-Threading in Real-World Applications

Thread Pools

Key Components of a Thread Pool:

Advantages of Using Thread Pools:

Common Thread Pool Types:

Thread Pool Best Practices:

Example: Simple Multi-Threaded Web Server

Conclusion

Files & Resources

References & Resources

Books:

Websites:

Online Communities:

Tools and Libraries:

Appendix A: Java’s Memory Model

Objectives

1. Shared Memory and Threads

Example 1: Shared Variable

2. Happens-Before Relationship

Example 2: Happens-Before

3. Synchronization

Example 3: Synchronized Method

4. Volatile Variables

Example 4: Volatile Variable

Appendix B: Java Thread API Reference

At-a-Glance

java.lang.Thread Class

Constructors

Methods

java.lang.Runnable Interface

Methods

Examples

Creating and Starting a Thread

Overriding the run() Method

9.501
Multi-Threading and Thread Synchronization in Java

The `volatile` Keyword

`java.util.concurrent` Package Overview

`java.lang.Thread` Class

`java.lang.Runnable` Interface

Overriding the `run()` Method