深入理解Java内存模型及其在多线程编程中的应用-CSDN博客

深入理解Java内存模型及其在多线程编程中的应用

大家好，我是微赚淘客系统3.0的小编，是个冬天不穿秋裤，天冷也要风度的程序猿！今天我们来深入探讨Java内存模型（Java Memory Model, JMM）及其在多线程编程中的应用。

一、Java内存模型概述

Java内存模型（JMM）是Java虚拟机规范的一部分，定义了变量的访问方式及线程之间如何协同工作。JMM为多线程编程提供了抽象的内存视图，并定义了内存访问操作的可见性和有序性。

二、JMM中的关键概念

主内存与工作内存
在JMM中，每个线程都有自己的工作内存，工作内存保存了该线程使用到的变量的副本。所有变量存储在主内存中。线程不能直接操作主内存中的变量，必须通过工作内存来读写。
volatile关键字
volatile变量直接存储在主内存中，线程对volatile变量的读写操作都会直接映射到主内存。这样保证了volatile变量的可见性，但不保证原子性。

package cn.juwatech.memory;

public class VolatileExample {
    private volatile boolean flag = true;

    public void stop() {
        flag = false;
    }

    public void doWork() {
        while (flag) {
            // 执行任务
        }
    }
}

原子性、可见性与有序性

原子性：保证操作不可被中断。
可见性：一个线程对变量的修改对其他线程是可见的。
有序性：操作按照程序的顺序执行。

三、同步机制

synchronized关键字
synchronized保证了代码块的原子性和可见性。它通过锁机制来控制对共享资源的访问。

package cn.juwatech.sync;

public class SynchronizedExample {
    private int count = 0;

    public synchronized void increment() {
        count++;
    }

    public synchronized int getCount() {
        return count;
    }
}

Lock接口
Lock提供了更灵活的锁机制，相比于synchronized，Lock可以在不同范围内锁定，并且支持中断和超时等操作。

package cn.juwatech.lock;

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class LockExample {
    private int count = 0;
    private final Lock lock = new ReentrantLock();

    public void increment() {
        lock.lock();
        try {
            count++;
        } finally {
            lock.unlock();
        }
    }

    public int getCount() {
        return count;
    }
}

四、volatile的使用场景

volatile适用于一些简单的状态标志，但不适合于需要原子性的操作。适合的场景包括：

状态标志
双重检查锁定单例模式

package cn.juwatech.singleton;

public class Singleton {
    private static volatile Singleton instance;

    private Singleton() {}

    public static Singleton getInstance() {
        if (instance == null) {
            synchronized (Singleton.class) {
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

五、Java并发包中的高级工具

CountDownLatch
用于同步一个或多个任务，强制它们等待由其他任务执行的一组操作完成。

package cn.juwatech.concurrent;

import java.util.concurrent.CountDownLatch;

public class CountDownLatchExample {
    public static void main(String[] args) throws InterruptedException {
        CountDownLatch latch = new CountDownLatch(3);

        for (int i = 0; i < 3; i++) {
            new Thread(new Worker(latch)).start();
        }

        latch.await();
        System.out.println("所有任务完成");
    }

    static class Worker implements Runnable {
        private final CountDownLatch latch;

        Worker(CountDownLatch latch) {
            this.latch = latch;
        }

        @Override
        public void run() {
            try {
                // 执行任务
            } finally {
                latch.countDown();
            }
        }
    }
}

CyclicBarrier
用于使一组线程互相等待，直到到达某个公共屏障点。

package cn.juwatech.concurrent;

import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;

public class CyclicBarrierExample {
    public static void main(String[] args) {
        int parties = 3;
        CyclicBarrier barrier = new CyclicBarrier(parties, () -> System.out.println("所有任务就绪"));

        for (int i = 0; i < parties; i++) {
            new Thread(new Task(barrier)).start();
        }
    }

    static class Task implements Runnable {
        private final CyclicBarrier barrier;

        Task(CyclicBarrier barrier) {
            this.barrier = barrier;
        }

        @Override
        public void run() {
            try {
                // 执行任务
                barrier.await();
            } catch (InterruptedException | BrokenBarrierException e) {
                Thread.currentThread().interrupt();
            }
        }
    }
}

Semaphore
信号量用于控制同时访问的线程数。

package cn.juwatech.concurrent;

import java.util.concurrent.Semaphore;

public class SemaphoreExample {
    public static void main(String[] args) {
        Semaphore semaphore = new Semaphore(3);

        for (int i = 0; i < 10; i++) {
            new Thread(new Task(semaphore)).start();
        }
    }

    static class Task implements Runnable {
        private final Semaphore semaphore;

        Task(Semaphore semaphore) {
            this.semaphore = semaphore;
        }

        @Override
        public void run() {
            try {
                semaphore.acquire();
                // 执行任务
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            } finally {
                semaphore.release();
            }
        }
    }
}