Java多线程编程：使用场景与实现详解
一、什么是多线程
多线程是指在一个程序中同时运行多个线程，每个线程可以独立执行不同的任务。Java从语言层面提供了强大的多线程支持，使得并发编程变得相对简单。
二、常见使用场景
1.提高程序响应速度
// 场景：GUI应用中避免界面卡顿publicclassUIExample{publicvoidloadData(){newThread(()->{// 耗时操作在后台线程执行List<Data>data=fetchDataFromDatabase();// 更新UISwingUtilities.invokeLater(()->updateUI(data));}).start();}}2.充分利用CPU资源
// 场景：大数据处理、图像处理publicclassDataProcessor{publicvoidprocessLargeDataset(List<Data>dataset){intcores=Runtime.getRuntime().availableProcessors();ExecutorServiceexecutor=Executors.newFixedThreadPool(cores);for(Datadata:dataset){executor.submit(()->processData(data));}executor.shutdown();}}3.异步任务处理
// 场景：发送邮件、消息通知publicclassNotificationService{privateExecutorServiceexecutor=Executors.newCachedThreadPool();publicvoidsendNotification(Useruser,Stringmessage){executor.submit(()->{emailService.send(user.getEmail(),message);smsService.send(user.getPhone(),message);});}}4.并发请求处理
// 场景：Web服务器、API网关publicclassWebServer{publicvoidhandleRequest(Requestrequest){// 每个请求在独立线程中处理threadPool.execute(()->{Responseresponse=processRequest(request);sendResponse(response);});}}5.定时任务
// 场景：数据同步、缓存刷新publicclassScheduledTaskExample{privateScheduledExecutorServicescheduler=Executors.newScheduledThreadPool(1);publicvoidstartScheduledTask(){// 每5秒执行一次scheduler.scheduleAtFixedRate(()->refreshCache(),0,5,TimeUnit.SECONDS);}}三、Java多线程实现方式
方式1：继承Thread类
publicclassMyThreadextendsThread{@Overridepublicvoidrun(){System.out.println("线程执行: "+Thread.currentThread().getName());}publicstaticvoidmain(String[]args){MyThreadthread=newMyThread();thread.start();}}优点：实现简单
缺点：Java单继承限制，无法继承其他类
方式2：实现Runnable接口
publicclassMyRunnableimplementsRunnable{@Overridepublicvoidrun(){System.out.println("线程执行: "+Thread.currentThread().getName());}publicstaticvoidmain(String[]args){Threadthread=newThread(newMyRunnable());thread.start();// Lambda表达式简化newThread(()->{System.out.println("Lambda方式");}).start();}}优点：避免单继承限制，代码解耦
缺点：无法直接获取返回值
方式3：实现Callable接口
publicclassMyCallableimplementsCallable<Integer>{@OverridepublicIntegercall()throwsException{intsum=0;for(inti=1;i<=100;i++){sum+=i;}returnsum;}publicstaticvoidmain(String[]args)throwsException{FutureTask<Integer>task=newFutureTask<>(newMyCallable());newThread(task).start();// 获取返回值（会阻塞）Integerresult=task.get();System.out.println("计算结果: "+result);}}优点：可以获取返回值，可以抛出异常
缺点：代码相对复杂
方式4：线程池（推荐）
publicclassThreadPoolExample{publicstaticvoidmain(String[]args){// 1. 固定大小线程池ExecutorServicefixedPool=Executors.newFixedThreadPool(5);// 2. 缓存线程池ExecutorServicecachedPool=Executors.newCachedThreadPool();// 3. 单线程池ExecutorServicesinglePool=Executors.newSingleThreadExecutor();// 4. 定时线程池ScheduledExecutorServicescheduledPool=Executors.newScheduledThreadPool(3);// 5. 自定义线程池（推荐）ThreadPoolExecutorcustomPool=newThreadPoolExecutor(5,// 核心线程数10,// 最大线程数60L,// 空闲线程存活时间TimeUnit.SECONDS,// 时间单位newLinkedBlockingQueue<>(100),// 任务队列newThreadPoolExecutor.CallerRunsPolicy()// 拒绝策略);// 提交任务for(inti=0;i<10;i++){inttaskId=i;customPool.submit(()->{System.out.println("执行任务 "+taskId);});}// 关闭线程池customPool.shutdown();}}四、线程同步与安全
1. synchronized关键字
publicclassSynchronizedExample{privateintcount=0;// 同步方法publicsynchronizedvoidincrement(){count++;}// 同步代码块publicvoiddecrement(){synchronized(this){count--;}}}2. Lock接口
publicclassLockExample{privatefinalReentrantLocklock=newReentrantLock();privateintcount=0;publicvoidincrement(){lock.lock();try{count++;}finally{lock.unlock();}}}3. 原子类
publicclassAtomicExample{privateAtomicIntegercount=newAtomicInteger(0);publicvoidincrement(){count.incrementAndGet();}publicintgetCount(){returncount.get();}}4. volatile关键字
publicclassVolatileExample{privatevolatilebooleanrunning=true;publicvoidstop(){running=false;}publicvoidrun(){while(running){// 执行任务}}}五、实战案例：生产者-消费者模式
publicclassProducerConsumerExample{privatestaticfinalintCAPACITY=10;privateBlockingQueue<Integer>queue=newLinkedBlockingQueue<>(CAPACITY);// 生产者classProducerimplementsRunnable{@Overridepublicvoidrun(){try{for(inti=0;i<20;i++){queue.put(i);System.out.println("生产: "+i);Thread.sleep(100);}}catch(InterruptedExceptione){Thread.currentThread().interrupt();}}}// 消费者classConsumerimplementsRunnable{@Overridepublicvoidrun(){try{while(true){Integeritem=queue.take();System.out.println("消费: "+item);Thread.sleep(200);}}catch(InterruptedExceptione){Thread.currentThread().interrupt();}}}publicstaticvoidmain(String[]args){ProducerConsumerExampleexample=newProducerConsumerExample();newThread(example.newProducer()).start();newThread(example.newConsumer()).start();}}六、最佳实践
1.优先使用线程池
// ❌ 不推荐newThread(()->doSomething()).start();// ✅ 推荐ExecutorServiceexecutor=Executors.newFixedThreadPool(10);executor.submit(()->doSomething());2.合理设置线程池参数
// CPU密集型：线程数 = CPU核心数 + 1intcpuIntensive=Runtime.getRuntime().availableProcessors()+1;// IO密集型：线程数 = CPU核心数 * 2intioIntensive=Runtime.getRuntime().availableProcessors()*2;3.避免死锁
// 按固定顺序获取锁publicvoidtransfer(Accountfrom,Accountto,intamount){Accountfirst=from.getId()<to.getId()?from:to;Accountsecond=from.getId()<to.getId()?to:from;synchronized(first){synchronized(second){from.debit(amount);to.credit(amount);}}}4.正确关闭线程池
executor.shutdown();// 不再接受新任务try{if(!executor.awaitTermination(60,TimeUnit.SECONDS)){executor.shutdownNow();// 强制关闭}}catch(InterruptedExceptione){executor.shutdownNow();}5.使用线程安全的集合
// 线程安全的集合ConcurrentHashMap<String,Integer>map=newConcurrentHashMap<>();CopyOnWriteArrayList<String>list=newCopyOnWriteArrayList<>();BlockingQueue<Task>queue=newLinkedBlockingQueue<>();七、常见问题
1.start() vs run()
start()：启动新线程，JVM调用run()方法run()：普通方法调用，在当前线程执行
2.sleep() vs wait()
sleep()：Thread类方法，不释放锁wait()：Object类方法，释放锁，需要notify()唤醒
3.如何停止线程
// ✅ 推荐：使用标志位privatevolatilebooleanrunning=true;publicvoidstop(){running=false;}// ❌ 不推荐：使用stop()方法（已废弃）八、总结
Java多线程是提升程序性能和响应速度的重要手段。选择合适的实现方式和同步机制，遵循最佳实践，可以编写出高效、安全的并发程序。
关键要点：
- 优先使用线程池管理线程
- 注意线程安全问题
- 合理设置线程数量
- 避免死锁和资源竞争
- 正确处理异常和关闭资源
希望这篇文章能帮助你更好地理解和使用Java多线程！
