Java并发模式和设计策略详解

后端 潘老师 3个月前 (12-04) 65 ℃ (0) 扫码查看

本文主要讲解关于Java并发模式和设计策略详解相关内容,让我们来一起学习下吧!

引言

小伙伴们,今天小黑要和咱们聊聊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并发编程的更多细节和模式里去。别担心,虽然听起来有点吓人,但只要咱们一步一个脚印地走,就能慢慢掌握它的精髓。

Java并发模式

生产者-消费者模式

这个模式,就像是餐厅里的厨师和食客。厨师(生产者)负责制作食物,食客(消费者)则负责消费。在编程世界里,咱们也经常遇到类似的场景,比如一个线程生成数据,另一个线程处理这些数据。

来看个例子:

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;

class Producer implements Runnable {
    private BlockingQueue<Integer> queue;

    Producer(BlockingQueue<Integer> queue) {
        this.queue = queue;
    }

    @Override
    public 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 BlockingQueue<Integer> queue;

    Consumer(BlockingQueue<Integer> queue) {
        this.queue = queue;
    }

    @Override
    public 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) {
        BlockingQueue<Integer> queue = new LinkedBlockingQueue<>();

        Thread producerThread = new Thread(new Producer(queue));
        Thread consumerThread = new Thread(new Consumer(queue));

        producerThread.start();
        consumerThread.start();
    }
}

在这个例子中,ProducerConsumer分别是生产者和消费者,它们通过一个共享的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 {
    @Override
    public void update(String message) {
        System.out.println("Received message: " + message);
    }
}

class Subject {
    private List<Observer> 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 RecursiveTask<Integer> {
    private int simulatedWork;

    public SimpleRecursiveTask(int simulatedWork) {
        this.simulatedWork = simulatedWork;
    }

    @Override
    protected 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 List<EventListener> 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 ThreadLocal<Integer> 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并发模式和设计策略详解相关的全部内容,希望对你有帮助。欢迎持续关注潘子夜个人博客(www.panziye.com),学习愉快哦!


版权声明:本站文章,如无说明,均为本站原创,转载请注明文章来源。如有侵权,请联系博主删除。
本文链接:https://www.panziye.com/back/12090.html
喜欢 (0)
请潘老师喝杯Coffee吧!】
分享 (0)
用户头像
发表我的评论
取消评论
表情 贴图 签到 代码

Hi,您需要填写昵称和邮箱!

  • 昵称【必填】
  • 邮箱【必填】
  • 网址【可选】