网站做ssl证书有风险,淄博电商网站建设,企业馆设计公司,做设计的搜素材上什么网站引言
小伙伴们#xff0c;今天小黑要和咱们聊聊Java并发编程的那些事儿。在现代软件开发中#xff0c;高效地处理多任务是一个不可或缺的能力。特别是对于服务成千上万用户的应用#xff0c;能够同时处理多个操作不仅是一个加分项#xff0c;简直是必备技能了#xff01;… 引言
小伙伴们今天小黑要和咱们聊聊Java并发编程的那些事儿。在现代软件开发中高效地处理多任务是一个不可或缺的能力。特别是对于服务成千上万用户的应用能够同时处理多个操作不仅是一个加分项简直是必备技能了
但说实话Java并发编程就像是一门艺术既美丽又充满挑战。为什么这么说呢首先它能让咱们的应用跑得更快处理更多的任务。但与此同时如果处理不当它也可能让整个应用崩溃或者出现各种难以预料的问题。
所以小黑在这里要和咱们一起探讨一下Java并发编程的奥秘看看怎样才能既享受它带来的便利又避免那些潜在的坑。
并发编程的基础
讲到并发编程咱们首先得搞明白“并发”和“并行”的区别。简单来说「并发」是指多个任务在同一时间段内执行而「并行」则是多个任务在同一时刻同时执行。听起来差不多但其实区别大了去了。
在Java世界里线程是并发的基石。每个线程都像是一个小小的工人它们在JVM里并行工作各司其职。但是线程之间的协作并非易事。想象一下如果两个线程同时试图修改同一个数据事情就会变得复杂。
为了解决这种问题Java提供了各种同步机制比如锁和内存模型。锁就像是一把钥匙确保在某一时刻只有一个线程可以访问特定的资源。而Java内存模型JMM则确保了线程间的可见性和有序性保证了一个线程对共享变量的修改其他线程能够及时看到。
来看个简单的例子
public class Counter {private int count 0;public synchronized void increment() {count;}public int getCount() {return count;}
}这里increment方法用synchronized关键字修饰确保每次只有一个线程能够进入这个方法从而安全地增加count的值。
但这只是冰山一角。并发编程的世界远比这复杂。接下来小黑会带咱们深入到Java并发编程的更多细节和模式里去。别担心虽然听起来有点吓人但只要咱们一步一个脚印地走就能慢慢掌握它的精髓。 PS: 小黑收集整理了一份超级全面的复习面试资料包在这偷偷分享给你~ 链接https://sourl.cn/CjagkK 提取码yqwt Java并发模式
生产者-消费者模式
这个模式就像是餐厅里的厨师和食客。厨师生产者负责制作食物食客消费者则负责消费。在编程世界里咱们也经常遇到类似的场景比如一个线程生成数据另一个线程处理这些数据。
来看个例子
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;class Producer implements Runnable {private BlockingQueueInteger queue;Producer(BlockingQueueInteger queue) {this.queue queue;}Overridepublic void run() {for (int i 0; i 10; i) {try {System.out.println(Produced: i);queue.put(i);Thread.sleep(1000);} catch (InterruptedException e) {Thread.currentThread().interrupt();}}}
}class Consumer implements Runnable {private BlockingQueueInteger queue;Consumer(BlockingQueueInteger queue) {this.queue queue;}Overridepublic void run() {while (true) {try {Integer value queue.take();System.out.println(Consumed: value);Thread.sleep(1000);} catch (InterruptedException e) {Thread.currentThread().interrupt();}}}
}public class ProducerConsumerExample {public static void main(String[] args) {BlockingQueueInteger queue new LinkedBlockingQueue();Thread producerThread new Thread(new Producer(queue));Thread consumerThread new Thread(new Consumer(queue));producerThread.start();consumerThread.start();}
}在这个例子中Producer和Consumer分别是生产者和消费者它们通过一个共享的BlockingQueue进行通信。 读写锁模式
当咱们在处理并发数据时经常会遇到这样的情况读操作比写操作频繁得多。为了优化这种场景就有了读写锁模式。这种模式允许多个线程同时读取数据但在写入数据时则需要独占锁。
来看个简单的读写锁实现
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;class SharedResource {private ReadWriteLock lock new ReentrantReadWriteLock();private int resourceValue;public void increment() {lock.writeLock().lock();try {resourceValue;} finally {lock.writeLock().unlock();}}public int getValue() {lock.readLock().lock();try {return resourceValue;} finally {lock.readLock().unlock();}}
}public class ReadWriteLockExample {public static void main(String[] args) {SharedResource sharedResource new SharedResource();// 创建多个读取线程和写入线程// ...}
}在这个例子中SharedResource类使用ReadWriteLock来实现读写分离提高了在高并发情况下的性能。 单例模式
在并发环境下单例模式确保一个类只创建一个实例并且提供一个全局访问点。这在处理资源共享比如数据库连接或配置管理时尤为重要。但在多线程环境中要确保这个实例不会被多次创建。
来看个双检锁的单例实现示例
public class Singleton {private static volatile Singleton instance;private Singleton() {}public static Singleton getInstance() {if (instance null) {synchronized (Singleton.class) {if (instance null) {instance new Singleton();}}}return instance;}
}这里使用了volatile关键字和双重检查锁定以确保线程安全且性能优化。
观察者模式
观察者模式在并发环境中也很有用特别是在事件驱动或消息传递系统中。在这种模式下被观察对象一旦状态变化就会通知所有观察者对象。
看下面的代码示例
import java.util.ArrayList;
import java.util.List;interface Observer {void update(String message);
}class ConcreteObserver implements Observer {Overridepublic void update(String message) {System.out.println(Received message: message);}
}class Subject {private ListObserver observers new ArrayList();public void attach(Observer observer) {observers.add(observer);}public void notifyObservers(String message) {for (Observer observer : observers) {observer.update(message);}}
}public class ObserverPatternExample {public static void main(String[] args) {Subject subject new Subject();Observer observer new ConcreteObserver();subject.attach(observer);subject.notifyObservers(Hello, Observer Pattern!);}
}在这个示例中Subject类维护一个观察者列表当发生某些事件时它会通知所有观察者。
工作窃取模式
在并发编程的世界里平衡每个线程的负载是一项挑战。有时候一些线程可能忙得不可开交而其他线程则闲得发慌。这时「工作窃取模式」就闪亮登场了。它允许空闲的线程从忙碌的线程那里偷取任务来执行。
在Java中咱们可以利用ForkJoinPool来实现这个模式。下面是一个简单的示例
import java.util.concurrent.RecursiveTask;
import java.util.concurrent.ForkJoinPool;class SimpleRecursiveTask extends RecursiveTaskInteger {private int simulatedWork;public SimpleRecursiveTask(int simulatedWork) {this.simulatedWork simulatedWork;}Overrideprotected Integer compute() {if (simulatedWork 100) {System.out.println(Parallel execution needed because of the huge task: simulatedWork);SimpleRecursiveTask task1 new SimpleRecursiveTask(simulatedWork / 2);SimpleRecursiveTask task2 new SimpleRecursiveTask(simulatedWork / 2);task1.fork();task2.fork();int solution 0;solution task1.join();solution task2.join();return solution;} else {System.out.println(No need for parallel execution, small task: simulatedWork);return 2 * simulatedWork;}}
}public class WorkStealingExample {public static void main(String[] args) {ForkJoinPool forkJoinPool new ForkJoinPool(Runtime.getRuntime().availableProcessors());SimpleRecursiveTask task new SimpleRecursiveTask(400);System.out.println(forkJoinPool.invoke(task));}
}在这个例子中SimpleRecursiveTask是一个简单的任务它会根据工作量的大小决定是否需要拆分为更小的任务。ForkJoinPool负责管理这些任务包括任务的分配和工作窃取。
事件驱动模式
事件驱动模式是另一个在并发编程中非常有用的模式。在这个模式中程序的流程是由事件决定的比如用户输入、传感器信号或者消息。这种模式在编写响应式程序时特别有用。
在Java中咱们可以使用监听器和回调来实现这个模式。下面是一个简单的事件监听器实现
import java.util.ArrayList;
import java.util.List;interface EventListener {void onEvent(Event e);
}class Event {}class EventSource {private final ListEventListener listeners new ArrayList();public void registerListener(EventListener listener) {listeners.add(listener);}public void eventOccured(Event e) {for (EventListener listener : listeners) {listener.onEvent(e);}}
}public class EventDrivenExample {public static void main(String[] args) {EventSource eventSource new EventSource();eventSource.registerListener(e - System.out.println(Event received: e));eventSource.eventOccured(new Event());}
}在这个例子中EventSource是事件的源头它可以触发事件。当事件发生时所有注册的EventListener都会接收到通知。
接着上面的话题小黑还要和咱们聊两个挺酷的并发模式双检锁模式和线程局部存储模式。
双检锁/双重校验锁模式
这个模式用于创建线程安全的懒汉式单例。所谓懒汉式就是实例在第一次被使用时才创建。但要小心如果不正确实现就可能在多线程环境下产生多个实例。这就是双检锁模式发挥作用的地方。
看看这个例子
public class Singleton {private volatile static Singleton instance;private Singleton() {}public static Singleton getInstance() {if (instance null) {synchronized (Singleton.class) {if (instance null) {instance new Singleton();}}}return instance;}
}在这里小黑使用了两次检查第一次检查避免不必要的同步第二次检查确保只有一个实例被创建。同时instance变量被声明为volatile防止指令重排序。
线程局部存储模式
线程局部存储Thread Local Storage, TLS模式允许咱们为每个线程存储单独的数据副本从而避免了多线程间的数据共享问题。这在处理像数据库连接或用户会话这样的任务时特别有用。
来看个例子
public class ThreadLocalExample {private static final ThreadLocalInteger threadLocalValue new ThreadLocal();public static void main(String[] args) {Thread thread1 new Thread(() - {threadLocalValue.set(1);System.out.println(Thread 1: threadLocalValue.get());});Thread thread2 new Thread(() - {threadLocalValue.set(2);System.out.println(Thread 2: threadLocalValue.get());});thread1.start();thread2.start();}
}在这个例子中每个线程都有一个自己的threadLocalValue副本互不干扰。这种方式特别适合那些需要隔离处理每个线程状态的场景。
有限状态机模式
接下来小黑带咱们看看另一个在Java并发编程中非常有用的模式有限状态机Finite State Machine, FSM。这个模式就像是一部机器它根据输入改变自己的状态。在并发编程中这个模式特别有用因为它帮助管理复杂的状态转换尤其是在多线程环境下。
想象一下咱们有一个网络连接的类它可以处于连接、断开或重连等状态。这些状态之间的转换需要精确控制以避免多个线程造成的混乱。有限状态机就是为此而生的。
来看看怎么用代码实现这个模式
public class ConnectionState {private enum State {CONNECTED, DISCONNECTED, RECONNECTING}private State currentState;public ConnectionState() {currentState State.DISCONNECTED;}public synchronized void connect() {if (currentState State.DISCONNECTED) {currentState State.CONNECTED;// 连接逻辑}}public synchronized void disconnect() {if (currentState State.CONNECTED) {currentState State.DISCONNECTED;// 断开连接逻辑}}public synchronized void reconnect() {if (currentState State.DISCONNECTED) {currentState State.RECONNECTING;// 重连逻辑}}// 其他方法...
}在这个简单的例子中ConnectionState类用枚举State来表示不同的状态并且每个方法都会根据当前的状态来决定是否改变状态。这种方式使得状态转换清晰、可控极大地减少了并发环境中的复杂性。
总结
小黑今天和咱们一起走过了Java并发编程的几个关键模式。咱们看到了无论是生产者-消费者模式还是读写锁模式亦或是有限状态机每一种模式都像是并发编程的一块拼图帮助咱们构建起更稳健、更高效的应用程序。
记住并发编程并不仅仅是关于线程的启动和停止更重要的是理解数据之间的交互和状态的管理。通过今天的学习咱们可以更好地把握这些概念更加灵活地应用于实际的开发工作中。
在并发编程的世界里没有一劳永逸的解决方案。随着技术的发展和应用场景的变化新的模式和理论也在不断涌现。因此持续学习保持好奇心和探索精神是每个Java开发者成长道路上不可或缺的一部分。
希望通过今天的分享咱们都能在Java并发编程的路上走得更远构建出更加强大、更加稳定的应用。记得每一步的进步都是通往高手之路的重要一环加油咱们一起向前 面对寒冬我们更需团结小黑收集整理了一份超级强大的复习面试资料包也强烈建议你加入我们的Java后端报团取暖群一起复习共享各种学习资源互助成长。无论是新手还是老手这里都有你的位置。在这里我们共同应对职场挑战分享经验提升技能闲聊副业共同抵御不确定性携手走向更稳定的职业未来。让我们在Java的路上不再孤单进群方式以及资料点击如下链接即可获取
链接https://sourl.cn/CjagkK 提取码yqwt
