装饰者模式-包装线程不安全的类

程序员小潘

于 2021-01-08 07:38:46 发布

阅读量562

点赞数

分类专栏：设计模式文章标签：设计模式

本文链接：https://blog.csdn.net/qq_32099833/article/details/112301657

版权

设计模式专栏收录该内容

25 篇文章 4 订阅

订阅专栏

1. 包装线程不安全的类

集合容器应该是程序员使用最频繁的工具类了，需要注意的是，大家平常使用的大部分容器都是线程不安全的，例如ArrayList、HashMap等，如果涉及到对容器的并发访问，开发者需要做好同步控制，否则程序会出现异常。
当然了，你也完全可以选择使用J.U.C包下提供的线程安全的集合容器，但是我们今天不讨论这个，而是换一个思路，看看如何通过「装饰者模式」来巧妙的将一个线程不安全的类包装成线程安全的。

本文会以List列表举例，但由于JDK提供的List接口太复杂，因此这里不用JDK提供的，而是自己手写实现一个，功能会做精简，旨在理解装饰者模式的思想。

程序的整体类图如下：
在这里插入图片描述
编写List接口，定义列表具有的功能：

public interface List<E> {

	// 添加元素
	void add(E e);

	// 删除元素
	E remove(int index);

	// 获取元素
	E get(int index);

	// 元素个数
	int size();
}

基于数组的ArrayList实现类：

NotThreadSafe
public class ArrayList<E> implements List<E> {
	private Object[] table = new Object[1 << 4];//初始容量
	private int size;

	@Override
	public void add(E e) {
		table[size++] = e;
		if (size >= table.length) {
			// 扩容
			Object[] newTable = new Object[table.length << 1];
			System.arraycopy(table, 0, newTable, 0, table.length);
			table = newTable;
		}
	}

	@Override
	public E remove(int index) {
		E oldValue = (E) table[index];
		int numMoved = size - index - 1;
		if (numMoved > 0)
			System.arraycopy(table, index + 1, table, index, numMoved);
		table[--size] = null;
		return oldValue;
	}

	@Override
	public E get(int index) {
		if (index >= size) {
			throw new IndexOutOfBoundsException("size:" + size + ",index:" + index);
		}
		return (E) table[index];
	}

	@Override
	public int size() {
		return size;
	}

	@Override
	public String toString() {
		StringJoiner sj = new StringJoiner(",");
		for (int i = 0; i < size; i++) {
			sj.add(table[i].toString());
		}
		return "{" + sj + "}";
	}
}

客户端这样调用：

public class Client {
	public static void main(String[] args) throws IOException {
		List list = new ArrayList();
		list.add(1);
		list.add(2);
		list.add(3);
		System.out.println(list);
	}
}
输出:
{1,2,3}

非常简单，功能也正常，但是有一个问题，ArrayList的实现是线程不安全的，如果有多个线程并发访问列表，程序可能会抛异常。
例如多线程并发add()时，如果线程A在扩容期间，线程B也要调用add()插入元素，就会导致数组下标越界，程序抛出异常，如下：

public class Client {
	public static void main(String[] args) throws IOException {
		List list = new ArrayList();
		for (int i = 0; i < 10; i++) {
			new Thread(()->{
				for (int k = 0; k < 1000; k++) {
					list.add(k);
				}
			}).start();
		}
	}
}
输出:
Exception in thread "Thread-0" Exception in thread "Thread-1" Exception in thread "Thread-3" Exception in thread "Thread-4" java.lang.ArrayIndexOutOfBoundsException: 2048
	at top.javap.dp.unit11.decorator.ArrayList.add(ArrayList.java:19)
	at top.javap.dp.unit11.decorator.Client.lambda$main$0(Client.java:16)
	at java.lang.Thread.run(Thread.java:748)
......

如果现在需要一个线程安全的列表容器，需要怎么做呢？修改ArrayList代码？加上synchronized关键字？
首先，修改源码这违反了「开闭原则」，其次，不是所有的地方都需要线程安全的容器，同步会影响性能，如果系统又需要一个不安全的列表容器，你又要怎么做？

「对扩展开放，对修改关闭」，我们能否再派生一个List子类，来对原List对象做一个装饰，让其所有的操作都串行化执行，具备同步的性质呢？答案是：当然可以！

主角登场，SynchronizedList，List的装饰者

@ThreadSafe
public class SynchronizedList<E> implements List<E> {
	private final List<E> list;

	public SynchronizedList(List<E> list) {
		this.list = list;
	}

	@Override
	public synchronized void add(E e) {
		this.list.add(e);
	}

	@Override
	public synchronized E remove(int index) {
		return this.list.remove(index);
	}

	@Override
	public synchronized E get(int index) {
		return this.list.get(index);
	}

	@Override
	public synchronized int size() {
		return this.list.size();
	}

	@Override
	public synchronized String toString() {
		return this.list.toString();
	}
}

客户端这样调用：

public class Client {
	public static void main(String[] args) throws IOException {
		// 装饰原ArrayList对象
		List list = new SynchronizedList(new ArrayList());
		list.add(1);
		list.add(2);
		list.add(3);
		System.out.println(list);
	}
}
输出:
{1,2,3}