### Java多线程编程的核心原理与实践技巧

#### 一、线程基础与创建方式

1. 继承Thread类

```java

class MyThread extends Thread {

@Override

public void run() {

System.out.println(线程执行);

}

}

// 启动线程

new MyThread().start();

```

2. 实现Runnable接口

```java

class MyRunnable implements Runnable {

@Override

public void run() {

System.out.println(线程执行);

}

}

// 启动线程

new Thread(new MyRunnable()).start();

```

3. 实现Callable接口

```java

class MyCallable implements Callable {

@Override

public String call() throws Exception {

return 执行结果;

}

}

// 使用线程池执行

ExecutorService executor = Executors.newSingleThreadExecutor();

Future future = executor.submit(new MyCallable());

```

#### 二、线程生命周期与状态转换

- NEW：新建状态，线程被创建但未启动

- RUNNABLE：可运行状态，包括就绪和运行中

- BLOCKED：阻塞状态，等待监视器锁

- WAITING：等待状态，无限期等待其他线程操作

- TIMED_WAITING：超时等待状态，在指定时间内等待

- TERMINATED：终止状态，线程执行完毕

#### 三、线程同步与锁机制

1. synchronized关键字

```java

// 同步方法

public synchronized void syncMethod() {

// 临界区代码

}

// 同步代码块

public void method() {

synchronized(this) {

// 临界区代码

}

}

```

2. ReentrantLock可重入锁

```java

private final ReentrantLock lock = new ReentrantLock();

public void method() {

lock.lock();

try {

// 临界区代码

} finally {

lock.unlock();

}

}

```

3. ReadWriteLock读写锁

```java

private final ReadWriteLock rwLock = new ReentrantReadWriteLock();

public void read() {

rwLock.readLock().lock();

try {

// 读操作

} finally {

rwLock.readLock().unlock();

}

}

```

#### 四、线程间通信

1. wait/notify机制

```java

class SharedResource {

private boolean available = false;

public synchronized void produce() throws InterruptedException {

while(available) wait();

// 生产资源

available = true;

notifyAll();

}

public synchronized void consume() throws InterruptedException {

while(!available) wait();

// 消费资源

available = false;

notifyAll();

}

}

```

2. Condition条件变量

```java

class BoundedBuffer {

private final Lock lock = new ReentrantLock();

private final Condition notFull = lock.newCondition();

private final Condition notEmpty = lock.newCondition();

public void put(Object x) throws InterruptedException {

lock.lock();

try {

while(/ 缓冲区满 /) notFull.await();

// 放入数据

notEmpty.signal();

} finally {

lock.unlock();

}

}

}

```

#### 五、线程池原理与实践

1. ThreadPoolExecutor核心参数

```java

ThreadPoolExecutor executor = new ThreadPoolExecutor(

corePoolSize, // 核心线程数

maximumPoolSize, // 最大线程数

keepAliveTime, // 空闲线程存活时间

TimeUnit.SECONDS, // 时间单位

new LinkedBlockingQueue<>(), // 工作队列

new ThreadFactory() { // 线程工厂

@Override

public Thread newThread(Runnable r) {

return new Thread(r, custom-thread);

}

},

new ThreadPoolExecutor.AbortPolicy() // 拒绝策略

);

```

2. Executors工具类

```java

// 固定大小线程池

ExecutorService fixedPool = Executors.newFixedThreadPool(10);

// 缓存线程池

ExecutorService cachedPool = Executors.newCachedThreadPool();

// 单线程池

ExecutorService singlePool = Executors.newSingleThreadExecutor();

// 调度线程池

ScheduledExecutorService scheduledPool = Executors.newScheduledThreadPool(5);

```

#### 六、原子操作与CAS

1. Atomic类使用

```java

private AtomicInteger counter = new AtomicInteger(0);

public void increment() {

counter.incrementAndGet();

}

private AtomicReference reference = new AtomicReference<>(初始值);

```

2. CAS原理实现

```java

public class CASExample {

private volatile int value;

public synchronized boolean compareAndSet(int expect, int update) {

if (value == expect) {

value = update;

return true;

}

return false;

}

}

```

#### 七、并发集合类

1. ConcurrentHashMap

```java

ConcurrentHashMap map = new ConcurrentHashMap<>();

map.put(key, 1);

map.computeIfAbsent(key, k -> 1);

```

2. CopyOnWriteArrayList

```java

CopyOnWriteArrayList list = new CopyOnWriteArrayList<>();

list.add(元素);

```

3. BlockingQueue

```java

BlockingQueue queue = new LinkedBlockingQueue<>();

// 生产者

queue.put(消息);

// 消费者

String message = queue.take();

```

#### 八、volatile关键字与内存可见性

```java

class VolatileExample {

private volatile boolean flag = false;

public void writer() {

flag = true; // 写操作，保证可见性

}

public void reader() {

if (flag) { // 读操作，总能读到最新值

// 执行逻辑

}

}

}

```

#### 九、ThreadLocal原理与应用

```java

public class ThreadLocalExample {

private static ThreadLocal threadLocal = ThreadLocal.withInitial(() -> 0);

public void method() {

Integer value = threadLocal.get();

threadLocal.set(value + 1);

}

}

```

#### 十、最佳实践与性能优化

1. 避免死锁策略

- 按固定顺序获取锁

- 使用tryLock()带超时机制

- 避免嵌套锁

2. 性能优化建议

- 合理设置线程池参数

- 使用合适的并发集合

- 减少锁粒度

- 使用读写锁替代独占锁

3. 异常处理

```java

ExecutorService executor = Executors.newFixedThreadPool(1);

Future future = executor.submit(() -> {

try {

// 任务逻辑

} catch (Exception e) {

// 异常处理

}

});

```

通过深入理解Java多线程的核心原理，结合合理的实践技巧，可以构建出高效、稳定的并发应用程序。在实际开发中，需要根据具体场景选择合适的并发工具和策略，平衡性能与复杂度之间的关系。