java 线程间交换数据的Exchanger

life1024

已于 2025-02-28 17:08:30 修改

阅读量483

点赞数

CC 4.0 BY-SA版权

分类专栏： java 线程有关文章标签： java windows 开发语言

于 2017-07-31 18:34:12 首次发布

本文链接：https://blog.csdn.net/u013378306/article/details/76461536

java 线程有关专栏收录该内容

10 篇文章

订阅专栏

本文通过两个示例展示了Java中Exchanger类的基本用法。第一个示例使用Exchanger进行字符串数据交换，第二个示例则交换了List类型的元素。两个线程通过Exchanger实现了数据同步。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

字符串

线程1调用exchange()方法时，它会阻塞直到线程2也调用了exchange()方法。一旦两个线程都到达了exchange()调用，它们就会交换它们提供的数据，并且每个线程都会继续执行，接收到对方提供的数据。

如果三个线程共用一个Exchanger ，那么2个线程会交换数据，第三个线程没有配对的，然后会一直等待，导致线程卡死。因此必须成双成对


import java.util.concurrent.Exchanger;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
 public class ExchangerTest {
 
   private static final Exchanger<String> exgr = new Exchanger<String>();
 
     private static ExecutorService threadPool = Executors.newFixedThreadPool(2);
 
     public static void main(String[] args) {
 
         threadPool.execute(new Runnable() {
           @Override
            public void run() {
                 try {
                     String A = "银行流水A";// A录入银行流水数据
                     String o=exgr.exchange(A);
                     System.out.println(o);
                 } catch (InterruptedException e) {
                 }
             }
        });
 
         threadPool.execute(new Runnable() {
            @Override
             public void run() {
                 try {
                     String B = "银行流水B";// B录入银行流水数据
                     String A = exgr.exchange(B);
                     System.out.println("A和B数据是否一致：" + A.equals(B) + ",A录入的是："
                             + A + ",B录入是：" + B);
                 } catch (InterruptedException e) {
                 }
             }
         });

        threadPool.shutdown();

     }
 }

对象

import java.util.ArrayList;  
import java.util.List;  
import java.util.concurrent.Exchanger;  
  
public class ExchangerDemo {  
  
    public static void main(String[] args) {  
        final Exchanger<List<Integer>> exchanger = new Exchanger<List<Integer>>();  
        new Thread(){  
            public void run(){  
                List<Integer> list = new ArrayList<Integer>(2);  
                list.add(1);  
                list.add(2);  
                  
                try {  
                    list = exchanger.exchange(list);  
                } catch (InterruptedException e) {  
                    // TODO Auto-generated catch block  
                    e.printStackTrace();  
                }  
                System.out.println("thread1:" + list);  
            }  
        }.start();  
          
        new Thread(){  
            public void run(){  
                List<Integer> list = new ArrayList<Integer>(3);  
                list.add(3);  
                list.add(4);  
                list.add(5);  
                try {  
                    list = exchanger.exchange(list);  
                } catch (InterruptedException e) {  
                    // TODO Auto-generated catch block  
                    e.printStackTrace();  
                }  
                System.out.println("thread2:" + list);  
            }  
        }.start();  
          
    }  
}