Java 线程第三版 第五章 极简同步技巧 读书笔记

一、能避免同步吗？

取得锁会因为以下原因导致成本很高：
    取得由竞争的锁需要在虚拟机的层面上运行更多的程序代码。
    要取得有竞争锁的线程总是必须等到锁被释放后。

1. 寄存器的效应

计算机有一定数量的主寄存器用来存储与程序有关的数据。
从逻辑上的观点来看，每个Thread都有自己的一组寄存器。当操作系统将某个Thread分配给CPU时，它会把该Thread特有的信息加载到CPU的寄存器中。在分配不同的Thread给CPU之前，它会将寄存器的信息存下来。所以Thread间绝不会共享保存在寄存器的数据。
当虚拟机进入synchronized方法或者块时，它必须重新加载本来已经缓存到自有寄存器上的数据。在虚拟机离开synchroized方法或者块之前，它必须把自有寄存器存入主寄存器中。

2. 重排语句的效应

在单独线程中，程序总是按照代码一行行的执行的，但是如果是多个线程并发，Java并不保证每个线程run方法的执行顺序，也就是可能其中一个线程执行到一半就会被暂时停止，执行其他线程，之后再切换回来。
多个线程间调度执行的无序性就是重排语句的效应。


3. 双重检查的Locking

二、Atomic变量

1. Atomic Class的概述

    AtomicInteger, AtomicLong, AtomicBoolean, AtomicRefrences。Atomic的功能实现时通过使用use-level的Java程序无法访问的固有方法来完成的。
atomic package支持更复杂的变量类型吗?
    一些不支持，例如字符或者浮点。
    AtomicStampedReference能够让mark或stamp跟在任何对象的引用上。
    AtomicMarkableReference提供一个包含对象引用结合boolean的数据结构。

2. 使用Atomic Class

import javax.swing.*;import java.awt.event.*;import java.util.concurrent.*;import java.util.concurrent.atomic.*;import javathreads.examples.ch05.*;public class ScoreLabel extends JLabel implements CharacterListener {    private AtomicInteger score = new AtomicInteger(0);    private AtomicInteger char2type = new AtomicInteger(-1);    private AtomicReference<CharacterSource> generator = null;    private AtomicReference<CharacterSource> typist = null;    public ScoreLabel (CharacterSource generator, CharacterSource typist) {        this.generator = new AtomicReference(generator);        this.typist = new AtomicReference(typist);        if (generator != null)             generator.addCharacterListener(this);        if (typist != null)             typist.addCharacterListener(this);           }    public ScoreLabel () {        this(null, null);    }    public void resetGenerator(CharacterSource newGenerator) {        CharacterSource oldGenerator;        if (newGenerator != null)            newGenerator.addCharacterListener(this);        oldGenerator = generator.getAndSet(newGenerator);        if (oldGenerator != null)            oldGenerator.removeCharacterListener(this);    }    public void resetTypist(CharacterSource newTypist) {        CharacterSource oldTypist;        if (newTypist != null)            newTypist.addCharacterListener(this);        oldTypist = typist.getAndSet(newTypist);        if (oldTypist != null)            oldTypist.removeCharacterListener(this);    }    public void resetScore() {        score.set(0);        char2type.set(-1);        setScore();    }    private void setScore() {        // This method will be explained later in chapter 7        SwingUtilities.invokeLater(new Runnable() {            public void run() {                setText(Integer.toString(score.get()));            }        });    }    public void newCharacter(CharacterEvent ce) {        int oldChar2type;         // Previous character not typed correctly - 1 point penalty        if (ce.source == generator.get()) {            oldChar2type = char2type.getAndSet(ce.character);            if (oldChar2type != -1) {                score.decrementAndGet();                setScore();            }        }        // If character is extraneous - 1 point penalty        // If character does not match - 1 point penalty        else if (ce.source == typist.get()) {            while (true) {                oldChar2type = char2type.get();                if (oldChar2type != ce.character) {                    score.decrementAndGet();                    break;                } else if (char2type.compareAndSet(oldChar2type, -1)) {                    score.incrementAndGet();                    break;                }            }            setScore();        }    } }

变量替换
score与char2type变量已经改成atomic变量。
以上resetScroe方法中对两个变量进行修改，虽然使用atomic能保证每个变量的原子性，但是如果多个线程同时执行resetScore方法依然会出现竞态条件。
有可能一个线程执行resetScore的第一行代码score.set(0);还未执行第二行，而另外一个线程可能已经执行newCharacter方法获取char2type的值，但是之前的线程执行resetScore方法还未对char2type进行修改。因为resetScore整个方法并不是原子的。


变更算法
resetGenerator与resetTypist两个方法，以resetGenerator方法为例，将generator变量变成AtomicRerence同样引发上面描述的问题。


通知与Atomic变量

import java.awt.*;import javax.swing.*;import java.util.concurrent.*;import java.util.concurrent.atomic.*;import javathreads.examples.ch05.*;public class AnimatedCharacterDisplayCanvas extends CharacterDisplayCanvas implements CharacterListener, Runnable {    private AtomicBoolean done = new AtomicBoolean(true);    private AtomicInteger curX = new AtomicInteger(0);    private AtomicInteger tempChar = new AtomicInteger(0);    private Thread timer = null;    public AnimatedCharacterDisplayCanvas() {        startAnimationThread();    }    public AnimatedCharacterDisplayCanvas(CharacterSource cs) {        super(cs);        startAnimationThread();    }    private void startAnimationThread() {        if (timer == null) {            timer = new Thread(this);            timer.start();        }    }    public void newCharacter(CharacterEvent ce) {        curX.set(0);        tempChar.set(ce.character);        repaint();    }    protected void paintComponent(Graphics gc) {        char[] localTmpChar = new char[1];        localTmpChar[0] = (char) tempChar.get();        int localCurX = curX.get();        Dimension d = getSize();        int charWidth = fm.charWidth(localTmpChar[0]);        gc.clearRect(0, 0, d.width, d.height);        if (localTmpChar[0] == 0)            return;        gc.drawChars(localTmpChar, 0, 1,                     localCurX, fontHeight);        curX.getAndIncrement();    }    public void run() {        while (true) {            try {                Thread.sleep(100);                if (!done.get()) {                    repaint();                }            } catch (InterruptedException ie) {                return;            }        }    }    public void setDone(boolean b) {        done.set(b);    }}

使用Atomic变量的总结
乐观同步
程序代码抓住保护变量的值并作出此一瞬间没有其他修改的假设，然后程序代码就计算出该变量的新值并尝试更新该变量。
如果有其他的Thread同时修改了变量，这个更新就失败且程序必须重新执行这些步骤（使用变量的最新修改过的值）。




数据交换： getAndSet()
复杂的数据交换： get()与compareAndSet()

高级的atomic数据类型

import java.lang.*;import java.util.concurrent.atomic.*;public class AtomicDouble extends Number {    private AtomicReference<Double> value;    public AtomicDouble() {        this(0.0);    }    public AtomicDouble(double initVal) {        value = new AtomicReference<Double>(new Double(initVal));    }    public double get() {        return value.get().doubleValue();    }    public void set(double newVal) {        value.set(new Double(newVal));    }    public boolean compareAndSet(double expect, double update) {        Double origVal, newVal;        newVal = new Double(update);        while (true) {            origVal = value.get();            if (Double.compare(origVal.doubleValue(), expect) == 0) {                if (value.compareAndSet(origVal, newVal))                    return true;             } else {                return false;            }        }    }    public boolean weakCompareAndSet(double expect, double update) {        return compareAndSet(expect, update);    }    public double getAndSet(double setVal) {        Double origVal, newVal;        newVal = new Double(setVal);        while (true) {            origVal = value.get();            if (value.compareAndSet(origVal, newVal))                return origVal.doubleValue();        }    }    public double getAndAdd(double delta) {        Double origVal, newVal;        while (true) {            origVal = value.get();            newVal = new Double(origVal.doubleValue() + delta);            if (value.compareAndSet(origVal, newVal))                return origVal.doubleValue();        }    }    public double addAndGet(double delta) {        Double origVal, newVal;        while (true) {            origVal = value.get();            newVal = new Double(origVal.doubleValue() + delta);            if (value.compareAndSet(origVal, newVal))                return newVal.doubleValue();        }    }    public double getAndIncrement() {        return getAndAdd((double) 1.0);    }    public double getAndDecrement() {        return getAndAdd((double) -1.0);    }    public double incrementAndGet() {        return addAndGet((double) 1.0);    }    public double decrementAndGet() {        return addAndGet((double) -1.0);    }    public double getAndMultiply(double multiple) {        Double origVal, newVal;        while (true) {            origVal = value.get();            newVal = new Double(origVal.doubleValue() * multiple);            if (value.compareAndSet(origVal, newVal))                return origVal.doubleValue();        }    }    public double multiplyAndGet(double multiple) {        Double origVal, newVal;        while (true) {            origVal = value.get();            newVal = new Double(origVal.doubleValue() * multiple);            if (value.compareAndSet(origVal, newVal))                return newVal.doubleValue();        }    }    public int intValue() {        return DoubleValue().intValue();    }    public long longValue() {        return DoubleValue().longValue();    }    public float floatValue() {        return DoubleValue().floatValue();    }    public double doubleValue() {        return DoubleValue().doubleValue();    }    public byte byteValue() {        return (byte)intValue();    }    public short shortValue() {        return (short)intValue();    }    public Double DoubleValue() {        return value.get();    }    public boolean isNaN() {        return DoubleValue().isNaN();    }    public boolean isInfinite() {        return DoubleValue().isInfinite();    }    public String toString() {        return DoubleValue().toString();    }    public int hashCode() {        return DoubleValue().hashCode();    }    public boolean equals(Object obj) {        Double origVal = DoubleValue();        return ((obj instanceof Double)                && (origVal.equals((Double)obj)))               ||               ((obj instanceof AtomicDouble)                && (origVal.equals(((AtomicDouble)obj).DoubleValue())));    }    public int compareTo(Double aValue) {        return Double.compare(doubleValue(), aValue.doubleValue());    }    public int compareTo(AtomicDouble aValue) {        return Double.compare(doubleValue(), aValue.doubleValue());    }}

大量数据的更改
    用两个变量的原子类：分数与字母变量。

import java.util.concurrent.atomic.*;public class AtomicScoreAndCharacter {    public class ScoreAndCharacter {        private int score, char2type;        public ScoreAndCharacter(int score, int char2type) {            this.score = score;            this.char2type = char2type;        }        public int getScore() {            return score;        }        public int getCharacter() {            return char2type;        }    }    private AtomicReference<ScoreAndCharacter> value;    public AtomicScoreAndCharacter() {        this(0, -1);    }    public AtomicScoreAndCharacter(int initScore, int initChar) {        value = new AtomicReference<ScoreAndCharacter>                    (new ScoreAndCharacter(initScore, initChar));    }    public int getScore() {        return value.get().getScore();    }    public int getCharacter() {        return value.get().getCharacter();    }    public void set(int newScore, int newChar) {        value.set(new ScoreAndCharacter(newScore, newChar));    }    public void setScore(int newScore) {        ScoreAndCharacter origVal, newVal;        while (true) {            origVal = value.get();            newVal = new ScoreAndCharacter                         (newScore, origVal.getCharacter());            if (value.compareAndSet(origVal, newVal)) break;        }    }    public void setCharacter(int newCharacter) {        ScoreAndCharacter origVal, newVal;        while (true) {            origVal = value.get();            newVal = new ScoreAndCharacter                         (origVal.getScore(), newCharacter);            if (value.compareAndSet(origVal, newVal)) break;        }    }    public void setCharacterUpdateScore(int newCharacter) {        ScoreAndCharacter origVal, newVal;        int score;        while (true) {            origVal = value.get();            score = origVal.getScore();            score = (origVal.getCharacter() == -1) ? score : score-1;            newVal = new ScoreAndCharacter (score, newCharacter);            if (value.compareAndSet(origVal, newVal)) break;        }    }    public boolean processCharacter(int typedChar) {        ScoreAndCharacter origVal, newVal;        int origScore, origCharacter;        boolean retValue;        while (true) {            origVal = value.get();            origScore = origVal.getScore();            origCharacter = origVal.getCharacter();            if (typedChar == origCharacter) {                origCharacter = -1;                origScore++;                retValue = true;            } else {                origScore--;                retValue = false;            }            newVal = new ScoreAndCharacter(origScore, origCharacter);            if (value.compareAndSet(origVal, newVal)) break;        }        return retValue;    }}

被封装的值是以只读的方式处理。set方法必须创建新的对象来封装被保存的新值。

三、Thread局部变量

import java.util.*;public abstract class Calculator {    private static ThreadLocal<HashMap> results = new ThreadLocal<HashMap>() {        protected HashMap initialValue() {            return new HashMap();        }    };    public Object calculate(Object param) {        HashMap hm = results.get();Object o = hm.get(param);if (o != null)    return o;        o = doLocalCalculate(param);        hm.put(param, o);        return o;    }    protected abstract Object doLocalCalculate(Object param);}