JDK中java.util.Collections类提供了一些方便的操作集合的方法。例如:
这些方法都是非线程安全的。在多线程环境下,假设一个线程正在对List进行排序,如果另一个线程同时从List中删除一个元素的话,很可能会导致异常发生。
如何修改上述的方法,使之线程安全呢?
在coding之前,我们必须了解有一下几个前提:
[list]
1. 作为一个类库,我们不能预料其他开发人员如何使用该方法。即,如果其他开发人员在未加锁的环境中修改作为参数传递进来的List,即使我们简单地对该对象加锁, 也不能保护该对象。
2. 如果对整个类或者实例加锁,成本太高,同时也无法解决问题1。
[/list]
因此,例如要编写一个线程安全的排序方法,首先,要排序的列表必须是线程安全的,比如List就不适合作为参数(无法确保其是synchronized的),而必须替换为Vector。即方法需要修改为:
其次,要保证排序操作不能被其他线程打断,即排序操作需要加锁:
这两个条件缺一不可。测试代码如下 (TestSyncParam.java):
执行结果如下:
[table]
|Start bubble sorting.Thread[main,5,main]|
|Trying to remove first element. - Thread[Thread-1,5,main]|
|Bubble sorting done.Thread[main,5,main]|
|Removed '2', size: 11 - Thread[Thread-1,5,main]|
[/table]
总之,多线程环境下,我不建议将共享资源作为方法参数。如果必须,则该资源对象必须线程安全,方法的实现同时需要避免死锁。
public static void reverse(List<?> list)
public static void shuffle(List<?> list)
public static <T extends Comparable<? super T>> void sort(List<T> list)
等。
这些方法都是非线程安全的。在多线程环境下,假设一个线程正在对List进行排序,如果另一个线程同时从List中删除一个元素的话,很可能会导致异常发生。
如何修改上述的方法,使之线程安全呢?
在coding之前,我们必须了解有一下几个前提:
[list]
1. 作为一个类库,我们不能预料其他开发人员如何使用该方法。即,如果其他开发人员在未加锁的环境中修改作为参数传递进来的List,即使我们简单地对该对象加锁, 也不能保护该对象。
2. 如果对整个类或者实例加锁,成本太高,同时也无法解决问题1。
[/list]
因此,例如要编写一个线程安全的排序方法,首先,要排序的列表必须是线程安全的,比如List就不适合作为参数(无法确保其是synchronized的),而必须替换为Vector。即方法需要修改为:
public <T> void sort(final Vector<T> list);
其次,要保证排序操作不能被其他线程打断,即排序操作需要加锁:
public <T> void sort(finalVector<T> list){
synchronized (list) {
//perform sorting on the list.
}
}
这两个条件缺一不可。测试代码如下 (TestSyncParam.java):
import java.util.Vector;
public class TestSyncParam {
public void sort(Vector<Integer> list) {
synchronized (list) {
System.out.println("Start bubble sorting." + Thread.currentThread());
for (int i = 0; i < list.size(); i++) {
for (int j = list.size() - 1; j > i; j--) {
if (list.get(j) < list.get(j - 1)) {
int tmp = list.get(j - 1);
list.set(j - 1, list.get(j));
list.set(j, tmp);
}
try {
// slow down to give other threads a chance to touch 'list'
Thread.sleep(50);
} catch (InterruptedException e) {
}
}
}
System.out.println("Bubble sorting done." + Thread.currentThread());
}//end of sync
}
public static void main(String[] args) {
int[] ii = new int[] { 12, 5, 18, 3, 50, 34, 4, 8, 11, 3, 25, 2 };
final Vector<Integer> list = new Vector<Integer>();
for (int i : ii)
list.add(i);
Runnable r1 = new Runnable() {
public void run() {
try {
Thread.sleep(100);
} catch (InterruptedException e) {
}
System.out.println("Trying to remove first element. - " + Thread.currentThread());
Integer i = list.remove(0);
System.out.println("Removed '" + i + "', size: "+list.size()+" - " + Thread.currentThread());
}
};
TestSyncParam tsp = new TestSyncParam();
new Thread(r1).start();
tsp.sort(list);
}
}
执行结果如下:
[table]
|Start bubble sorting.Thread[main,5,main]|
|Trying to remove first element. - Thread[Thread-1,5,main]|
|Bubble sorting done.Thread[main,5,main]|
|Removed '2', size: 11 - Thread[Thread-1,5,main]|
[/table]
总之,多线程环境下,我不建议将共享资源作为方法参数。如果必须,则该资源对象必须线程安全,方法的实现同时需要避免死锁。