可见性
eg.1 重排序现象
public class NoVisibility {
private static boolean ready;
private static int number;
private static class ReaderThread extends Thread {
public void run() {
while (!ready)
Thread.yield();
System.out.println(number);
}
}
public static void main(String[] args) {
new ReaderThread().start();
number = 42;
ready = true;
}
}
- 1.main线程将number设为42,read设为true
- 2.ReaderThread循环判断 ready,输出number的值
- 3.但是NoVisibility看起来会输出42,但事实上可能是0,也可能无法终止(这种现象称之为"重排序")
eg.2 数据失效
@NotThreadSafe
public class MutableInteger {
private int value;
public int get() {
return value;
}
public void set(int value) {
this.value = value;
}
}
- A、B两个线程,A set时 B同时在get,此时B可能读取到的值是更新前的也可能是更新后的;为此我们进行加锁改造
eg.2.1 蜜汁加锁
public class SynchronizedInteger {
@GuardedBy("this") private int value;
public synchronized int get() {
return value;
}
public synchronized void set(int value) {
this.value = value;
}
}
- 调用get仍然有可能会看见失效值
- 因为set get操作可能不是在同一个线程
Volatile变量
- 可见性。对一个volatile变量的读,总是能看到(任意线程)对这个volatile变量最后的写入。
- 原子性:对任意单个volatile变量的读/写具有原子性,但类似于volatile++这种复合操作不具有原子性。
基于volatile变量的特性,通常只需要对写入操作进行适当的加锁来控制并发
发布与逃逸
发布: 表示对象能够在当前作用域之外的代码中使用
- eg.3 错误的发布
class UnsafeStates {
private String[] states = new String[]{
"AK", "AL" /*...*/
};
public String[] getStates() {
return states;
}
}
任何调用者都能修改数组的内容,states对象已经逸出了他所在的作用域
- eg.4 this引用逃逸
public class ThisEscape {
public ThisEscape(EventSource source) {
source.registerListener(new EventListener() {
public void onEvent(Event e) {
doSomething(e);
}
});
}
void doSomething(Event e) {
}
interface EventSource {
void registerListener(EventListener e);
}
interface EventListener {
void onEvent(Event e);
}
interface Event {
}
}
当我们new ThisEscape对象的时候,该线程会持有doSomething的this引用,此时ThisEscape还没有实例完成(没有返回引用),导致this引用逸出
- eg.5 工厂方法防止this逸出
public class SafeListener {
private final EventListener listener;
private SafeListener() {
listener = new EventListener() {
public void onEvent(Event e) {
doSomething(e);
}
};
}
public static SafeListener newInstance(EventSource source) {
SafeListener safe = new SafeListener();
source.registerListener(safe.listener);
return safe;
}
void doSomething(Event e) {
}
interface EventSource {
void registerListener(EventListener e);
}
interface EventListener {
void onEvent(Event e);
}
interface Event {
}
}
线程封闭
当访问共享的可变数据时,通常需要使用同步.一种避免使用同步方式就是不共享数据.如果再单线程内访问数据,就不需要同步,这种技术被称之为线程封闭
Ad-hoc线程封闭(脆弱)
指维护线程封闭性的职责完全有程序实现来承担
栈封闭
只能通过局部变量才能访问对象
eg.7
public class Animals {
Ark ark;
Species species;
Gender gender;
public int loadTheArk(Collection<Animal> candidates) {
SortedSet<Animal> animals;
int numPairs = 0;
Animal candidate = null;
// animals confined to method, don't let them escape!
animals = new TreeSet<Animal>(new SpeciesGenderComparator());
animals.addAll(candidates);
for (Animal a : animals) {
if (candidate == null || !candidate.isPotentialMate(a))
candidate = a;
else {
ark.load(new AnimalPair(candidate, a));
++numPairs;
candidate = null;
}
}
return numPairs;
}
class Animal {
Species species;
Gender gender;
public boolean isPotentialMate(Animal other) {
return species == other.species && gender != other.gender;
}
}
enum Species {
AARDVARK, BENGAL_TIGER, CARIBOU, DINGO, ELEPHANT, FROG, GNU, HYENA,
IGUANA, JAGUAR, KIWI, LEOPARD, MASTADON, NEWT, OCTOPUS,
PIRANHA, QUETZAL, RHINOCEROS, SALAMANDER, THREE_TOED_SLOTH,
UNICORN, VIPER, WEREWOLF, XANTHUS_HUMMINBIRD, YAK, ZEBRA
}
enum Gender {
MALE, FEMALE
}
class AnimalPair {
private final Animal one, two;
public AnimalPair(Animal one, Animal two) {
this.one = one;
this.two = two;
}
}
class SpeciesGenderComparator implements Comparator<Animal> {
public int compare(Animal one, Animal two) {
int speciesCompare = one.species.compareTo(two.species);
return (speciesCompare != 0)
? speciesCompare
: one.gender.compareTo(two.gender);
}
}
class Ark {
private final Set<AnimalPair> loadedAnimals = new HashSet<AnimalPair>();
public void load(AnimalPair pair) {
loadedAnimals.add(pair);
}
}
}
new TreeSet引用保存在animals中,此时只有一个引用指向animals,该引用封闭在局部变量中,因此被封闭在执行线程中。如果发布了对animals的引用,就会造成逃逸。
ThreadLocal类
提供get和set方法,每个使用该变量的线程都存一份独立的副本,get总是返回当前执行线程在调用set时设置的最新值
-
ThreadLocal对象通常用于防止对可变的单实例变量或全局变量进行共享。
假设你需要将一个单线程应用程序移植到多线程环境中,通过将共享的全局变量转换为ThreadLocal对象(如果全局变量的语义允许),可以维持线程安全性。 -
ThreadLocal变量类似于全局变量,它能降低代码的可重用性,并在类之间引入隐含的耦合性,因此在使用时要格外小心。
不变性
- 1、对象创建完之后其状态就不能修改
- 2、对象的所有与都是 final 类型
- 3、对象时正确创建的(创建期间没有 this 的逸出)
安全发布
安全地发布一个对象,对象的应用以及对象的状态必须同时对其他线程可见。一个正确构造的对象可以通过以下方式来安全地发布:
- 1、在静态初始化函数中初始化一个对象引用
- 2、将对象的应用保存到volatile类型的域或者AtomicReferance对象中
- 3、将对象的引用保存到某个正确构造对象的final类型域中
- 4、将对象的引用保存到一个由锁保护的域中。
在线程安全容器内部的同步意味着,在将对象放入到某个容器,例如Vector或synchronizedList时,将满足上述最后一条需求。如果线程A将对象X放入一个线程安全的容器,随后线程B读取这个对象,那么可以确保B看到A设置的X状态,即便在这段读/写X的应用程序代码中没有包含显式的同步。尽管Javadoc在这个主题上没有给出很清晰的说明,但线程安全库中的容器类提供了以下的安全发布保证:
- 1、通过将一个键或者值放入Hashtable、synchronizedMap或者ConcurrentMap中,可以安全地将它发布给任何从这些容器中访问它的线程(无论是直接访问还是通过迭代器访问)
- 2、通过将某个元素放入Vector、CopyOnWriteArrayList、CopyOnWriteArraySet、synchronizedList或synchronizedSet中,可以将该元素安全地发布到任何从这些容器中访问该元素的线程
- 3、通过将某个元素放入BlockingQueue或者ConcurrentLinkedQueue中,可以将该元素安全地发布到任何从这些队列中访问该元素的线程。
类库中的其他数据传递机制(例如Future和Exchanger)同样能实现安全发布。
通常,要发布一个静态构造的对象,最简单和最安全的方式是使用静态的初始化器:
public static Holder holder = new Holder(42);
静态初始化器由JVM在类的初始化阶段执行。由于在JVM内部存在着同步机制,因此通过这种方式初始化的任何对象都可以被安全地发布[JLS 12.4.2]。
可变对象
对象的发布需求取决于它的可变性:
- 1、不可变对象可以通过任意机制来发布
- 2、事实不可改变必须通过安全方式发布
- 3、可变对象必须通过安全方式发布,并且必须是线程安全的或者由某个锁保护起来
小结
在并发程序中使用和共享对象时,遵循如下实用策略
- 1.线程封闭 对象封闭在线程中,只能由该线程修改
- 2.只读共享 多线程并发只读对象,不能修改
- 3.线程安全共享 线程安全的对象在其内部实现同步,多线程可以通过对象公有接口进行访问而不是进一步同步
- 4.保护对象 被保护的对象只能通过持有特地的锁来访问