Java Concurrency Programming: Concepts, Tools, and Practical Examples

Introduction: This session aims to share Java concurrency programming tools, their usage, underlying principles, common problems, and how to select appropriate tools for efficient design.

Team: Xueersi Peiyou Operations R&D team; presenters listed.

Section 01 – Introduction to Concurrency: Defines concurrency vs parallelism using a JVM garbage‑collection example.

Section 02 – Why Learn Concurrency: Discusses industry demand, career advancement, interview relevance, and provides a double‑checked‑locking singleton example.

private static volatile Singleton singleton;
private Singleton(){};
public static Singleton getSingleton(){
    if(singleton == null){
        synchronized(Singleton.class){
            if(singleton == null){
                singleton = new Singleton();
            }
        }
    }
    return singleton;
}

Explains volatile, synchronized, JMM, MESI, and instruction reordering.

Shows a thread‑interaction interview question (alternating print) and mentions possible implementations with AtomicInteger, ReentrantLock, CountDownLatch, and LockSupport.

Introduces the Disruptor framework, its core concepts, ring buffer, SequenceBarrier, Sequencer, and common wait strategies (Blocking, Sleeping, Yielding, BusySpin).

Highlights three main concurrency properties—atomicity, visibility, ordering—with code examples demonstrating each.

for(int i=0;i<20;i++){
    Thread thread = new Thread(() -> {
        for(int j=0;j<10000;j++){
            res++;
            normal++;
            atomicInteger.incrementAndGet();
        }
    });
    thread.start();
}

Shows a visibility issue with a thread reading a shared variable and explains the Java Memory Model.

Provides a producer‑consumer example using synchronized, wait/notify, and suggests improvements with BlockingQueue.

class CarProducter implements Runnable{
    CarStock carStock;
    public CarProducter(CarStock carStock){ this.carStock = carStock; }
    @Override
    public void run(){
        while(true){ carStock.produceCar(); }
    }
    public synchronized void produceCar(){
        // production logic with wait/notifyAll
    }
}

class CarConsumer implements Runnable{
    CarStock carStock;
    public CarConsumer(CarStock carStock){ this.carStock = carStock; }
    @Override
    public void run(){
        while(true){ carStock.consumeCar(); }
    }
    public synchronized void consumeCar(){
        // consumption logic with wait/notifyAll
    }
}

Concludes with a thought exercise: design a race where the first three threads stop after reaching the finish line.

Next chapter preview: volatile and synchronized keywords.