基于多线程+队列实现生产者和消费者

需求分析

需要设计一个系统，能够实时接收视频传来的车牌数据并注入到对应的车辆实体类中。这可能涉及到多线程编程，以处理并监督车牌数据的流入和处理。下面是一种可能的设计思想：

设计思路

**生产者-消费者模式：**你可以考虑使用生产者-消费者模式来处理这个问题。视频传来的车牌数据作为生产者，负责将数据添加到队列中，而消费者线程将从队列中获取数据并进行处理。

**队列数据结构：**选择合适的队列数据结构，例如BlockingQueue，作为生产者和消费者之间的通信通道。这可以帮助实现线程安全和流量控制。

**多线程处理：**创建多个消费者线程，每个线程负责从队列中获取数据，解析车牌信息，然后将其注入到对应的车辆实体类中。这有助于并发处理车牌数据，加快处理速度。

**线程池管理：**考虑使用线程池来管理消费者线程。这可以减少线程创建和销毁的开销，提高系统性能。

**监督和控制：**实现一个监督线程，负责监控队列中的数据，以确保数据的处理速度跟得上数据的流入速度。如果队列变得太大，可以采取控制措施，例如拒绝新的数据或者适当地减少生产者速度。

**异常处理：**考虑如何处理异常情况，例如处理无效的车牌数据或者队列溢出。确保系统的稳定性和可靠性。

**并发安全：**在处理车牌数据时，要确保并发安全性。这可能需要对车辆实体类进行适当的同步操作，以避免多个线程同时修改相同的实体。

**性能调优：**根据系统的性能需求，可以采取一些性能优化措施，例如使用缓存、异步处理等。

**日志和监控：**实施适当的日志记录和监控机制，以便跟踪系统的状态和性能。

总之，这个设计思想旨在构建一个能够高效处理视频传来的车牌数据的系统。考虑到并发性、性能和可维护性等因素，可以进一步细化和优化设计，以满足具体需求。

notify() 和 wait() 作为Java 中用于线程间通信的两个关键方法，通常与synchronized关键字一起使用。
它们用于实现线程之间的协同工作，允许线程在某些条件下等待、唤醒或通知其他线程。

这两个方法一起使用可以实现生产者-消费者模式，或者线程间的协同工作。生产者线程通过notify()通知消费者线程，生产了数据，而消费者线程通过wait()等待新的数据。这种方式可以有效地控制线程的执行顺序和同步。

代码展示

生产者

import java.util.ArrayList;
import java.util.List;

class DataProcessor {
    private List<String> dataList = new ArrayList<>();

    public synchronized void produce(String data) {
        dataList.add(data);
        notify(); // 唤醒等待的消费线程
    }

    public synchronized String consume() {
        while (dataList.isEmpty()) {
            try {
                wait(); // 等待数据可供消费
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }
        return dataList.remove(0);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

• notify(): notify() 方法用于通知等待在对象上的一个线程，告诉它可以继续执行。通常是在一个线程执行完某项任务后，通过notify()来通知等待的线程可以执行了。如果有多个线程在等待，只有一个会被唤醒。

• wait(): wait() 方法用于使当前线程等待，直到另一个线程调用相同对象上的notify()方法为止。通常在一个线程需要等待某个条件满足时使用wait()来暂停自己的执行。调用wait()后，线程将进入等待状态，直到其他线程调用相同对象上的notify()或notifyAll()方法。

这两个方法一起使用可以实现生产者-消费者模式，或者线程间的协同工作。生产者线程通过notify()通知消费者线程，生产了数据，而消费者线程通过wait()等待新的数据。这种方式可以有效地控制线程的执行顺序和同步。

需要注意的是，notify() 和 wait() 方法必须在synchronized块内部调用，因为它们要求线程获取对象的锁才能执行。如果不在synchronized块内部使用这些方法，将会引发IllegalMonitorStateException异常；

class DataProducer implements Runnable {
    private DataProcessor dataProcessor;

    public DataProducer(DataProcessor dataProcessor) {
        this.dataProcessor = dataProcessor;
    }

    @Override
    public void run() {
        for (int i = 1; i <= 10; i++) {
            String data = "Data " + i;
            dataProcessor.produce(data);
            System.out.println("Produced: " + data);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

class DataConsumer implements Runnable {
    private DataProcessor dataProcessor;

    public DataConsumer(DataProcessor dataProcessor) {
        this.dataProcessor = dataProcessor;
    }

    @Override
    public void run() {
        for (int i = 1; i <= 10; i++) {
            String data = dataProcessor.consume();
            System.out.println("Consumed: " + data);
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

创建生产和消费者；

public class ListDataProcessingDemo {
    public static void main(String[] args) {
        DataProcessor dataProcessor = new DataProcessor();
        DataProducer producer = new DataProducer(dataProcessor);
        DataConsumer consumer = new DataConsumer(dataProcessor);

        Thread producerThread = new Thread(producer);
        Thread consumerThread = new Thread(consumer);

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14

注入线程，启动进行测试

顺序消费