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多线程！