java 多线程设计模式-CFANZ编程社区

Java 多线程设计模式

引言

多线程编程是现代软件开发中的重要部分。在并发编程中，设计良好的多线程模式可以提高程序的性能和可维护性。本文将介绍几种常见的Java多线程设计模式，并附带代码示例。

1. 单例模式

单例模式是一种创建型设计模式，它可以确保一个类只有一个实例，并提供全局访问点。在多线程环境中，为了避免多个线程同时创建多个实例，我们需要使用双重检查锁定（double-checked locking）来保证线程安全。

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;
    }
}

2. 生产者-消费者模式

生产者-消费者模式是一种协作模式，用于解决生产者和消费者之间的同步问题。生产者负责生成数据，消费者负责消费数据。在多线程环境中，我们可以使用阻塞队列来实现生产者-消费者模式。

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;

public class ProducerConsumer {
    private static final int BUFFER_SIZE = 10;
    private static BlockingQueue<Integer> buffer = new ArrayBlockingQueue<>(BUFFER_SIZE);

    public static void main(String[] args) {
        Thread producerThread = new Thread(() -> {
            try {
                for (int i = 0; i < BUFFER_SIZE; i++) {
                    buffer.put(i);
                    System.out.println("Produced: " + i);
                    Thread.sleep(100);
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        Thread consumerThread = new Thread(() -> {
            try {
                for (int i = 0; i < BUFFER_SIZE; i++) {
                    int value = buffer.take();
                    System.out.println("Consumed: " + value);
                    Thread.sleep(100);
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

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

3. 观察者模式

观察者模式是一种行为模式，用于实现对象之间的一对多依赖关系。当一个对象的状态发生变化时，所有依赖它的对象都将得到通知并自动更新。在多线程环境中，我们可以使用Java内置的观察者模式来实现线程之间的通信。

import java.util.Observable;
import java.util.Observer;

public class ObserverPatternDemo {
    static class MyObservable extends Observable {
        public void setValue(int value) {
            setChanged();
            notifyObservers(value);
        }
    }

    static class MyObserver implements Observer {
        @Override
        public void update(Observable o, Object arg) {
            System.out.println("Received: " + arg);
        }
    }

    public static void main(String[] args) {
        MyObservable observable = new MyObservable();
        MyObserver observer = new MyObserver();

        observable.addObserver(observer);
        observable.setValue(42);
    }
}