从线程创建到高并发架构设计的系统性实践指南
在java多线程编程的世界里,理解线程的本质是开启高并发开发的第一把钥匙。线程(Thread)是操作系统能够进行运算调度的最小单位,被包含在进程之中,是进程中的实际运作单位。Java语言通过java.lang.Thread类和java.lang.Runnable接口提供了对线程的原生支持。
创建线程主要有三种方式:
Thread类并重写run()方法Runnable接口并传递给Thread构造器Callable与Futures支持返回值与异常处理以下为典型示例:
// 方式一:继承Thread类
class MyThread extends Thread {
public void run() {
System.out.println("线程执行中:" + Thread.currentThread().getName());
}
}
new MyThread().start();
// 方式二:实现Runnable接口
class MyTask implements Runnable {
public void run() {
System.out.println("任务执行:" + Thread.currentThread().getName());
}
}
new Thread(new MyTask()).start();
// 方式三:使用Lambda(Java 8+)
new Thread(() -> {
System.out.println("Lambda线程:" + Thread.currentThread().getName());
}).start();
值得注意的是,直接调用run()方法不会启动新线程,仅作为普通方法调用;必须通过start()方法触发JVM创建新线程并执行run()逻辑。
线程的生命周期包括:
Object.wait()、LockSupport.park())Thread.sleep()、Object.wait(timeout))线程优先级范围为1(MIN_PRIORITY)~10(MAX_PRIORITY),默认为5(NORM_PRIORITY)。但需注意:优先级仅作为调度提示,不保证执行顺序,且不同操作系统对优先级映射不一致,过度依赖可能导致调度不公平。
线程安全问题源于多个线程并发访问共享可变状态,典型场景包括:计数器累加、缓存更新、集合修改等。若缺乏同步机制,将出现AABA问题、丢失更新、可见性缺失等风险。
线程安全的核心在于控制对共享资源的并发访问。Java提供了多层次的同步机制,从语言级到类库级,覆盖不同场景需求。
synchronized是Java内置的轻量级同步原语,可修饰方法或代码块。其本质是通过对象监视器(Monitor)实现互斥访问:
// 修饰实例方法:锁当前实例对象
public synchronized void updateCounter() { ... }
// 修饰静态方法:锁Class对象
public static synchronized void resetAll() { ... }
// 修饰代码块:显式指定锁对象
private final Object lock = new Object();
synchronized(lock) {
// 临界区
}
需警惕锁粗化(Lock Coarsening)与锁消除(Lock Elision)优化:JIT编译器可能自动合并连续加锁/解锁操作,或在逃逸分析确认对象仅单线程访问时移除锁。
volatile确保变量的可见性与禁止指令重排序,适用于状态标记、双检锁单例等场景。但volatile不保证原子性,因此count++等复合操作仍需额外同步:
private volatile boolean initialized = false;
public void init() {
if (!initialized) {
synchronized(this) {
if (!initialized) {
setup(); // 禁止重排序:setup()在initialized=true前执行
initialized = true;
}
}
}
}
ReentrantLock提供比synchronized更灵活的控制:
lockInterruptibly())tryLock(timeout, unit))true)避免线程饥饿newCondition())替代wait/notifyprivate final ReentrantLock lock = new ReentrantLock();
private final Condition notFull = lock.newCondition();
private final Condition notEmpty = lock.newCondition();
public void put(E e) throws InterruptedException {
lock.lock();
try {
while (queue.size() == capacity)
notFull.await();
queue.add(e);
notEmpty.signal();
} finally {
lock.unlock();
}
}
ReadWriteLock允许多个读线程并发访问,但写线程独占,适用于读多写少场景(如缓存、配置中心):
private final ReadWriteLock rwLock = new ReentrantReadWriteLock();
private final Lock r = rwLock.readLock();
private final Lock w = rwLock.writeLock();
public String readConfig() {
r.lock();
try { return config; }
finally { r.unlock(); }
}
public void updateConfig(String newConfig) {
w.lock();
try { config = newConfig; }
finally { w.unlock(); }
}
频繁创建/销毁线程带来显著开销。线程池通过复用线程、控制并发数、管理任务队列,实现资源高效利用。
| 参数 | 说明 | 典型值 |
|---|---|---|
corePoolSize | 核心线程数(常驻线程) | CPU核数+1 |
maximumPoolSize | 最大线程数 | 根据任务类型调整 |
keepAliveTime | 非核心线程存活时间 | 60秒 |
unit | 时间单位 | TimeUnit.SECONDS |
workQueue | 任务队列 | LinkedBlockingQueue等 |
threadFactory | 线程工厂(可命名线程) | new NamedThreadFactory() |
handler | 拒绝策略 | AbortPolicy等 |
常见拒绝策略:
AbortPolicy:抛出RejectedExecutionExceptionCallerRunsPolicy:由调用线程执行任务(限流回压)DiscardPolicy:静默丢弃DiscardOldestPolicy:丢弃队列头任务《阿里巴巴Java开发手册》建议:
线程池不允许使用Executors创建,应通过ThreadPoolExecutor显式指定参数,避免资源耗尽风险。
典型安全创建方式:
int core = Runtime.getRuntime().availableProcessors();
BlockingQueue queue = new LinkedBlockingQueue<>(1024);
ThreadFactory factory = new ThreadFactoryBuilder()
.setNameFormat("biz-worker-%d")
.setDaemon(true)
.build();
ThreadPoolExecutor executor = new ThreadPoolExecutor(
core, core * 2, 60L, TimeUnit.SECONDS,
queue, factory, new ThreadPoolExecutor.CallerRunsPolicy()
);
不同任务类型建议配置:
允许一个或多个线程等待其他线程完成操作。典型场景:主线程等待所有子任务初始化完成。
CountDownLatch latch = new CountDownLatch(3);
ExecutorService pool = Executors.newFixedThreadPool(3);
for (int i = 0; i < 3; i++) {
pool.execute(() -> {
try {
Thread.sleep(500);
System.out.println("子任务完成");
} catch (InterruptedException e) { }
finally { latch.countDown(); }
});
}
latch.await(); // 阻塞直到countDown为0
System.out.println("所有任务完成");
一组线程互相等待到达屏障点后一起继续执行。支持重用与屏障动作。
CyclicBarrier barrier = new CyclicBarrier(3, () -> {
System.out.println("所有线程就位,准备下一阶段");
});
ExecutorService pool = Executors.newFixedThreadPool(3);
for (int i = 0; i < 3; i++) {
pool.execute(() -> {
try {
Thread.sleep((long)(Math.random()*1000));
barrier.await(); // 等待其余线程
System.out.println(Thread.currentThread().getName() + "通过栅栏");
} catch (Exception e) { e.printStackTrace(); }
});
}
控制同时访问特定资源的线程数量,适用于限流(如数据库连接池)。
Semaphore semaphore = new Semaphore(5); // 5个许可
ExecutorService pool = Executors.newCachedThreadPool();
for (int i = 0; i < 10; i++) {
pool.execute(() -> {
try {
semaphore.acquire();
System.out.println("获取资源,当前可用:" + semaphore.availablePermits());
Thread.sleep(2000);
} catch (InterruptedException e) { }
finally { semaphore.release(); }
});
}
Java 8中采用Node数组+链表/红黑树结构,通过CAS+synchronized保证线程安全:
性能远超Hashtable与Collections.synchronizedMap,推荐作为高并发场景首选。
支持函数式编程风格的异步编排,弥补Future阻塞等待缺陷:
CompletableFuture future = CompletableFuture
.supplyAsync(() -> {
return "Hello";
})
.thenApplyAsync(s -> s + " World")
.thenComposeAsync(s -> CompletableFuture
.supplyAsync(() -> s + "!")
);
String result = future.join(); // 非阻塞获取结果
System.out.println(result); // Hello World!
常用方法:
thenApply:同步转换thenApplyAsync:异步转换(新线程)thenCompose:扁平化嵌套FuturethenCombine:合并两个Future结果allOf/anyOf:组合多个FutureJava内存模型(JMM)定义了线程如何与主内存交互,解决可见性、原子性、有序性三大问题。
read、load、use、assign、store、write为原子操作synchronized释放锁→获取锁;volatile写→读典型重排序场景:
防止重排序手段:
volatile:插入内存屏障,禁止指令重排synchronized:获取锁时刷新工作内存,释放锁时刷新主内存final字段:构造器中初始化后不可见部分初始化双检锁单例的正确写法:
public class Singleton {
private static volatile Singleton instance;
public static Singleton getInstance() {
if (instance == null) {
synchronized (Singleton.class) {
if (instance == null) {
instance = new Singleton(); // 1.分配内存 2.初始化 3.赋值引用
}
}
}
return instance;
}
}
若无volatile,可能发生指令重排:1→3→2,导致其他线程获取未初始化对象。
jstack:线程堆栈分析(死锁、阻塞点)jstat:GC与内存统计jmap:堆内存快照VisualVM:图形化监控(CPU/内存/线程)Arthas:在线诊断(方法调用追踪、性能热点)LongAdder替代AtomicLong(分段累加)某电商订单处理系统,单机TPS从2000提升至8000:
HashMap替换为ConcurrentHashMapsynchronized使用core=CPU×1.5,队列容量=1000,拒绝策略= CallerRunsPolicyCompletableFuture异步落库+批量提交使用Disruptor(高性能无锁队列)替代传统日志框架同步写盘:
RingBuffer ringBuffer = RingBuffer.createSingleProducer(
Event::new, 1024 * 1024
);
Disruptor disruptor = new Disruptor<>(Event::new, 1024, DaemonThreadFactory.INSTANCE);
disruptor.handleEventsWith((event, sequence, endOfBatch) -> {
logger.info("写入日志:{}", event.getMessage());
});
disruptor.start();
// 生产者发布事件
ringBuffer.publishEvent((event, sequence) -> event.setMessage("用户登录"));
实测日志写入延迟从15ms降至0.8ms,吞吐量提升10倍。
基于时间戳+机器ID+序列号,使用AtomicLong保证线程安全:
public class IdGenerator {
private static final long TWEPOCH = 1288834974657L;
private static final long WORKER_ID_BITS = 5L;
private static final long DATA_CENTER_ID_BITS = 5L;
private static final long SEQUENCE_BITS = 12L;
private final long workerId;
private final long dataCenterId;
private long sequence = 0L;
private long lastTimestamp = -1L;
public synchronized long nextId() {
long timestamp = timeGen();
if (timestamp < lastTimestamp)
throw new RuntimeException("时钟回拨");
if (timestamp == lastTimestamp) {
sequence = (sequence + 1) & ((1 << SEQUENCE_BITS) - 1);
if (sequence == 0) timestamp = tilNextMillis(lastTimestamp);
} else sequence = 0L;
lastTimestamp = timestamp;
return ((timestamp - TWEPOCH) << (WORKER_ID_BITS + DATA_CENTER_ID_BITS + SEQUENCE_BITS))
| (dataCenterId << (WORKER_ID_BITS + SEQUENCE_BITS))
| (workerId << SEQUENCE_BITS)
| sequence;
}
}
A:局部变量存储在线程栈中,每个线程拥有独立的栈空间,不存在共享,故天然线程安全。但若局部变量引用了共享对象(如传入的参数),仍需同步。
A:ArrayList非线程安全。替代方案:
ArrayList(性能最优)Collections.synchronizedList(new ArrayList<>())CopyOnWriteArrayList(写时复制)ConcurrentSkipListMap或自定义分段锁A:步骤如下:
jps -l获取Java进程IDjstack [pid]查看线程堆栈Found one Java-level deadlock预防策略:
tryLock+超时重试ConcurrentHashMap)A:Java 6起synchronized大幅优化(偏向锁、轻量级锁),在无竞争场景性能优于ReentrantLock。但ReentrantLock在高竞争、长持锁时间下更优,且提供更丰富功能。
实测数据(1000万次加锁/解锁):
| 方案 | 耗时(ms) | 吞吐量(万次/秒) |
|---|---|---|
| synchronized | 280 | 35.7 |
| ReentrantLock(公平) | 450 | 22.2 |
| ReentrantLock(非公平) | 310 | 32.3 |
建议:简单场景用synchronized;需中断、超时、公平性控制时用ReentrantLock。