Java之Exchanger使用

我会带着你远行 2022-05-31 06:22 131阅读 0赞

Java 并发 API 提供了一种允许2个并发任务间相互交换数据的同步应用。更具体的说，Exchanger 类允许在2个线程间定义同步点，当2个线程到达这个点，他们相互交换数据类型，使用第一个线程的数据类型变成第二个的，然后第二个线程的数据类型变成第一个的。

这个类在遇到类似生产者和消费者问题时，是非常有用的。来一个非常经典的并发问题：你有相同的数据buffer，一个或多个数据生产者，和一个或多个数据消费者。只是Exchange类只能同步2个线程，所以你只能在你的生产者和消费者问题中只有一个生产者和一个消费者时使用这个类。

在这个指南，你将学习如何使用 Exchanger 类来解决只有一个生产者和一个消费者的生产者和消费者问题。

/** * @author wzx * @time 2018/2/9 */
    public class Producer implements Runnable { 
    
        private List<String> buffer;
    
        private final Exchanger<List<String>> exchanger;
    
        public Producer(List<String> buffer, Exchanger<List<String>> exchanger) {
            this.buffer = buffer;
            this.exchanger = exchanger;
        }
    
        @Override
        public void run() {
            int cycle = 1;
            for (int i = 0; i < 10; i++) {
                System.out.printf("Producer: Cycle %d\n", cycle);
                for (int j = 0; j < 10; j++) {
                    String message = "Event " + ((i * 10) + j);
                    System.out.printf("Producer: %s\n", message);
                    buffer.add(message);
                }
                //调用 exchange() 方法来与consumer交换数据
                try {
                    buffer = exchanger.exchange(buffer);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("Producer: " + buffer.size());
                cycle++;
            }
        }
    }

/** * @author wzx * @time 2018/2/9 */
    public class Consumer implements Runnable { 
    
        private List<String> buffer;
    
        private final Exchanger<List<String>> exchanger;
    
        public Consumer(List<String> buffer, Exchanger<List<String>> exchanger) {
            this.buffer = buffer;
            this.exchanger = exchanger;
        }
    
        @Override
        public void run() {
            int cycle = 1;
            for (int i = 0; i < 10; i++) {
                System.out.printf("Consumer: Cycle %d\n", cycle);
                try {
                    buffer = exchanger.exchange(buffer);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                for (int j = 0; j < 10; j++) {
                    String message = buffer.get(0);
                    System.out.println("Consumer: " + message);
                    buffer.remove(0);
                }
                cycle++;
            }
        }
    }

/** * @author wzx * @time 2018/2/9 */
    public class ExchangerTest { 
        public static void main(String[] args) {
            List<String> buffer1 = new ArrayList<>();
            List<String> buffer2 = new ArrayList<>();
    
            Exchanger<List<String>> exchanger = new Exchanger<>();
    
            Producer producer = new Producer(buffer1, exchanger);
            Consumer consumer = new Consumer(buffer2, exchanger);
    
            Thread threadProducer = new Thread(producer);
            Thread threadConsumer = new Thread(consumer);
            threadProducer.start();
            threadConsumer.start();
        }
    }

输出结果：

Producer: Cycle 1
    Consumer: Cycle 1
    Producer: Event 0
    Producer: Event 1
    Producer: Event 2
    Producer: Event 3
    Producer: Event 4
    Producer: Event 5
    Producer: Event 6
    Producer: Event 7
    Producer: Event 8
    Producer: Event 9
    Producer: 0
    Consumer: Event 0
    Producer: Cycle 2
    Consumer: Event 1
    Producer: Event 10
    Producer: Event 11
    Producer: Event 12
    Producer: Event 13
    Producer: Event 14
    Producer: Event 15
    Producer: Event 16
    Producer: Event 17
    Producer: Event 18
    Producer: Event 19
    Consumer: Event 2
    Consumer: Event 3
    Consumer: Event 4
    Consumer: Event 5
    Consumer: Event 6
    Consumer: Event 7
    Consumer: Event 8
    Consumer: Event 9
    Consumer: Cycle 2
    Consumer: Event 10
    Consumer: Event 11
    Consumer: Event 12
    Consumer: Event 13
    Consumer: Event 14
    Consumer: Event 15
    Consumer: Event 16
    Consumer: Event 17
    Consumer: Event 18
    Consumer: Event 19
    Consumer: Cycle 3
    Producer: 0

> [http://ifeve.com/thread-synchronization-utilities-8/][http_ifeve.com_thread-synchronization-utilities-8]

[http_ifeve.com_thread-synchronization-utilities-8]: http://ifeve.com/thread-synchronization-utilities-8/