1、同步访问共享的可变数据
（1）同步的两个作用
A、可以阻止一个线程看到对象处于不一致的状态之中
B、保证进入同步方法或者同步代码块的每个线程，都看到由同一个锁保护的之前所有的修改效果
（2）变量的原子性
Java语言规范保证读取或者写一个变量是原子的，除非这个变量的类型为long或者double。即读取一个非long或double的变量，可以保证返回的值是某个线程保存在该变量中的。但是它不保证一个线程的写入值对另一个线程是可见的，线程之间的通信需要互斥与同步。
（3）提升（hoisting）造成活性失败（liveness failure）
A、无法停止
public class StopThread {
private static boolean stopRequested;
public static void main(String[] args)
throws InterruptedException {
Thread backgroundThread = new Thread(new Runnable() {
public void run() {
int i = 0;
while (!stopRequested)
i++;
}
});
backgroundThread.start();
TimeUnit.SECONDS.sleep(1);
stopRequested = true;
}
}因为stopRequested的操作没有进行同步，主线程将其置为true，后台线程不一定能保证看到，虚拟机自动将
while(!done)
i++;优化为（这种优化成为提升）：
if(!done)
while(true)
i++;
B、正确的应该对stopRequested进行同步（synchronized可保证原子性和可见性）
public class StopThread {
private static boolean stopRequested;
private static synchronized void requestStop() {
stopRequested = true;
}
private static synchronized boolean stopRequested() {
return stopRequested;
}
public static void main(String[] args)
throws InterruptedException {
Thread backgroundThread = new Thread(new Runnable() {
public void run() {
int i = 0;
while (!stopRequested())
i++;
}
});
backgroundThread.start();
TimeUnit.SECONDS.sleep(1);
requestStop();
}
} 或者使用volatile保证可见性（因为本身对boolean的操作是原子的）
public class StopThread {
private static volatile boolean stopRequested;
public static void main(String[] args)
throws InterruptedException {
Thread backgroundThread = new Thread(new Runnable() {
public void run() {
int i = 0;
while (!stopRequested)
i++;
}
});
backgroundThread.start();
TimeUnit.SECONDS.sleep(1);
stopRequested = true;
}
}（4）volatile不保证原子性（安全性失败safety failure）
private static volatile int nextSerialNumber = 0;
//此方法不保证原子性
public static int generateSerialNumber(){
return nextSerialNumber ++ ;
}修正方法
A、generateSerialNumber方法增加synchronized方法，同时去除volatile修饰
B、使用AtomicLong类
private static final AtomicLong nextSerialNum = new AtomicLong();
public static long generateNextSerialNum(){
return nextSerialNum.getAndIncrement();
}（5）安全发布（safe publication）
要么不共享可变数据，要么共享不可变数据，要么不共享。总之，要将可变数据限制在单个线程中。
让一个线程在短时间内修改一个数据对象，然后与其他线程共享，这是可以接受的，只同步共享对象引用的动作，然后其他线程没有进一步的同步也是可以读取对象，只要它没有再被修改，这种对象被称为事实上不可变的（effectively immutable），这种对象引用从一个线程传递到其他线程的操作称为安全发布。
安全发布对象引用的方法：
A、将其保存在静态域中，作为类初始化的一部分
B、保存在volatile域、final域或者通过锁访问的域中
C、放到并发集合当中
总之，当多个线程共享可变数据时，每个读或者写的线程都必须执行同步，如果没有同步，就无法保证一个线程所做的修改可以被另外一个线程获知，未能同步共享可变数据会造成活性失败和安全性失败。
如果只需要在线程之间的交互通信，不需要互斥，volatile是一个可以接受的同步形式。
2、避免过度同步
（1）被同步的方法或代码块，不要放弃对客户端的控制
即不要调用设计成要被覆盖的方法，或者是由客户端以函数形式提供的方法，因为外来类的操作是不可预知的，容易导致异常、死锁或数据损坏。
public class ObservableSet<E> extends ForwardingSet<E> {
public ObservableSet(Set<E> set) { super(set); }
private final List<SetObserver<E>> observers =
new ArrayList<SetObserver<E>>();
public void addObserver(SetObserver<E> observer) {
synchronized(observers) {
observers.add(observer);
}
}
public boolean removeObserver(SetObserver<E> observer) {
synchronized(observers) {
return observers.remove(observer);
}
}
// This method is the culprit
private void notifyElementAdded(E element) {
synchronized(observers) {
for (SetObserver<E> observer : observers)
observer.added(this, element);
}
}
// Alien method moved outside of synchronized block - open calls - Page 268
// private void notifyElementAdded(E element) {
// List<SetObserver<E>> snapshot = null;
// synchronized(observers) {
// snapshot = new ArrayList<SetObserver<E>>(observers);
// }
// for (SetObserver<E> observer : snapshot)
// observer.added(this, element);
// }
// Thread-safe observable set with CopyOnWriteArrayList - Page 269
//
// private final List<SetObserver<E>> observers =
// new CopyOnWriteArrayList<SetObserver<E>>();
//
// public void addObserver(SetObserver<E> observer) {
// observers.add(observer);
// }
// public boolean removeObserver(SetObserver<E> observer) {
// return observers.remove(observer);
// }
// private void notifyElementAdded(E element) {
// for (SetObserver<E> observer : observers)
// observer.added(this, element);
// }
@Override public boolean add(E element) {
boolean added = super.add(element);
if (added)
notifyElementAdded(element);
return added;
}
@Override public boolean addAll(Collection<? extends E> c) {
boolean result = false;
for (E element : c)
result |= add(element); // calls notifyElementAdded
return result;
}
}（2）ConcurrentModificationException实例
public class Test2 {
public static void main(String[] args) {
ObservableSet<Integer> set =
new ObservableSet<Integer>(new HashSet<Integer>());
set.addObserver(new SetObserver<Integer>() {
public void added(ObservableSet<Integer> s, Integer e) {
System.out.println(e);
if (e == 23) s.removeObserver(this);
}
});
for (int i = 0; i < 100; i++)
set.add(i);
}
}add方法调用notifyElementAdded，而同时added方法则删除元素。
（3）死锁实例
public class Test3 {
public static void main(String[] args) {
ObservableSet<Integer> set =
new ObservableSet<Integer>(new HashSet<Integer>());
// Observer that uses a background thread needlessly
set.addObserver(new SetObserver<Integer>() {
public void added(final ObservableSet<Integer> s, Integer e) {
System.out.println(e);
if (e == 23) {
ExecutorService executor =
Executors.newSingleThreadExecutor();
final SetObserver<Integer> observer = this;
try {
executor.submit(new Runnable() {
public void run() {
s.removeObserver(observer);
}
}).get();
} catch (ExecutionException ex) {
throw new AssertionError(ex.getCause());
} catch (InterruptedException ex) {
throw new AssertionError(ex.getCause());
} finally {
executor.shutdown();
}
}
}
});
for (int i = 0; i < 100; i++)
set.add(i);
}
}后台线程调用s.removeObserver，企图锁定observers，但它无法获得该锁，因为主线程已经有锁了，这个期间，主线程一直在等待后台线程来完成对观察者的删除，这正是造成死锁的原因。
（4）将外来方法的调用移出同步块
A、方法一，弄个快照
// This method is the culprit
private void notifyElementAdded(E element) {
synchronized(observers) {
for (SetObserver<E> observer : observers)
observer.added(this, element);
}
}
// Alien method moved outside of synchronized block - open calls - Page 268
// private void notifyElementAdded(E element) {
// List<SetObserver<E>> snapshot = null;
// synchronized(observers) {
// snapshot = new ArrayList<SetObserver<E>>(observers);
// }
// for (SetObserver<E> observer : snapshot)
// observer.added(this, element);
// }B、方法二，使用并发集合
private final List<SetObserver<E>> observers = new CopyOnWriteArrayList<SetObserver<E>>();
public void addObserver(SetObserver<E> observer){
observers.add(observer);
}
public boolean removeObserver(SetObserver<E> observer){
return observers.remove(observer);
}
private void notifyElementAdded(E element){
for(SetObserver<E> observer:observers){
observer.added(this,element);
}
}（5）开放调用（open call）
在同步区之外被调用的外来方法，称为开放调用，除了可以避免死锁之外，还可以极大增加并发性。外来方法的运行时间可能会任意长，如果在同步区域内调用外来方法，其他线程对受保护资源的访问就会遭到不必要的拒绝。
（6）在同步区做尽可能少的工作（限制同步区的工作量）
获得锁、检查共享数据、根据需要转换数据，然后放掉锁。
（7）不要过度同步
在多核时代，过度同步的实际成本并不是指获得锁所花费的CPU时间，而是指失去了并行的机会，以及因为需要确保每个核都有一个一致的内存视图而导致的延迟。过度同步的另一项潜在开销在于，它会限制JVM优化代码的能力。
3、executor和task优先于线程
（1）executor service
A、可以等待一个任务集合中的任何任务或所有任务完成
invokeAny，invokeAll
B、可以等待executor service优雅地完成终止
awaitTermination
C、可以在任务完成时逐个获取这些任务的记过
ExecutorCompletionService
（2）线程池的选择
A、小程序或轻载的服务器使用Executors.newCachedThreadPool
在缓存的线程池中，被提交的任务并没有排成队列，而是直接交给线程执行，如果没有线程可用，则创建一个新的。对于大负载的时候，cached的线程池不适用，任务越多，创建越多线程
B、大负载的情况，使用Executors.newFixedThreadPool
4、并发工具优先于wait和notify
java.util.concurrent更高级的东西，分为三类：Executor Framework，并发集合、同步器。
（1）并发集合
public class Intern {
private static final ConcurrentMap<String, String> map =
new ConcurrentHashMap<String, String>();
// Concurrent canonicalizing map atop ConcurrentMap - not optimal - Page 273
// public static String intern(String s) {
// String previousValue = map.putIfAbsent(s, s);
// return previousValue == null ? s : previousValue;
// }
// Concurrent canonicalizing map atop ConcurrentMap - faster! - Page 274
public static String intern(String s) {
String result = map.get(s);
if (result == null) {
result = map.putIfAbsent(s, s);
if (result == null)
result = s;
}
return result;
}
}（2）同步器
是使一些线程能够等待另一个线程的对象，允许它们协调动作，最常见的是CountDownLatch和Semaphore，较不常用的是CyclicBarrier和Exchanger。
public class ConcurrentTimer {
private ConcurrentTimer() { } // Noninstantiable
public static long time(Executor executor, int concurrency,
final Runnable action) throws InterruptedException {
final CountDownLatch ready = new CountDownLatch(concurrency);
final CountDownLatch start = new CountDownLatch(1);
final CountDownLatch done = new CountDownLatch(concurrency);
for (int i = 0; i < concurrency; i++) {
executor.execute(new Runnable() {
public void run() {
ready.countDown(); // Tell timer we're ready
try {
start.await(); // Wait till peers are ready
action.run();
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
} finally {
done.countDown(); // Tell timer we're done
}
}
});
}
ready.await(); // Wait for all workers to be ready
long startNanos = System.nanoTime();
start.countDown(); // And they're off!
done.await(); // Wait for all workers to finish
return System.nanoTime() - startNanos;
}
}5、线程安全性的文档化
（1）线程安全的几种级别
A、不可变的
如String、Long、BigInteger
B、无条件的线程安全
实例可变，但是这个类有着足够的内部同步，可以并发使用
比如Random、ConcurrentHashMap
C、有条件的线程安全
Collections.synchronized包装返回的集合
D、非线程安全
可变的，需要自己同步，比如ArrayList、HashMap
E、线程对立的
没有同步地修改静态数据，比如System.runFinalizersOnExit，现已废除
（2）同步序列
有条件的线程安全使用要特别小心，你必须指明哪个调用序列需要外部同步，还要指明为了执行这些序列，必须获得哪一把锁。
It is imperative that the user manually synchronize on the returned
* sorted map when iterating over any of its collection views, or the
* collections views of any of its <tt>subMap</tt>, <tt>headMap</tt> or
* <tt>tailMap</tt> views.
* <pre>
* SortedMap m = Collections.synchronizedSortedMap(new TreeMap());
* ...
* Set s = m.keySet(); // Needn't be in synchronized block
* ...
* synchronized (m) { // Synchronizing on m, not s!
* Iterator i = s.iterator(); // Must be in synchronized block
* while (i.hasNext())
* foo(i.next());
* }（3）把锁对象封装在它所同步的对象里
这样就不会暴露给客户端，防止客户端发起攻击
私有锁对象的模式只能用在无条件线程安全类上，有条件的不能使用这种模式，但必须在文档注明调用序列
6、慎用延迟初始化
（1）延迟初始化（lazy initialization）
延迟到需要域的值得时候才将它初始化的行为。
（2）如无必要，不要这么做
它虽然降低了初始化类或者创建实例的开销，但是却增加了访问被延迟初始化域的开销。
（3）正常初始化优于延迟初始化
public class Initialization {
// Normal initialization of an instance field - Page 282
private final FieldType field1 = computeFieldValue();
// Lazy initialization of instance field - synchronized accessor - Page 282
private FieldType field2;
synchronized FieldType getField2() {
if (field2 == null)
field2 = computeFieldValue();
return field2;
}
// Lazy initialization holder class idiom for static fields - Page 283
private static class FieldHolder {
static final FieldType field = computeFieldValue();
}
static FieldType getField3() { return FieldHolder.field; }
// Double-check idiom for lazy initialization of instance fields - Page 283
private volatile FieldType field4;
FieldType getField4() {
FieldType result = field4;
if (result == null) { // First check (no locking)
synchronized(this) {
result = field4;
if (result == null) // Second check (with locking)
field4 = result = computeFieldValue();
}
}
return result;
}
// Single-check idiom - can cause repeated initialization! - Page 284
private volatile FieldType field5;
private FieldType getField5() {
FieldType result = field5;
if (result == null)
field5 = result = computeFieldValue();
return result;
}
private static FieldType computeFieldValue() {
return new FieldType();
}
}
class FieldType { }（4）使用模式
A、对于实例域，使用双重检查模式
B、对于静态域，使用static holder模式
C、对于可以接受重复初始化的实例域，采用单重检查模式
7、不要依赖于线程调度器
（1）依赖线程调度器可能导致不可移植
A、确保可运行的线程平均数量不明显多于处理器的数量，这样让线程调度器没有更多的选择，即使在根本不同的线程调度算法下，这些程序的行为也不会有很大的变化
B、让线程做有意义的工作，然后等待更多有意义的工作。不要一直处于busy-wait的状态，即反复的检查一个共享对象，以等待事情的发生，这样极大地加大处理器的负担。
// Awful CountDownLatch implementation - busy-waits incessantly!
public class SlowCountDownLatch {
private int count;
public SlowCountDownLatch(int count) {
if (count < 0)
throw new IllegalArgumentException(count + " < 0");
this.count = count;
}
public void await() {
while (true) {
synchronized(this) {
if (count == 0) return;
}
}
}
public synchronized void countDown() {
if (count != 0)
count--;
}
}上面这段实现，比标准的实现慢了大约2000倍。
（2）不要依赖Thread.yield或者线程优先级
同一个yield调用在一个JVM实现上能提高性能，但是在另外一个JVM实现上可能会更差。
线程优先级的话，也是依赖平台系统的，不建议使用。
8、避免使用线程组
ThreadGroup已经过时，而且很多方法有缺陷，不建议使用，一般用executor替代。
扫一扫
9614
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
