1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
@ThreadSafe
public
class
PersonSet {
@GuardedBy
(
"this"
)
private
final
Set<Person> mySet =
new
HashSet<Person>();
public
synchronized
void
addPerson(Person p) {
mySet.add(p);
}
public
synchronized
boolean
containsPerson(Person p) {
return
mySet.contains(p);
}
interface
Person {
}
}
|
1 2 3 4 5 6 7 8 9 10 |
public
class
PrivateLock {
private
final
Object myLock =
new
Object();
@GuardedBy
(
"myLock"
) Widget widget;
void
someMethod() {
synchronized
(myLock) {
// Access or modify the state of widget
}
}
}
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 |
@NotThreadSafe
class
BadListHelper <E> {
public
List<E> list = Collections.synchronizedList(
new
ArrayList<E>());
public
synchronized
boolean
putIfAbsent(E x) {
//内置锁对于客户端来讲是不同的
boolean
absent = !list.contains(x);
if
(absent)
list.add(x);
return
absent;
}
}
@ThreadSafe
class
GoodListHelper <E> {
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;
}
}
}
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
@ThreadSafe
public
class
ImprovedList<T>
implements
List<T> {
private
final
List<T> list;
/**
* PRE: list argument is thread-safe.
*/
public
ImprovedList(List<T> list) {
this
.list = list; }
public
synchronized
boolean
putIfAbsent(T x) {
boolean
contains = list.contains(x);
if
(contains)
list.add(x);
return
!contains;
}
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 |
public
class
TaskRunnable
implements
Runnable {
BlockingQueue<Task> queue;
public
void
run() {
try
{
processTask(queue.take());
}
catch
(InterruptedException e) {
// restore interrupted status
Thread.currentThread().interrupt();
}
}
void
processTask(Task task) {
// Handle the task
}
interface
Task {
}
}
|
更多推荐
java并发编程实战学习笔记之对象的组合与基础构建模块
发布评论