- 浏览: 8368 次
- 性别:
- 来自: 上海
最新评论
设计线程安全的类需要
考虑哪些因素?
1) 找出哪些变量 属于对象的状态
2) 找出哪些不变量 属于对象的状态
3) 使用合适的并发策略来管理对状态的访问
考虑线程安全的需求
1) 同步范围多大? 整个方法? 一个大块? 小块?
2) 有哪些限制和先决条件?
java内建的监视器模型, 通过锁定, 即在锁对象添加监视器, 一旦锁定释放, 监视器通知其他等待的线程. Object.wait/notity/notifyAll
"代理"线程安全性
如果一个类合理的使用了一个已经实现线程安全的类, 就是把线程安全性交给内部对象"代理"了.
JDK提供一些线程安全的类, 如Vector, HashTable, ConcurrentHashMap, Collections.concurrentXXX(Obj) , BlockingQueue等. 例子:
public class DelegatingVehicleTracker {
private final ConcurrentMap<String, Point> locations;
private final Map<String, Point> unmodifiableMap;
public DelegatingVehicleTracker(Map<String, Point> points) {
locations = new ConcurrentHashMap <String, Point>(points);
unmodifiableMap = Collections.unmodifiableMap (locations);
}
public Map<String, Point> getLocations() {
return unmodifiableMap;
}
public Point getLocation(String id) {
return locations.get(id);
}
public void setLocation(String id, int x, int y) {
if (locations.replace(id, new Point(x, y)) == null)
throw new IllegalArgumentException(
"invalid vehicle name: " + id);
}
}
对于只有单个需要代理的对象, 可以很方便的应用上述的"代理"方式, 对于多个相互独立的对象而已, 也可以使用
public class VisualComponent {
private final List<KeyListener> keyListeners = new CopyOnWriteArrayList<KeyListener>();
private final List<MouseListener> mouseListeners = new CopyOnWriteArrayList<MouseListener>();
public void add(..);
public void remove(...);
}
但是如果这些对象有相互关系, 就出问题了
如何给线程安全的类增加方法
1) 修改源代码, 最好. 需了解原来的线程安全的策略
2) 继承类, 并增加synchronized方法.
3) 用Decorator模式, 把类包起来, 增加新方法, 然而需要注意锁定的对象. 比如下面是不对的
public class ListHelper<E> {
//锁定对象为返回的list
public List<E> list = Collections.synchronizedList(new ArrayList<E>());
...
public synchronized boolean putIfAbsent(E x) { //锁定对象为ListHelper对象
boolean absent = !list.contains(x);
if (absent)
list.add(x);
return absent;
}
}
因为两个同步的锁定不是同一个对象, 因此不同的线程可以分别操作putIfAbsent方法和list对象固有的方法. 如果要让这个类正确运行, 需要修正如下
public class ListHelper<E> {
//锁定对象为list
public List<E> list =Collections.synchronizedList(new ArrayList<E>());
...
public boolean putIfAbsent(E x) {
synchronized (list) { //锁定对象为list
boolean absent = !list.contains(x);
if (absent)
list.add(x);
return absent;
}
}
}
使用synchronized collection的原子性的问题
比如下面的代码:
另一种变通的方法是, 在遍历集合之前, 复制一份集合的引用. 当然集合复制也有细微的性能代价.
被隐藏的Iterator
JDK5的并发集合
ConcurrentMap (接口)和 ConcurrentHashMap, 并发环境下HashMap的替代品
CopyOnWriteArrayList, 并发环境下List的替代品
Queue: ConcurrentLinkedQueue , PriorityQueue(非并发) . 不阻塞, 如果队列为空, get()返回null
BlockingQueue: 它的方法是阻塞的, 当队列为空, get()会阻塞直到队列有元素加入, 当队列满脸, insert()也会阻塞
ConcurrentHashMap使用一种 lock striping 的机制来实现并发控制, 并且提供了弱一致性的Iterator, 允许在迭代期间被修改而不抛出ConcurrentModificationException(例 如,忽略被删除的元素). 然而作为代价, size()返回的值不是精确的元素的数量, 不过size()在并发环境的作用比get, put, containsKey的用途小得多
看一小段程序
ConcurrentHashMap<String, String> m = new ConcurrentHashMap<String, String>();
m.put("1", "one");
m.put("2", "two");
m.put("3", "three");
Iterator keyIt = m.keySet().iterator();
// !! remove some element, remove-if-equals 风格的操作
m.remove("1", "one");
while (keyIt.hasNext()) {
String k = (String)keyIt.next();
System.out.println("key: " + k + ", value: " + m.get(k));
}
输出结果:
key: 1, value: null
key: 3, value: three
key: 2, value: two
很短的代码, 一下执行完了, 没有再报错, 可以发现remove操作没有影响到遍历抛出异常. 然而, key: 1, value: null 这行输出说明了我们还留着对这个key的引用.
ConcurrentHashMap有几种新的风格的方法, put-if-absent, remove-if-equal, replace-if-equal, 比如上面的 m.remove("1", "one"); 就是, 如果改为 m.remove("1", "two"); 那么["1","one"]这一对就被保留下来了
CopyOnWriteArrayList, 顾名思义, 就能猜到每次都这个类做了改动, 就会copy一份原来的数组, 在改动后替换原来的数组, 再返回给调用者
BlockingQueue是基于 生产者-消费者 的模式构建的, 包括LinkedBlockingQueue, ArrayBlockingQueue, PriorityBlockingQueue,SynchronousQueue 4个实现类. 看一点示例代码:
public static void putAndOffer() throws InterruptedException {
BlockingQueue<String> q = new ArrayBlockingQueue<String>(1);
q.offer("1");
System.out.println("offer A done");
q.offer("2");
System.out.println("offer B done");
q.clear();
q.put("A");
System.out.println("put A done");
q.put("B");
System.out.println("put B done");
}
输出结果:
offer A done
offer B done
put A done
我们指定了BlockingQueue的容量为1, offer方法是不阻塞的, 所以q.offer("2");直接返回false, 而put方法是阻塞的, 所以System.out.println("put B done");一直没有执行.
PriorityBlockingQueue: 对于加入队列的元素是可排序的
SynchronousQueue : 不能算是queue的实现, 但是模仿了queue的行为, 更像是worker模式的实现. 因为它内部维护了一组用于处理元素的线程, 并且直接把加入队列的元素分配给处理该元素的线程. 如果没有可用线程, 就阻塞了.
BlockingQueue实例代码
下面是摘录的代码, 使用BlockingQueue, 分配N个线程执行文件索引的任务, 很经典:
1) 找出哪些变量 属于对象的状态
2) 找出哪些不变量 属于对象的状态
3) 使用合适的并发策略来管理对状态的访问
考虑线程安全的需求
1) 同步范围多大? 整个方法? 一个大块? 小块?
2) 有哪些限制和先决条件?
java内建的监视器模型, 通过锁定, 即在锁对象添加监视器, 一旦锁定释放, 监视器通知其他等待的线程. Object.wait/notity/notifyAll
"代理"线程安全性
如果一个类合理的使用了一个已经实现线程安全的类, 就是把线程安全性交给内部对象"代理"了.
JDK提供一些线程安全的类, 如Vector, HashTable, ConcurrentHashMap, Collections.concurrentXXX(Obj) , BlockingQueue等. 例子:
public class DelegatingVehicleTracker {
private final ConcurrentMap<String, Point> locations;
private final Map<String, Point> unmodifiableMap;
public DelegatingVehicleTracker(Map<String, Point> points) {
locations = new ConcurrentHashMap <String, Point>(points);
unmodifiableMap = Collections.unmodifiableMap (locations);
}
public Map<String, Point> getLocations() {
return unmodifiableMap;
}
public Point getLocation(String id) {
return locations.get(id);
}
public void setLocation(String id, int x, int y) {
if (locations.replace(id, new Point(x, y)) == null)
throw new IllegalArgumentException(
"invalid vehicle name: " + id);
}
}
对于只有单个需要代理的对象, 可以很方便的应用上述的"代理"方式, 对于多个相互独立的对象而已, 也可以使用
public class VisualComponent {
private final List<KeyListener> keyListeners = new CopyOnWriteArrayList<KeyListener>();
private final List<MouseListener> mouseListeners = new CopyOnWriteArrayList<MouseListener>();
public void add(..);
public void remove(...);
}
但是如果这些对象有相互关系, 就出问题了
public class NumberRange {
// INVARIANT: lower <= upper
private final AtomicInteger lower = new AtomicInteger(0);
private final AtomicInteger upper = new AtomicInteger(0);
public void setLower(int i) {
// Warning -- unsafe check-then-act
if (i > upper.get())
throw new IllegalArgumentException(
"can't set lower to " + i + " > upper");
lower.set(i);
}
public void setUpper(int i) {
// Warning -- unsafe check-then-act
if (i < lower.get())
throw new IllegalArgumentException(
"can't set upper to " + i + " < lower");
upper.set(i);
}
public boolean isInRange(int i) {
return (i >= lower.get() && i <= upper.get());
}
}
}
显然setLower, setUpper, isInRange三个方法的调用没有原子性保障, 而且isInRange同时依赖到两个相关的值,
很容易导致结果错误. 需要增加某些锁定来保证. 或者运行的情况下, 把两个对象合并为一个如何给线程安全的类增加方法
1) 修改源代码, 最好. 需了解原来的线程安全的策略
2) 继承类, 并增加synchronized方法.
3) 用Decorator模式, 把类包起来, 增加新方法, 然而需要注意锁定的对象. 比如下面是不对的
public class ListHelper<E> {
//锁定对象为返回的list
public List<E> list = Collections.synchronizedList(new ArrayList<E>());
...
public synchronized boolean putIfAbsent(E x) { //锁定对象为ListHelper对象
boolean absent = !list.contains(x);
if (absent)
list.add(x);
return absent;
}
}
因为两个同步的锁定不是同一个对象, 因此不同的线程可以分别操作putIfAbsent方法和list对象固有的方法. 如果要让这个类正确运行, 需要修正如下
public class ListHelper<E> {
//锁定对象为list
public List<E> list =Collections.synchronizedList(new ArrayList<E>());
...
public boolean putIfAbsent(E x) {
synchronized (list) { //锁定对象为list
boolean absent = !list.contains(x);
if (absent)
list.add(x);
return absent;
}
}
}
使用synchronized collection的原子性的问题
比如下面的代码:
public class VectorHelper{
public static Object getLast(Vector list) {
int lastIndex = list.size() - 1;
return list.get(lastIndex);
}
public static void deleteLast(Vector list) {
int lastIndex = list.size() - 1;
list.remove(lastIndex);
}
}
非常简单, 很多代码都是这样写的, 但是, 这段代码如果要正常运行, 必须是在假设Vertor对象是不被多个线程共享的情况下.
因为虽然Vector本身是线程安全的, 但VectorHelper不是,
并且getLast和deleteLast同时依赖于Vector.size()来判断最后一个元素. 很容易造成ArrayIndexOutOfBoundsException.
如果Vector被多个线程共享, 最简单的就是加上同步, 然后对一个集合的同步会带来很大的性能代价, 因为阻止了其他线程对集合的访问,
特别是当集合很大并且处理的任务非常大的情况下. 另一种变通的方法是, 在遍历集合之前, 复制一份集合的引用. 当然集合复制也有细微的性能代价.
被隐藏的Iterator
public class HiddenIterator {
@GuardedBy("this")
private final Set<Integer> set = new HashSet<Integer>();
public synchronized void add(Integer i) { set.add(i); }
public synchronized void remove(Integer i) { set.remove(i); }
public void addTenThings() {
Random r = new Random();
for (int i = 0; i < 10; i++)
add(r.nextInt());
System.out.println("DEBUG: added ten elements to " + set);
}
}
能想象这么简单的代码会在什么地方出错么? 答案是最后一行, System.out.println,
因为用到的set.toString(), 而toString()内部是会用Iterator来访问set的, 一旦此过程中set被修改, 就抛出
ConcurrentModificationException
.JDK5的并发集合
ConcurrentMap (接口)和 ConcurrentHashMap, 并发环境下HashMap的替代品
CopyOnWriteArrayList, 并发环境下List的替代品
Queue: ConcurrentLinkedQueue , PriorityQueue(非并发) . 不阻塞, 如果队列为空, get()返回null
BlockingQueue: 它的方法是阻塞的, 当队列为空, get()会阻塞直到队列有元素加入, 当队列满脸, insert()也会阻塞
ConcurrentHashMap使用一种 lock striping 的机制来实现并发控制, 并且提供了弱一致性的Iterator, 允许在迭代期间被修改而不抛出ConcurrentModificationException(例 如,忽略被删除的元素). 然而作为代价, size()返回的值不是精确的元素的数量, 不过size()在并发环境的作用比get, put, containsKey的用途小得多
看一小段程序
ConcurrentHashMap<String, String> m = new ConcurrentHashMap<String, String>();
m.put("1", "one");
m.put("2", "two");
m.put("3", "three");
Iterator keyIt = m.keySet().iterator();
// !! remove some element, remove-if-equals 风格的操作
m.remove("1", "one");
while (keyIt.hasNext()) {
String k = (String)keyIt.next();
System.out.println("key: " + k + ", value: " + m.get(k));
}
输出结果:
key: 1, value: null
key: 3, value: three
key: 2, value: two
很短的代码, 一下执行完了, 没有再报错, 可以发现remove操作没有影响到遍历抛出异常. 然而, key: 1, value: null 这行输出说明了我们还留着对这个key的引用.
ConcurrentHashMap有几种新的风格的方法, put-if-absent, remove-if-equal, replace-if-equal, 比如上面的 m.remove("1", "one"); 就是, 如果改为 m.remove("1", "two"); 那么["1","one"]这一对就被保留下来了
CopyOnWriteArrayList, 顾名思义, 就能猜到每次都这个类做了改动, 就会copy一份原来的数组, 在改动后替换原来的数组, 再返回给调用者
BlockingQueue是基于 生产者-消费者 的模式构建的, 包括LinkedBlockingQueue, ArrayBlockingQueue, PriorityBlockingQueue,SynchronousQueue 4个实现类. 看一点示例代码:
public static void putAndOffer() throws InterruptedException {
BlockingQueue<String> q = new ArrayBlockingQueue<String>(1);
q.offer("1");
System.out.println("offer A done");
q.offer("2");
System.out.println("offer B done");
q.clear();
q.put("A");
System.out.println("put A done");
q.put("B");
System.out.println("put B done");
}
输出结果:
offer A done
offer B done
put A done
我们指定了BlockingQueue的容量为1, offer方法是不阻塞的, 所以q.offer("2");直接返回false, 而put方法是阻塞的, 所以System.out.println("put B done");一直没有执行.
PriorityBlockingQueue: 对于加入队列的元素是可排序的
SynchronousQueue : 不能算是queue的实现, 但是模仿了queue的行为, 更像是worker模式的实现. 因为它内部维护了一组用于处理元素的线程, 并且直接把加入队列的元素分配给处理该元素的线程. 如果没有可用线程, 就阻塞了.
BlockingQueue实例代码
下面是摘录的代码, 使用BlockingQueue, 分配N个线程执行文件索引的任务, 很经典:
public class FileCrawler implements Runnable { //这个是producer角色 private final BlockingQueue<File> fileQueue ; private final FileFilter fileFilter; private final File root; ... public FileCrawler(File root, BlockingQueue queue, FileFilter filter){ ... } public void run() { try { crawl(root); } catch (InterruptedException e) { Thread.currentThread().interrupt(); } } /*把该目录下所有的文件夹都放进一个queue, 如果满了, 就阻塞*/ private void crawl(File root) throws InterruptedException { File[] entries = root.listFiles(fileFilter); if (entries != null) { for (File entry : entries) if (entry.isDirectory()) crawl(entry); else if (!alreadyIndexed(entry)) fileQueue.put(entry) ; //把找到的目录放入队列 } } } public class Indexer implements Runnable { //这个是consumer角色 private final BlockingQueue<File> queue; public Indexer(BlockingQueue<File> queue ) { // queue在indexer和FileCrawler之间共享 this.queue = queue; } public void run() { try { while (true) indexFile(queue.take()); //从queue中获取一个File对象进行索引 } catch (InterruptedException e) { Thread.currentThread().interrupt(); } } }
//这个是客户端的方法, 可以假设roots是在界面设置的几个目录 public static void startIndexing(File[] roots) {
BlockingQueue<File> queue = new LinkedBlockingQueue<File>(BOUND); FileFilter filter = new FileFilter() { public boolean accept(File file) { return true; } }; for (File root : roots) new Thread(new FileCrawler(queue , filter, root)).start(); //此处是否可以考虑使用线程池更有效? 而且, 如果有些目录层次非常深, //就会有某些线程运行时间非常长, 相反有些线程非常快就执行完毕. //最恶劣的情况是可能其他线程都完成了, 而退化到只有一个线程中运行, //成为"单线程"程序? for (int i = 0; i < N_CONSUMERS; i++) new Thread(new Indexer(queue )).start(); //此处是否可以考虑使用线程池更有效? } 基于上述这种"单线程"的考虑, 不谋而合的, JDK6引入了一种"Work Stealing"的模式, 即N个线程中运行, 每个线程处理自己的事情, 一旦自己手头的事情处理, 那么就去尝试"偷"来其他线程的任务来运行. 这样一来, 系统就会时刻保持多个线程中处理任务, 而不是出现"一人忙活,大家凉快"的情况
发表评论
-
list map set及所有子类 区别与使用总结
2010-08-25 20:51 1358括号为是否线程安全 list: LinkedList(no) ... -
一个关于Java Thread wait(),notify()的实用例
2010-08-25 20:46 906///// // ProducerConsumer.j ... -
Java线程:线程状态的转换
2010-08-25 19:44 665转自:http://lavasoft.blog.51cto.c ... -
集合类(Collection) List/Set/Map... 的区别和联系
2010-08-11 09:55 926关键字: 集合类 Collection ... -
并发集合类 ConcurrentHashMap 和 CopyOnWriteArrayList(转)
2010-08-10 19:25 788在Java类库中出现的第 ...
相关推荐
spring boot 通过任务执行器 taskexecutor 来实现多线程和并发编程。下面这篇文章主要给大家介绍了关于spring boot中多线程开发的注意事项,文中通过示例代码介绍的非常详细,需要的朋友可以参考下
书中以muduo网络库为例,讲解这种编程模型的使用方法及注意事项。 《Linux多线程服务端编程:使用muduo C++网络库》的宗旨是贵精不贵多。掌握两种基本的同步原语就可以满足各种多线程同步的功能需求,还能写出更...
本书主要讲述采用现代C++在x86-64 Linux上编写多线程TCP网络服 务程序的主流常规技术, 这也是我对过去5年编写生产环境下的多线程 服务端程序的经验总结。 本书重点讲解多线程...解这种编程模型的使用方法及注意事项
10) Interrupt()注意事项 16 三. 线程之间协作 17 1)演示简单的消费者和生产者的例子: 17 2)管道的读写流处理方式 19 3)重要的演示死锁的问题—哲学家就餐问题 20 4)终止多线程程序的两种方式(轮询访问变量和...
多线程文件备份源码 项目描述 ...注意事项:备份完成后打包步骤需要安装压缩包运行软件,否则将打包失败. 所以需要先安装压缩包,安装文件为:wrar401sc.exe 双击即可安装 欢迎感兴趣的用户下载学习。
本书以muduo 网络库为例,讲解这种编程模型的使用方法及注意事项。 本书的宗旨是贵精不贵多。掌握两种基本的同步原语就可以满足各种多线程同步的功能需求,还能写出更易用的同步设施。掌握一种进程间通信方式和一种...
本书以 muduo 网络库为例,讲解这种编程模型的使用方法及注意事项。 本书的宗旨是贵精不贵多。掌握两种基本的同步原语就可以满足各种多线程同步的功能需求,还能写出更易用的同步设施。掌握一种进程间通信方式和一种...
Java 与C# 是现扣今网络开发的两大主要平台,而多线程编程则是进行并行处理计算中的基础,本文主要阐述了在Java 与C#开发平台下如何进行多线程编程的方法及注意事项,并且比较和分析两种开发平台下进行多线程编程的...
iphone多线程开发指导文档。讲述线程的使用,多线程的同步,线程开发的注意事项等等。
本书主要讲述采用现代C++ 在x86-64 Linux 上编写多线程TCP 网络服务程序的主流常规技术,重点讲解一种适应性较强的多线程服务器的编程模型,即one loop per thread。这是在Linux 下以native 语言编写用户态高性能...
《Linux多线程服务端编程:使用muduo C++网络库》主要讲述采用现代C++在x86-64 Linux上编写多线程TCP网络服务程序的主流常规技术,重点讲解一种适应性较强的多线程服务器的编程模型,即one loop per thread。...
C#多线程系列教程。对多线程的原理,开发流程,关键点及注意事项有详细的解说。想学习多线程开发的程序员们可以阅读。
并结合作者多年工作经历的相关实战案例,介绍了多线程环境下常用设计模式的来龙去脉:各个设计模式是什么样的及其典型的实际应用场景、实际应用时需要注意的事项以及各个模式的可复用代码实现。 《Java多线程编程...
本书主要讲述采用现代C++ 在x86-64 Linux 上编写多线程TCP 网络服务程序的主流常规技术,重点讲解一种适应性较强的多线程服务器的编程模型,即one loop per thread。这是在Linux 下以native 语言编写用户态高性能...
主要讲解了目前高性能服务器的高并发和大流量应对的服务端开发注意事项。
三、注意事项 1、开发环境为Visual Studio 2010,使用.net 2.0 C#开发。 2、跳转到第几页功能:在页码文本框中输入页码,按回车键即可跳转。 2、项目结构。解决方案DotNet.WinFormPager包含2个项目,主要功能如下...
多线程摇号源码 源码描述: 一、源码特点 一款非常简单的多线程摇号源码,适合初学者学习使用,有需要的朋友不要错过 二、注意事项 开发环境为Visual Studio 2010,使用.net 4.0开发。
Winform多线程处理实例源码 一、源码描述 1、我们在用C# 开发程序时,经常会使用的多线程,实现多任务的处理。...二、注意事项 1、开发环境为Visual Studio 2012,无数据库,使用.net 3.0开发。
一、源码特点 1、功能强大,可以查询数据增删改,操作xml文件的读写,线程,画图,坐标等等功能 ...二、菜单功能 1、喷印控制 2、喷印资料 ...三、注意事项 开发环境为Visual Studio 2010,使用.net 4.0开发。
AriaNg多线程下载工具是一款智能路由上bt、pt程序Aria2的前端,使用纯html & javascript开发,无需任何编译器或运行环境即可运行,您只要将AriaNg放在您的Web服务器里并在浏览器中打开即可使用,软件使用响应式布局...