码迷,mamicode.com
首页 > 编程语言 > 详细

[Java 并发编程实战] 设计线程安全的类的三个方式(含代码)

时间:2018-06-02 11:27:25      阅读:158      评论:0      收藏:0      [点我收藏+]

标签:java并发编程   线程安全   同步      

发奋忘食,乐以忘优,不知老之将至。———《论语》

前面几篇已经介绍了关于线程安全和同步的相关知识,那么有了这些概念,我们就可以开始着手设计线程安全的类。本文将介绍构建线程安全类的几个方法,并说明他的区别。

我要讲的这几个构建线程安全类的方式是:

  1. 实例封闭。

  2. 线程安全性的委托。

  3. 现有的线程安全类添加功能。

另外,在设计线程安全类的过程中,我们需要考虑下面三个基本要素,遵循这三个步骤:

  • 找出构成对象状态的所有变量。

  • 找出约束状态变量的不变性条件。

  • 建立对象状态的并发访问策略。

以上,就是这篇文章主要讲解的内容,下面章节分三个构建方法逐步展开说明,逐个分析,并附上自己测试过的实例代码,确保这篇文章分享的内容是经过验证的。

实例封闭

意思是将数据封装在对象内部,它将数据的访问限制在对象的方法上,从而更容易确保线程在访问数据时总能持有正确的锁。当一个非线程安全对象被封装到另一对象中时,能够访问被封装对象的所有代码路径都是已知的。这和在整个程序中直接访问非线程对象相比,更易于对代码进行分析。下面代码清单就是一个实例封闭的例子:

 1import java.util.ArrayList;
2
3//ThreadSafe
4public class PointList{
5
6    //非线程安全对象 myList
7    private final ArrayList<SafePoint> myList = new ArrayList<SafePoint>();
8
9    //所有访问 myList 的方法都是用同步锁,确保线程安全
10    public synchronized void addPoint(SafePoint p) {
11        myList.add(p);
12    }
13    //所有访问 myList 的方法都是用同步锁,确保线程安全
14    public synchronized boolean containsPoint(SafePoint p) {
15        return myList.contains(p);
16    }
17    //所有访问 myList 的方法都是用同步锁,确保线程安全
18    //发布SafePoint
19    public synchronized SafePoint getPoint(int i) {
20        return myList.get(i);
21    }
22
23    //ThreadSafe(可发布的可变线程安全对象)
24    class SafePoint{
25        private int x;
26        private int y;
27
28        private SafePoint(int[] a) {this(a[0], a[1]);}
29
30        public SafePoint(SafePoint p) {this(p.get());}
31
32        public SafePoint(int x, int y) {
33            this.x = x;
34            this.y = y;
35        }
36        //使用同步锁,确保线程安全
37        public synchronized int[] get() {
38            return new int[] {x, y};
39        }
40        //使用同步锁,确保线程安全
41        public synchronized void set(int x, int y) {
42            this.x = x;
43            this.y = y;
44        }
45    }
46}

PointList 的状态由 ArrayList 来管理,但是 ArrayList 并非线程安全的。由于 ArrayList 私有并且不会逸出,因此 ArrayList 被封闭在 PointList 中。唯一能够访问 ArrayList 的路径都上同步锁了,也就是说 ArrayList 的状态完全有 PointList 内置锁保护,因而 PointList 是一个线程安全的类。Point 类的安全性放到后面讨论。

从这里例子可以看出,实例封闭可以非常简单的构建出线程安全的类。封闭机制更易于构造线程安全的类,因为当封闭类的状态时,在分析类的线程安全性时就无需检查整个程序。当然,如果将一个本该封闭的对象发布出去,那么也会破坏封闭性。

线程安全性的委托

如果类中的各个状态已经是线程安全的,那么是否需要再增加一个线程安全层的封装呢?
具体问题具体分析,这种需要视情况而定。

1) 如果各个状态变量是相互独立的并且互不依赖,并且没有复合操作,那么可以将线程安全性委托给底层的状态变量。如将安全性委托给 value:

1import java.util.concurrent.atomic.AtomicInteger;
2
3public class SafeSequene{
4    private value = new AtomicInteger(0);
5    //返回一个唯一的数值
6    public synchronized int getNext(){
7        return value.incrementAndGet();
8    }
9}

2) 如果各个状态变量之间存在依赖关系,并且存在复合操作,那么是非线程安全的。来看下面一个例子,NumberRange 这个类的各个状态组成部分都是线程安全的,但是存在状态之间的依赖关系,并非互相独立,所以也是非线程安全的。

 1import java.util.concurrent.atomic.AtomicInteger;
2
3public class NumberRange{
4
5    //不变性条件:lower <= upper
6    private final AtomicInteger lower = new AtomicInteger(0);//线程安全类
7    private final AtomicInteger upper = new AtomicInteger(0);//线程安全类
8
9    private static boolean flag = true;
10
11    private static volatile boolean stopAllThread = false; //检测到无效状态,停止所有线程并输出,此时lower > upper
12
13    private static int count = 3; //非线程安全,但是不必理会,不影响我们测试
14
15    //检查然后更新
16    public void setLower(int i) {
17        if(i <= upper.get()) { //lower依赖upper的值,有可能upper的值已经失效
18            lower.set(i);
19        }
20    }
21
22    //检查然后更新
23    public void setUpper(int i) {
24        if(i >= lower.get()) { //upper依赖lower的值,有可能lower的值已经失效
25            upper.set(i);
26        }
27    }
28
29    public static void main(String[] args) {
30
31
32        NumberRange nr = new NumberRange();
33        while(stopAllThread == false) {
34            for(int i = 0; i < 10000; i++) {
35
36                if(stopAllThread == true)
37                    break;
38
39                new Thread(new Runnable() {
40                    @Override
41                    public void run() {
42
43                        if(stopAllThread == true)
44                            return;
45
46                        if(flag == true)
47                        {
48                            flag = false;
49                            nr.setLower(count++);
50                        }
51                        else {
52                            flag = true;
53                            nr.setUpper(count);
54                        }
55                        if(nr.lower.get() > nr.upper.get()) //检测到无效状态,lower > upper
56                        {
57                            stopAllThread = true;
58                            System.out.println("state wrong");//打印错误信息
59                            System.out.println("lower = " + nr.lower.get() + " upper = " + nr.upper.get());
60                        }
61                    }
62                }).start();
63            }
64            while(Thread.activeCount() > 1);
65            System.out.println("lower = " + nr.lower.get() + " upper = " + nr.upper.get());
66        }
67    }
68}

在上面的程序中,并发的情况下我们可以检测到无效状态,即 upper 的值大于 lower 的值。这便是不满足我们的不变性条件,因为状态变量 lower 和 upper 不是彼此独立的,因此 NumberRange 不能将线程安全委托给他的线程安全状态变量。输出如下:

技术分享图片这里写图片描述

3) 如何安全的发布底层的状态变量?
如果一个状态变量是线程安全的,并且没有任何不变性条件来约束他的值,在变量操作上也不存在任何不允许的状态转换,那么就可以安全的发布这个变量。在示例封闭的代码清单中,SafePoint 是一个可变的且线程安全的类,我们可以安全的发布它。

现有的线程安全类添加功能

Java 的类库中,已经包含了很多线程安全的基础模块。通常,我们可以直接拿来重用,并不需要重复造轮子。重用已有的类库,可以有效降低开发的工作量,开发风险以及维护成本。下面将讲解三种方式来增加新方法,组合方式将是最优的方法。我们应当避免使用前两种方式,而所用最后一种方式。

通过继承基类添加功能(扩展类方式)

假设,我们需要对 Vector 扩展,添加一个[若没有则添加]的操作。我们想到的最直接的方法应该是修改原始类,但是通常是无法做到的,因为我们极有可能没法访问或修改类的源代码。

现在采用另一种方式,通过继承基类的方式扩展这个类并添加一个新方法 putIfAbsent。如下所示:

 1import java.util.Vector;
2//ThreadSafe
3public class BetterVector<E> extends Vector<E>{
4    public synchronized boolean putIfAbsent(E x) {
5        boolean absent = !contains(x);
6        if(absent)
7            add(x);
8        return absent;
9    }
10}

这样就可以成功添加一个新的方法。然而,这比直接在基类代码增加新方法更加脆弱,因为现在的同步策略被分布到多个源码文件中。如果底层的类修改了同步策略并选择不同的锁来保护,那么子类将会失效,不能保证线程安全。

客户端加锁机制

同样,来增加一个新方法 putIfAbsent,请看下面代码:

 1import java.util.ArrayList;
2import java.util.Collections;
3import java.util.List;
4
5public class ListHelper<E> {
6
7    public List<E> list = Collections.synchronizedList(new ArrayList<>());
8    //无效的同步锁
9    public  synchronized boolean putIfAbsent(E x) {
10        boolean absent = !list.contains(x);
11        if(absent)
12            list.add(x);
13        return absent;
14    }  
15}

这种方式并不能实现线程安全,它的问题在于同步的时候使用了错误的锁。因为 List 本身用的锁肯定不是 ListHelper 上的锁,这意味着 putIfAbsent 相对于其他 List 的方法来说并不是同步的。所以看起来同步了实际上却没有什么卵用。

要使这个方法能够正确同步,必须在客户端加锁。即对于使用某个对象 X 的客户端代码,使用 X 本身用于保护其状态的锁来保护这段客户代码。要使用客户端加锁,你必须知道对象 X 使用的是哪个锁。

在 Vector 和同步封装器的文档中指出,他们通过使用 Vector 或封装器容器的内置锁来支持客户端加锁。上面代码可以改成如下:

 1import java.util.ArrayList;
2import java.util.Collections;
3import java.util.List;
4
5public class ListHelper<E> {
6
7    public List<E> list = Collections.synchronizedList(new ArrayList<>());
8
9    public  boolean putIfAbsent(E x) {
10        synchronized(list) {//客户端加锁
11            boolean absent = !list.contains(x);
12            if(absent)
13                list.add(x);
14            return absent;
15        }
16    }  
17}

客户端加锁方式是很脆弱的加锁方式,意味他将类 C 的加锁代码放到与 C 完全无关的其他类中。所以在使用客户端加锁时,需要特别小心。

客户端加锁机制和扩展类机制有许多共同点,二者都是讲派生类的行为与基类的实现耦合在一起,会破坏实现的封装性和同步策略的封装性。

组合

相比前面两种机制,这是一种更好的方法。如下所示,ImprovedList 将 List 的操作委托给底层的 List 对象,然后自己继承 List 接口的所有方法并对他们加上同步锁。

 1import java.util.Collection;
2import java.util.Iterator;
3import java.util.List;
4import java.util.ListIterator;
5
6public class ImprovedList<T> implements List<T>{
7
8    private final List<T> list;
9
10    public ImprovedList(List<T> list) {
11        this.list = list;
12    }
13
14    //同步方法
15    public synchronized boolean putIfAbsent(T x) {
16        boolean contains = list.contains(x);
17        if(!contains)
18            list.add(x);
19        return contains;
20    }
21
22    @Override
23    public synchronized boolean add(T arg0) {
24        list.add(arg0);
25        return false;
26    }
27
28    @Override
29    public synchronized void clear() {
30        // TODO Auto-generated method stub
31        list.clear();
32    }
33
34    //按照此同步方式实现其他方法
35
36}

ImprovedList 增加了一层自身的内置锁,它不用关心底层的 List 是否线程安全或者底层 List 修改了他自己的加锁实现,ImprovedList 都能构提供一致的加锁机制来实现线程安全性。当然,加多一层锁会导致性能损失,但是 ImprovedList 相比前面两种方式也更加健壮。

上面就是构建安全类的所有内容,希望对你有所帮助,谢谢!!可以关注我公众号!

本文原创首发于微信公众号 [ 林里少年 ],欢迎关注第一时间获取更新。

技术分享图片


[Java 并发编程实战] 设计线程安全的类的三个方式(含代码)

标签:java并发编程   线程安全   同步      

原文地址:http://blog.51cto.com/13760461/2123390

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!