【设计模式】单例模式和生产者消费者模型
单例模式
单例模式是一种常见的设计模式，旨在确保一个类只有一个实例，并提供一个全局访问点。这种模式常用于需要控制资源的类，比如配置管理、线程池等。
主要特性：
- 唯一性：类只有一个实例。
- 全局访问：提供一个静态方法获取该实例。
- 延迟加载（可选）：实例在第一次使用时创建。
实现方法
1. 饿汉式单例
在类加载时就创建实例，线程安全，但不支持延迟加载。
public class Singleton {// 静态实例private static final Singleton instance = new Singleton();// 私有构造函数private Singleton() {}// 公共方法获取实例public static Singleton getInstance() {return instance;}
}
2. 懒汉式单例
在第一次调用时创建实例，支持延迟加载，线程不安全的实现。
public class Singleton {// 静态实例private static Singleton instance;// 私有构造函数private Singleton() {}// 公共方法获取实例public static Singleton getInstance() {if (instance == null) {instance = new Singleton();}return instance;}
}
3. 线程安全的懒汉式单例
通过同步方法实现线程安全。
public class Singleton {private static Singleton instance;private Singleton() {}public static synchronized Singleton getInstance() {if (instance == null) {instance = new Singleton();}return instance;}
}
4. 双重检查锁定
结合懒加载和性能优化，通过“双重检查”实现线程安全，减少同步开销。
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;}
}
总结
单例模式通过限制实例化数量，简化了代码管理和资源控制。在选择实现方式时，要考虑到线程安全和性能需求，适当选择实现。
wait 和 notify 方法
在Java中，wait 和 notify 是用于线程间通信的重要方法。这些方法被定义在 Object 类中，因此所有的对象都可以利用这些方法进行线程协调。它们通常用于同步块（synchronized block）中，以实现线程的等待和通知机制。
wait 方法
wait() 方法使当前线程等待，直到其他线程调用 notify() 或 notifyAll() 方法来唤醒它。调用 wait() 方法的线程会释放持有的对象锁。
notify 方法
notify() 方法用于唤醒一个正在等待该对象监视器的线程。如果有多个线程在等待，则其中一个线程会被唤醒，具体被哪个线程唤醒是不确定的。使用 notifyAll() 可以唤醒所有在等待该对象监视器的线程。
生产者消费者模型
生产者消费者模型是一种常见的并发设计模式，它用于解决生产者和消费者之间的协作问题。生产者负责生成数据，消费者则负责处理数据。这个模型通过缓冲区的方式进行协调，确保生产者在缓冲区满时暂停生产，消费者在缓冲区空时暂停消费。
主要特性：
- 并发性：生产者和消费者可以并行工作。
- 缓冲区：使用一个共享的缓冲区来存储数据。
- 同步控制：需要通过适当的同步机制来确保线程安全。
实现方法
以下是一个使用 Java 的生产者消费者模型的示例，利用 wait() 和 notify() 方法进行线程间的通信。
1. 定义缓冲区
import java.util.LinkedList;class Buffer {private LinkedList<Integer> queue = new LinkedList<>();private final int CAPACITY = 5;// 生产者向缓冲区添加数据public synchronized void produce(int value) throws InterruptedException {while (queue.size() == CAPACITY) {wait(); // 如果缓冲区满，等待消费者消费}queue.add(value);System.out.println("Produced: " + value);notifyAll(); // 通知消费者可以消费}// 消费者从缓冲区获取数据public synchronized int consume() throws InterruptedException {while (queue.isEmpty()) {wait(); // 如果缓冲区空，等待生产者生产}int value = queue.removeFirst();System.out.println("Consumed: " + value);notifyAll(); // 通知生产者可以生产return value;}
}
2. 定义生产者
class Producer extends Thread {private Buffer buffer;public Producer(Buffer buffer) {this.buffer = buffer;}@Overridepublic void run() {for (int i = 0; i < 10; i++) {try {buffer.produce(i);Thread.sleep(500); // 模拟生产时间} catch (InterruptedException e) {e.printStackTrace();}}}
}
3. 定义消费者
class Consumer extends Thread {private Buffer buffer;public Consumer(Buffer buffer) {this.buffer = buffer;}@Overridepublic void run() {for (int i = 0; i < 10; i++) {try {buffer.consume();Thread.sleep(1000); // 模拟消费时间} catch (InterruptedException e) {e.printStackTrace();}}}
}
4. 测试生产者和消费者
public class ProducerConsumerExample {public static void main(String[] args) {Buffer buffer = new Buffer();Producer producer = new Producer(buffer);Consumer consumer = new Consumer(buffer);producer.start();consumer.start();}
}
总结
在这个示例中，生产者和消费者通过一个共享的缓冲区进行交互，使用 synchronized 关键字、wait() 和 notifyAll() 方法实现同步控制。生产者在缓冲区满时暂停生产，消费者在缓冲区空时暂停消费，从而有效地协调了两者之间的关系。这个模型广泛应用于多线程编程、任务调度等场景。