java多线程知识点有哪些

# Java多线程知识点有哪些

## 一、多线程基础概念

### 1.1 进程与线程的区别
- **进程**：操作系统资源分配的基本单位，每个进程有独立的内存空间
- **线程**：CPU调度的基本单位，同一进程内的线程共享内存空间
- 关键区别：
  - 进程间通信需要IPC机制
  - 线程切换开销小于进程
  - 线程更轻量级

### 1.2 为什么需要多线程
- 提高CPU利用率（特别是多核处理器）
- 改善程序响应性（如GUI应用）
- 简化异步任务处理模型
- 现代服务器的基本要求（如Tomcat线程池）

## 二、线程创建与生命周期

### 2.1 创建线程的三种方式
```java
// 方式1：继承Thread类
class MyThread extends Thread {
    public void run() {
        // 线程执行逻辑
    }
}

// 方式2：实现Runnable接口
class MyRunnable implements Runnable {
    public void run() {
        // 线程执行逻辑
    }
}

// 方式3：使用Callable+FutureTask
Callable<Integer> callable = () -> {
    // 可返回结果的线程
    return 42;
};
FutureTask<Integer> futureTask = new FutureTask<>(callable);

2.2 线程状态转换

stateDiagram
    [*] --> NEW
    NEW --> RUNNABLE: start()
    RUNNABLE --> BLOCKED: 等待锁
    BLOCKED --> RUNNABLE: 获取锁
    RUNNABLE --> WTING: wait()/join()
    WTING --> RUNNABLE: notify()/notifyAll()
    RUNNABLE --> TIMED_WTING: sleep(n)/wait(n)
    TIMED_WTING --> RUNNABLE: 超时/唤醒
    RUNNABLE --> TERMINATED: run()结束

三、线程同步与锁机制

3.1 synchronized关键字

• 修饰实例方法：锁是当前实例对象
• 修饰静态方法：锁是当前类的Class对象
• 同步代码块：可指定锁对象

// 实例方法同步
public synchronized void method() {}

// 静态方法同步
public static synchronized void staticMethod() {}

// 同步代码块
public void block() {
    synchronized(lockObj) {
        // 临界区代码
    }
}

3.2 Lock接口及其实现类

Lock lock = new ReentrantLock();
lock.lock();
try {
    // 临界区代码
} finally {
    lock.unlock(); // 必须手动释放
}

• 相比synchronized的优势：
  • 可中断获取锁
  • 超时获取锁
  • 公平锁/非公平锁选择
  • 多个条件变量

3.3 volatile关键字

• 保证可见性：修改立即对其他线程可见
• 禁止指令重排序
• 不保证原子性（适合状态标志位场景）

四、线程间通信

4.1 wait/notify机制

synchronized(lock) {
    while(条件不满足) {
        lock.wait(); // 释放锁并等待
    }
    // 处理业务
    lock.notifyAll(); // 唤醒其他线程
}

4.2 Condition接口

Lock lock = new ReentrantLock();
Condition condition = lock.newCondition();

lock.lock();
try {
    condition.await(); // 类似wait()
    condition.signal(); // 类似notify()
} finally {
    lock.unlock();
}

五、并发工具类

5.1 CountDownLatch

CountDownLatch latch = new CountDownLatch(3);
// 工作线程
latch.countDown(); 
// 主线程
latch.await(); // 阻塞直到计数器归零

5.2 CyclicBarrier

CyclicBarrier barrier = new CyclicBarrier(3, ()->{
    // 所有线程到达后执行的回调
});

// 工作线程
barrier.await(); // 等待其他线程

5.3 Semaphore

Semaphore semaphore = new Semaphore(5); // 许可证数量
semaphore.acquire(); // 获取许可
try {
    // 受限资源访问
} finally {
    semaphore.release(); // 释放许可
}

六、线程池体系

6.1 Executor框架结构

Executor
├── ExecutorService
│   ├── AbstractExecutorService
│   │   └── ThreadPoolExecutor
│   └── ScheduledExecutorService
│       └── ScheduledThreadPoolExecutor
└── ForkJoinPool

6.2 核心参数解析

new ThreadPoolExecutor(
    corePoolSize,    // 核心线程数
    maximumPoolSize, // 最大线程数
    keepAliveTime,  // 空闲线程存活时间
    unit,           // 时间单位
    workQueue,      // 任务队列
    threadFactory,  // 线程工厂
    handler         // 拒绝策略
);

6.3 四种拒绝策略

• AbortPolicy（默认）：抛出RejectedExecutionException
• CallerRunsPolicy：由调用者线程执行
• DiscardPolicy：直接丢弃任务
• DiscardOldestPolicy：丢弃队列中最老的任务

七、并发集合类

7.1 ConcurrentHashMap

• JDK8+实现：数组+链表+红黑树+CAS+synchronized
• 并发控制：
  • 分段锁思想（JDK7）
  • 桶首节点锁（JDK8+）

7.2 CopyOnWriteArrayList

• 读操作无锁
• 写操作复制新数组
• 适合读多写少场景

7.3 BlockingQueue实现类

• ArrayBlockingQueue：数组实现的有界队列
• LinkedBlockingQueue：链表实现的可选有界队列
• PriorityBlockingQueue：支持优先级的无界队列
• SynchronousQueue：不存储元素的特殊队列

八、原子操作类

8.1 基本类型原子类

• AtomicInteger
• AtomicLong
• AtomicBoolean

8.2 数组原子类

• AtomicIntegerArray
• AtomicLongArray
• AtomicReferenceArray

8.3 CAS原理

// AtomicInteger的getAndIncrement实现
public final int getAndIncrement() {
    return unsafe.getAndAddInt(this, valueOffset, 1);
}
// Unsafe类中的CAS操作
public final native boolean compareAndSwapInt(
    Object obj, long offset, int expect, int update);

九、常见并发问题

9.1 死锁条件与预防

• 必要条件：
  1. 互斥条件
  2. 请求与保持
  3. 不可剥夺
  4. 循环等待
• 预防方案：
  • 锁排序
  • 超时机制
  • 死锁检测

9.2 线程安全设计原则

1. 优先使用不可变对象
2. 缩小同步范围
3. 使用线程安全类
4. 避免暴露内部状态
5. 考虑使用并发容器

十、Java内存模型（JMM）

10.1 happens-before规则

• 程序顺序规则
• 锁规则
• volatile变量规则
• 线程启动规则
• 传递性规则

10.2 内存屏障类型

• LoadLoad屏障
• StoreStore屏障
• LoadStore屏障
• StoreLoad屏障

最佳实践提示：多线程编程应遵循”先保证正确性，再考虑优化性能”的原则。JDK并发包中的工具类已经经过充分验证，优先使用这些高级工具而非自己造轮子。 “`

（注：实际字数约1800字，核心内容已涵盖主要知识点，可根据需要调整细节）