16、解决线程间协作问题的工具类Exchanger详解

傷城~ 2023-05-31 10:23 6阅读 0赞

在很久之前我曾写过一篇一篇文章介绍线程间如何进行通信的问题，当时使用的是等待通知模型，这篇文章介绍一个java提供的用于两个线程间通信的工具类Exchanger。

**一、概念理解**

Exchanger的作用就是为了两个线程之间交换数据，他提供了一个内部方法exchange，这个内部方法就好比是一个同步点，只有两个方法都到达同步点，才可以交换数据。我们换一张图来演示一波。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1NERERMTEw_size_16_color_FFFFFF_t_70]

也就是说只有线程A和线程B都到达同步点，才可以交换数据。

我们上代码直接看看如何使用，然后再去看看使用的时候需要注意什么。

**二、使用案例**

1、基本使用

首先我们定义一个测试类ExchangerTest：

public class ExchangerTest { 
    	private static Exchanger<String> exchanger = new Exchanger<>();
    	private static String threadA_data = "100块";
    	private static String threadB_data = "50块";
    	public static void main(String[] args) { 
    		new ThreadA(exchanger, threadA_data).start();
    		new ThreadB(exchanger, threadB_data).start();
    	}
    }

在这个类中，我们使用了ThreadA和ThreadB两个线程交换数据，然后我们定义了一个交换器Exchanger来交换。下面我们看看这俩线程是如何实现的。

public class ThreadA extends Thread { 
    	private Exchanger<String> exchanger = new Exchanger<>();
    	private String data = null;
    	public ThreadA(Exchanger<String> exchanger, String data) { 
    		this.exchanger = exchanger;
    		this.data = data;
    	}
    	@Override
    	public void run() { 
    		try { 
    			TimeUnit.SECONDS.sleep(3);
    			System.out.println("线程A交换前的数据是："+data);
    			data = exchanger.exchange(data);
    			System.out.println("线程A交换后的数据是："+data);
    		} catch (InterruptedException e) { 
    			e.printStackTrace();
    		}
    	}
    }

在这里我们主要是看run方法的实现，首先我们打印出交换之前的数据信息，然后使用交换器交换数据，最后再打印出交换之后的数据。由于ThreadB和ThreadA实现方式一样，在这里我们只给出一份代码即可。下面我们就可以运行一下，看看测试结果：

![在这里插入图片描述][20191024172154544.png]

现在我们看到，线程A和线程B就可以正常的进行交换了。通过这个案例我们会发现，Exchanger使用起来真的是超级简单。不过看起来很简单，其实还挖了很多的坑，下面我们来看看。

**注意点一：两个线程最终必须到达同步点**

这是什么意思呢？我们画一张图，举一个例子。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1NERERMTEw_size_16_color_FFFFFF_t_70 1]

上面这张图的意思是这个样子的，左边的线程还有20秒才可以到达同步点，但是右边的线程设置了超时时间，如果10秒钟后对方没有到达，那么这次交易就宣告失败。对于我们的程序来说也会出现异常。我们代码演示一下：

首先这次我们看右边的线程A：设置了超时时间为10秒

public class ThreadA extends Thread { 
    	private Exchanger<String> exchanger = new Exchanger<>();
    	private String data = null;
    	public ThreadA(Exchanger<String> exchanger, String data) { 
    		this.exchanger = exchanger;
    		this.data = data;
    	}
    	@Override
    	public void run() { 
    		try { 
    			TimeUnit.SECONDS.sleep(3);
    			System.out.println("线程A交换前的数据是："+data);
    			//线程A：设置超时时间为10秒，对应于右边的线程
    			data = exchanger.exchange(data,10,TimeUnit.SECONDS);
    			System.out.println("线程A交换后的数据是："+data);
    		} catch (InterruptedException | TimeoutException e) { 
    			e.printStackTrace();
    		}
    	}
    }

然后就是左边的线程B：还需要20秒才可以抵达

public class ThreadB extends Thread { 
    	private Exchanger<String> exchanger = new Exchanger<>();
    	private String data = null;
    	public ThreadB(Exchanger<String> exchanger, String data) { 
    		this.exchanger = exchanger;
    		this.data = data;
    	}
    	@Override
    	public void run() { 
    		try { 
    			//我还有20秒才可以抵达
    			TimeUnit.SECONDS.sleep(20);
    			System.out.println("线程B交换后的数据hashcode是："+data.hashCode());
    			data = exchanger.exchange(data);
    			System.out.println("线程B交换后的数据hashcode是："+data.hashCode());
    		} catch (InterruptedException e) { 
    			e.printStackTrace();
    		}
    	}
    }

现在我们再去测试一下看看会出现什么结果：

![在这里插入图片描述][20191024172215343.png]

我们发现线程A等待了10秒之后，线程B还没有到达，那就宣告交易失败。程序出现超时异常。

**注意点二：交换的线程必须成对出现**

这个注意点是什么意思呢？其实就是不能是单，就好比是找对象，最后总是成双成对的，要是5个男的4个女的，那剩下的一个男同胞怎么办，只能在那傻等了。这个我们也可以代码测试一下，只是新增了一个线程C。测试代码变一下：

public class ExchangerTest3 { 
    	private static Exchanger<String> exchanger = new Exchanger<>();
    	private static String threadA_data = "100块";
    	private static String threadB_data = "50块";
    	private static String threadC_data = "10块";
    	public static void main(String[] args) { 
    		new ThreadA(exchanger, threadA_data).start();
    		new ThreadB(exchanger, threadB_data).start();
    		new ThreadC(exchanger, threadC_data).start();
    	}
    }

此时我们再去测试，就会发现，总有一个线程处于死循环一直等待的状态。

![在这里插入图片描述][20191024172224435.png]  
**注意点三：多个线程交换数据**

上面我们提到了交换的线程配对之后不能落单，那么如果此时有多个成对的线程了，谁和谁配对呢？答案我们先告诉你，那就是胡乱配对。

在这里我们在注意点二的基础之上继续增加一个线程D，然后继续更改我们的测试类运行一下：

![在这里插入图片描述][20191024172233297.png]  
对于Exchanger的使用基本上需要注意的就是这么多。希望对你有帮助。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1NERERMTEw_size_16_color_FFFFFF_t_70 2]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1NERERMTEw_size_16_color_FFFFFF_t_70]: /images/20230531/bef62f3033cf44ed9bd4b919823bab08.png
[20191024172154544.png]: /images/20230531/88aef9d4102f42c0af286c0e565e98f9.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1NERERMTEw_size_16_color_FFFFFF_t_70 1]: /images/20230531/a58b2db5336a457ba95af384eb91641d.png
[20191024172215343.png]: /images/20230531/6172974d47af4c08a6ad5a16e6d7f966.png
[20191024172224435.png]: /images/20230531/7439fa22001b4a30b4447f98210c448e.png
[20191024172233297.png]: /images/20230531/1457bcd8aada48a4888dc5ede4f937e2.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1NERERMTEw_size_16_color_FFFFFF_t_70 2]: /images/20230531/9be58ca18d8c40f380c2b8e63b640e9a.png