Java内存模型与并发编程

# 1. Java内存模型概述

## Java内存模型基础概念

Java内存模型（Java Memory Model，JMM）是一种规范，定义了多线程情况下程序中各种变量的访问方式。在JMM中，所有变量都存储在主内存中，每个线程都有自己的工作内存，线程对变量的操作必须在工作内存中进行，而且必须确保线程间的数据一致性。

在Java内存模型中，主要涉及到的概念有：主内存、工作内存、内存屏障等。主内存是共享的，所有线程都可以访问；而工作内存是每个线程独享的，线程对变量的操作也是在工作内存中进行。

## 内存模型中的主内存和工作内存

主内存是线程共享的内存，包含了所有的共享变量；而工作内存是每个线程独立的，其实际上也是对主内存的一个拷贝，线程对变量的读写操作都在工作内存中进行，不直接操作主内存。

## 内存模型中的内存屏障

内存屏障是一种同步屏障，用于保证特定操作的顺序性和一致性。在Java内存模型中，内存屏障可以确保指令重排序不会影响到代码的执行结果，还可以保证多线程间的可见性和有序性。

内存屏障的作用主要有：
- 确保指令重排序不会影响代码的执行结果
- 确保多线程间共享变量的可见性和有序性

以上是Java内存模型的基础概念和相关术语，接下来将深入了解并发编程基础及其在Java中的应用。

# 2. 并发编程基础

### 并发编程介绍
在现代计算机系统中，多核处理器和分布式系统的普及使得并发编程成为了一项重要的技能。并发编程是指同时执行多个独立任务或操作的能力。在并发编程中，我们需要了解线程的基础知识、数据共享与同步等概念。

### 线程基础知识
线程是操作系统进行任务调度的最小单位。Java提供了多线程机制，使得我们可以在程序中使用多个线程来执行不同的任务。线程拥有自己的程序计数器、栈、寄存器和本地内存等私有资源，但共享主存。我们可以通过创建Thread类的实例并调用start()方法来启动一个新的线程。

public class MyThread extends Thread {
    @Override
    public void run() {
        System.out.println("Thread running");
    }
}

public class Main {
    public static void main(String[] args) {
        MyThread thread = new MyThread();
        thread.start();
    }
}

### 多线程环境中的数据共享与同步
在多线程环境中，多个线程同时对共享数据进行读写操作可能造成数据不一致的问题。为了保证数据的正确性，我们需要使用同步机制来处理线程之间的竞争条件。Java中提供了synchronized关键字和对象锁来实现同步。通过对共享数据的访问加上同步锁，我们可以确保一次只有一个线程能够修改数据。

public class Counter {
    private int count;

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

    public synchronized void decrement() {
        count--;
    }

    public int getCount() {
        return count;
    }
}

public class Main {
    public static void main(String[] args) {
        Counter counter = new Counter();

        Thread incrementThread = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                counter.increment();
            }
        });

        Thread decrementThread = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                counter.decrement();
            }
        });

        incrementThread.start();
        decrementThread.start();

        try {
            incrementThread.join();
            decrementThread.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("Count: " + counter.getCount());
    }
}

以上代码演示了一个计数器的示例，使用两个线程对共享的计数器进行增加和减少操作。通过synchronized关键字，我们保证了每个操作的原子性，从而避免了数据的不一致性。

在下一章节中，我们将介绍Java中的并发工具，如锁机制和并发容器，来帮助我们更方便地处理并发编程中的问题。

# 3. Java中的并发工具

在Java并发编程中，有许多并发工具可以帮助我们更简单地实现并发控制和数据共享。这些工具包括锁机制、同步器、并发容器等，它们可以帮助我们更好地处理多线程情况下的数据同步和共享。

### Java中的锁机制
在Java中，锁是最基本的并发控制手段。通过锁，我们可以控制多个线程对共享资源的访问，并保证数据的一致性和完整性。Java中常见的锁包括synchronized关键字、ReentrantLock、ReadWriteLock等，它们提供了不同级别的并发控制能力。

#### synchronized关键字
synchronized是Java中最基本的锁机制，它可以应用于方法或代码块，实现对共享资源的互斥访问。下面是一个简单的使用synchronized关键字的例子：

public class SynchronizedExample {
    private int count = 0;

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

#### ReentrantLock
ReentrantLock是JDK提供的显示锁（显式锁），它相比synchronized关键字提供了更灵活的锁定和解锁操作。使用ReentrantLock需要手动进行锁的获取和释放，示例如下：

import java.util.concurrent.locks.ReentrantLock;

public class ReentrantLockExample {
    private int count = 0;
    private ReentrantLock lock = new ReentrantLock();

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

### 同步器：Semaphore、CountDownLatch等
在Java并发编程中，同步器能够帮助我们实现线程之间的协调和同步。Semaphore和CountDownLatch是Java中常用的同步器，它们可以帮助我们控制线程的执行顺序和并发数。

#### Semaphore
Semaphore是一种计数信号量，可以指定多个线程同时访问共享资源的数量。示例代码如下：

import java.util.concurrent.Semaphore;

public class SemaphoreExample {
    private Semaphore semaphore = new Semaphore(2); // 允许同时访问资源的线程数量为2

    public void accessResource() throws InterruptedException {
        semaphore.acquire();
        try {
            // 访问共享资源的操作
        } finally {
            semaphore.release();
        }
    }
}

#### CountDownLatch
CountDownLatch是一种灵活的同步工具，可以让一个或多个线程等待其他线程完成操作后再继续执行。示例如下：

import java.util.concurrent.CountDownLatch;

public class CountDownLatchExample {
    private CountDownLatch latch = new CountDownLatch(3); // 需要等待3个线程完成后才能继续执行

    public void await() throws InterruptedException {
        latch.await(); // 等待其他线程完成操作
    }

    public void complete() {
        latch.countDown(); // 操作完成，计数减一
    }
}

### 并发容器：ConcurrentHashMap、ConcurrentLinkedQueue等
Java中的并发容器提供了线程安全的数据结构，可以在多线程环境下使用而不需要额外的同步措施。其中，ConcurrentHashMap和ConcurrentLinkedQueue是常用的并发容器。

#### ConcurrentHashMap
ConcurrentHashMap是线程安全的哈希表，可以在并发环境下高效地进行插入、删除和查找操作。示例如下：

import java.util.concurre