网站建设软件免费北京网站设计推荐刻

网站建设软件免费,北京网站设计推荐刻,工商局网上注册公司流程,ui设计培训班的学费一般是多少钱?1. 理解线程#xff1a;多任务执行的基石 1.1 什么是线程#xff1f; 在现代操作系统中#xff0c;进程是资源分配的基本单位#xff0c;而线程是CPU调度的最小单位。可以把进程想象成一家公司#xff0c;线程就是公司里的员工。 /** * 演示Java程序天生就是多线程程序 …1. 理解线程多任务执行的基石1.1 什么是线程在现代操作系统中进程是资源分配的基本单位而线程是CPU调度的最小单位。可以把进程想象成一家公司线程就是公司里的员工。/*** 演示Java程序天生就是多线程程序* 即使最简单的main方法也会启动多个系统线程*/public class MultiThread {public static void main(String[] args) {// 获取Java线程管理MXBeanThreadMXBean threadMXBean ManagementFactory.getThreadMXBean();// 不需要获取同步的monitor和synchronizer信息仅获取线程和线程堆栈信息ThreadInfo[] threadInfos threadMXBean.dumpAllThreads(false, false);// 遍历线程信息System.out.println( Java程序启动的线程列表 );for (ThreadInfo threadInfo : threadInfos) {System.out.println([ threadInfo.getThreadId() ] threadInfo.getThreadName());}}}输出示例 Java程序启动的线程列表 [4] Signal Dispatcher // 分发处理发送给JVM信号的线程[3] Finalizer // 调用对象finalize方法的线程[2] Reference Handler // 清除Reference的线程[1] main // main线程用户程序入口1.2 为什么需要多线程三大核心优势充分利用多核处理器 - 避免CPU资源闲置提升响应速度 - 后台任务不阻塞用户操作更好的编程模型 - Java提供一致的多线程API1.3 线程状态生命周期新建(NEW) → 可运行(RUNNABLE) → 运行中↓超时等待(TIMED_WAITING) ← 等待(WAITING) ← 阻塞(BLOCKED)↓终止(TERMINATED)2. 线程的启动与安全终止2.1 正确启动线程/*** 线程启动最佳实践示例* 重点设置有意义的线程名称合理设置守护线程标志*/public class ThreadStartExample {public static void main(String[] args) {// 推荐为线程设置有意义的名称便于问题排查Thread worker new Thread(new Task(), Data-Processor-1);worker.setDaemon(false); // 明确设置是否为守护线程worker.start(); // 正确启动方式不要直接调用run()System.out.println(主线程继续执行不会等待worker线程);}static class Task implements Runnable {Overridepublic void run() {System.out.println(Thread.currentThread().getName() 开始执行);try {// 模拟工作任务Thread.sleep(1000);} catch (InterruptedException e) {System.out.println(任务被中断);}System.out.println(Thread.currentThread().getName() 执行完成);}}}2.2 安全终止线程的两种方式方式一使用中断机制/*** 使用中断机制安全终止线程* 重点理解中断异常处理的最佳实践*/public class InterruptExample {public static void main(String[] args) throws InterruptedException {Thread worker new Thread(new InterruptibleTask(), Interruptible-Worker);worker.start();// 主线程等待2秒后中断工作线程TimeUnit.SECONDS.sleep(2);System.out.println(主线程发送中断信号);worker.interrupt(); // 发送中断信号// 等待工作线程完全退出worker.join();System.out.println(工作线程已安全退出);}static class InterruptibleTask implements Runnable {Overridepublic void run() {while (!Thread.currentThread().isInterrupted()) {try {// 模拟工作 - 这里可能抛出InterruptedExceptionSystem.out.println(Working...);TimeUnit.MILLISECONDS.sleep(500);} catch (InterruptedException e) {/*** 关键理解点为什么需要重新设置中断状态** 当线程在阻塞状态如sleep、wait、join时被中断* Java会做两件事* 1. 抛出InterruptedException* 2. 清除线程的中断状态设为false** 这导致循环条件 !Thread.currentThread().isInterrupted()* 会继续为true线程无法退出。** 因此我们需要在捕获异常后重新设置中断状态* 这样循环条件就能检测到中断安全退出。*/System.out.println(捕获到中断异常重新设置中断状态);Thread.currentThread().interrupt(); // 重新设置中断标志}}System.out.println(线程安全退出中断状态: Thread.currentThread().isInterrupted());}}}方式二使用标志位/*** 使用volatile标志位安全终止线程* 适用于没有阻塞调用或需要更复杂退出逻辑的场景*/public class FlagShutdownExample {// volatile保证可见性确保所有线程看到最新的值private volatile boolean running true;private final Thread workerThread;public FlagShutdownExample() {this.workerThread new Thread(this::doWork, Flag-Controlled-Worker);}public void start() {workerThread.start();}/*** 优雅停止工作线程*/public void stop() {System.out.println(请求停止工作线程);running false;// 同时发送中断处理可能存在的阻塞情况workerThread.interrupt();}/*** 工作线程的主循环* 同时检查标志位和中断状态提供双重保障*/private void doWork() {try {while (running !Thread.currentThread().isInterrupted()) {// 执行工作任务processData();}} finally {// 无论何种方式退出都执行清理工作cleanup();}System.out.println(工作线程已安全退出);}private void processData() {try {// 模拟数据处理System.out.println(处理数据中...);Thread.sleep(300);} catch (InterruptedException e) {System.out.println(处理数据时被中断);// 收到中断但可能还想继续处理所以不重新设置中断// 让循环条件来检查running标志}}private void cleanup() {System.out.println(执行资源清理工作...);// 关闭文件、数据库连接等资源}public static void main(String[] args) throws InterruptedException {FlagShutdownExample example new FlagShutdownExample();example.start();// 运行3秒后停止Thread.sleep(3000);example.stop();// 等待工作线程退出example.workerThread.join();}}3. 线程间通信协作的艺术3.1 volatile关键字共享状态可见性/*** volatile关键字示例* 保证多线程间的可见性但不保证原子性*/public class VolatileExample {// volatile确保shutdownRequested的修改对所有线程立即可见private volatile boolean shutdownRequested false;private int operationCount 0; // 非volatile不保证可见性public void shutdown() {shutdownRequested true; // 所有线程立即可见System.out.println(关闭请求已设置);}public void doWork() {while (!shutdownRequested) {// 正常工作循环operationCount; // 非原子操作可能有问题try {Thread.sleep(100);} catch (InterruptedException e) {System.out.println(工作被中断);Thread.currentThread().interrupt();break;}}System.out.println(工作线程退出操作次数: operationCount);}}3.2 synchronized关键字互斥访问/*** synchronized关键字示例* 保证原子性和可见性但可能影响性能*/public class SynchronizedCounter {private int count 0;/*** 同步方法 - 锁对象是当前实例(this)*/public synchronized void increment() {count; // 原子操作}/*** 同步块 - 可以更细粒度控制锁的范围*/public void decrement() {// 只同步关键部分减少锁持有时间synchronized (this) {count--;}// 这里可以执行非同步操作}/*** 同步的get方法保证看到最新值*/public synchronized int getCount() {return count;}/*** 静态同步方法 - 锁对象是类的Class对象*/public static synchronized void staticMethod() {// 静态同步方法使用Class对象作为锁}}3.3 等待/通知机制经典生产者-消费者模式/*** 生产者-消费者模式示例* 演示wait/notify机制的正确使用*/public class WaitNotifyExample {private final Object lock new Object(); // 共享锁对象private final QueueString queue new LinkedList();private final int MAX_SIZE 5;/*** 生产者方法*/public void produce(String data) throws InterruptedException {synchronized (lock) {// 必须使用while循环检查条件避免虚假唤醒while (queue.size() MAX_SIZE) {System.out.println(队列已满( queue.size() )生产者等待);lock.wait(); // 释放锁并等待}queue.offer(data);System.out.println(生产: data 队列大小: queue.size());// 通知所有等待的消费者lock.notifyAll();}}/*** 消费者方法*/public String consume() throws InterruptedException {synchronized (lock) {// 必须使用while循环检查条件while (queue.isEmpty()) {System.out.println(队列为空消费者等待);lock.wait(); // 释放锁并等待}String data queue.poll();System.out.println(消费: data 队列大小: queue.size());// 通知所有等待的生产者lock.notifyAll();return data;}}/*** 测试生产者消费者模式*/public static void main(String[] args) {WaitNotifyExample example new WaitNotifyExample();// 启动生产者线程Thread producer new Thread(() - {try {for (int i 0; i 10; i) {example.produce(Data- i);Thread.sleep(200);}} catch (InterruptedException e) {Thread.currentThread().interrupt();}}, Producer);// 启动消费者线程Thread consumer new Thread(() - {try {for (int i 0; i 10; i) {example.consume();Thread.sleep(300);}} catch (InterruptedException e) {Thread.currentThread().interrupt();}}, Consumer);producer.start();consumer.start();}}等待/通知经典范式// 消费者范式 - 永远在循环中调用wait()synchronized(锁对象) {while(条件不满足) {锁对象.wait(); // 等待时会释放锁}// 条件满足处理业务逻辑}// 生产者范式synchronized(锁对象) {改变条件; // 改变等待条件锁对象.notifyAll(); // 通知所有等待线程}3.4 Thread.join()线程依赖执行/*** Thread.join()使用示例* 实现线程间的顺序执行依赖*/public class JoinExample {public static void main(String[] args) throws InterruptedException {System.out.println(主线程开始);Thread previous Thread.currentThread();// 创建5个有依赖关系的线程for (int i 0; i 5; i) {Thread thread new Thread(new DependentTask(previous), Worker- i);thread.start();previous thread; // 设置依赖链}// 主线程先做一些工作TimeUnit.SECONDS.sleep(1);System.out.println(Thread.currentThread().getName() 完成初始化工作);// 等待所有线程完成实际上由最后一个Worker-4 join主线程}static class DependentTask implements Runnable {private final Thread dependency; // 依赖的线程public DependentTask(Thread dependency) {this.dependency dependency;}Overridepublic void run() {try {// 等待依赖的线程执行完成System.out.println(Thread.currentThread().getName() 等待 dependency.getName());dependency.join();// 依赖线程完成后开始自己的工作System.out.println(Thread.currentThread().getName() 开始工作);TimeUnit.MILLISECONDS.sleep(500); // 模拟工作System.out.println(Thread.currentThread().getName() 完成工作);} catch (InterruptedException e) {System.out.println(Thread.currentThread().getName() 被中断);Thread.currentThread().interrupt();}}}}3.5 ThreadLocal深入解析线程局部变量/*** ThreadLocal深度解析* 理解原理、使用场景和内存泄漏防护*/public class ThreadLocalExample {/*** ThreadLocal基本使用每个线程独立的SimpleDateFormat* 避免SimpleDateFormat的线程安全问题*/private static final ThreadLocalSimpleDateFormat DATE_FORMATTER ThreadLocal.withInitial(() - new SimpleDateFormat(yyyy-MM-dd HH:mm:ss));/*** ThreadLocal用于用户上下文传递* 在Web应用中非常有用避免在方法参数中传递用户信息*/private static final ThreadLocalUserContext USER_CONTEXT new ThreadLocal();/*** ThreadLocal用于事务上下文*/private static final ThreadLocalTransactionContext TRANSACTION_CONTEXT new ThreadLocal();/*** 可继承的ThreadLocal子线程可以继承父线程的值*/private static final InheritableThreadLocalString INHERITABLE_CONTEXT new InheritableThreadLocal();/*** 处理用户请求的示例方法*/public void processRequest(User user) {// 设置用户上下文到当前线程USER_CONTEXT.set(new UserContext(user));try {// 使用线程安全的日期格式化String timestamp DATE_FORMATTER.get().format(new Date());System.out.println(Thread.currentThread().getName() - 用户: user.getName() , 时间: timestamp);// 执行业务逻辑 - 任何方法都可以获取用户上下文无需传递参数doBusinessLogic();} finally {/*** 关键必须清理ThreadLocal防止内存泄漏** 原因* 1. ThreadLocalMap的key是弱引用会被GC回收* 2. 但value是强引用不会被自动回收* 3. 如果线程长时间存活如线程池中的线程会导致value无法释放* 4. 调用remove()方法显式清理*/USER_CONTEXT.remove();DATE_FORMATTER.remove(); // 清理所有使用的ThreadLocal}}private void doBusinessLogic() {// 在任何地方都可以获取用户上下文无需方法参数传递UserContext context USER_CONTEXT.get();if (context ! null) {System.out.println(执行业务逻辑用户: context.getUser().getName());}// 使用线程安全的日期格式化String now DATE_FORMATTER.get().format(new Date());System.out.println(业务执行时间: now);}/*** 演示ThreadLocal的内存泄漏问题*/public void demonstrateMemoryLeak() {// 错误的用法不清理ThreadLocalThreadLocalbyte[] leakyLocal new ThreadLocal();leakyLocal.set(new byte[1024 * 1024]); // 1MB数据// 如果没有调用 leakyLocal.remove(), 即使leakyLocalnull// 线程的ThreadLocalMap中仍然保留着这个Entry// 在线程池场景下线程重用会导致内存不断增长}/*** ThreadLocal最佳实践使用try-finally确保清理*/public void bestPractice(User user) {USER_CONTEXT.set(new UserContext(user));try {// 业务处理doBusinessLogic();} finally {// 确保清理即使在业务逻辑中发生异常USER_CONTEXT.remove();}}/*** 测试多线程环境下的ThreadLocal*/public static void main(String[] args) throws InterruptedException {ThreadLocalExample example new ThreadLocalExample();// 创建多个线程每个线程有独立的ThreadLocal值Thread[] threads new Thread[3];for (int i 0; i threads.length; i) {final int userId i;threads[i] new Thread(() - {User user new User(User- userId);example.processRequest(user);}, Thread- i);threads[i].start();}// 等待所有线程完成for (Thread thread : threads) {thread.join();}System.out.println(所有线程执行完成);}// 辅助类定义static class UserContext {private final User user;public UserContext(User user) { this.user user; }public User getUser() { return user; }}static class User {private final String name;public User(String name) { this.name name; }public String getName() { return name; }}static class TransactionContext {// 事务相关信息}}/*** ThreadLocal高级用法自定义ThreadLocal子类*/class AdvancedThreadLocalT extends ThreadLocalT {/*** 初始值 - 当线程第一次调用get()时如果还没有设置值会调用此方法*/Overrideprotected T initialValue() {System.out.println(Thread.currentThread().getName() - 初始化ThreadLocal值);return null; // 返回默认初始值}/*** 子线程值继承 - 仅对InheritableThreadLocal有效* 当创建新线程时可以控制如何从父线程继承值*/protected T childValue(T parentValue) {System.out.println(子线程继承父线程的值: parentValue);return parentValue; // 直接继承也可以进行转换}}4. 线程应用实例从理论到实践4.1 等待超时模式避免无限期等待/*** 等待超时模式实现* 在等待/通知机制基础上增加超时控制*/public class TimeoutWaitT {private T result;/*** 带超时的获取方法* param timeoutMs 超时时间(毫秒)* return 结果超时返回null*/public synchronized T get(long timeoutMs) throws InterruptedException {long endTime System.currentTimeMillis() timeoutMs;long remaining timeoutMs;// 循环检查条件和剩余时间