Code-Alongs

Introduction to Threads Code-Along

This code-along will guide you through implementing thread concepts in Java, focusing on creating and managing threads, and understanding synchronization challenges.

Key Topics Covered

Creating and starting threads using both Thread subclasses and Runnable implementations
Managing thread lifecycle and states (NEW, RUNNABLE, BLOCKED, WAITING, TERMINATED)
Handling synchronization challenges and race conditions
Implementing thread safety with synchronized methods and blocks
Applying threading concepts to improve application performance

Implementation Examples

In this code-along, you'll implement multithreading to improve an application's performance by executing tasks concurrently. You'll learn about important threading concepts including:

// Example: Creating a thread by extending Thread
public class MyThread extends Thread {
    public void run() {
        // Thread execution code
        System.out.println("Thread is running: " + Thread.currentThread().getName());
    }
}

// Example: Creating a thread with Runnable interface
public class MyRunnable implements Runnable {
    public void run() {
        // Thread execution code
        System.out.println("Runnable is running in thread: " + Thread.currentThread().getName());
    }
}

// Usage in main method
public static void main(String[] args) {
    // Starting a Thread subclass
    MyThread thread1 = new MyThread();
    thread1.setName("Thread-Subclass");
    thread1.start();
    
    // Starting a Thread with Runnable
    Thread thread2 = new Thread(new MyRunnable(), "Thread-Runnable");
    thread2.start();
}

Resources

Lambda Expressions Code-Along

This code-along will guide you through implementing and using lambda expressions in Java, focusing on functional programming concepts and practical applications.

Key Topics Covered

Understanding and implementing functional interfaces
Writing lambda expressions in different forms (with and without type declarations)
Using built-in functional interfaces like Function, Consumer, Supplier, and Predicate
Applying method references for more concise code
Integrating lambda expressions with collections and the Stream API

Implementation Examples

During this code-along, you'll explore how lambda expressions can transform your code by making it more concise and expressive:

// Example: Using lambda with Comparator
List<String> names = Arrays.asList("Alice", "Bob", "Charlie", "David");

// Traditional anonymous class approach
Collections.sort(names, new Comparator<String>() {
    @Override
    public int compare(String s1, String s2) {
        return s1.length() - s2.length();
    }
});

// Lambda expression approach
Collections.sort(names, (s1, s2) -> s1.length() - s2.length());

// Even more concise with method reference and comparing utility
Collections.sort(names, Comparator.comparing(String::length));

// Example: Using lambda with functional interfaces
Function<String, Integer> stringLength = s -> s.length();
Predicate<String> isLongName = s -> s.length() > 5;
Consumer<String> printName = s -> System.out.println(s);
Supplier<LocalDateTime> getCurrentTime = () -> LocalDateTime.now();

Introduction to Threads Code-Along

Key Topics Covered

Implementation Examples

Resources

Lambda Expressions Code-Along

Key Topics Covered

Implementation Examples

Resources

Additional Resources