synchronized和volatile笔记

1.无状态对象，是线程安全的。比如，无状态的servlet（它不包含域，也不引用其他的域。）一次特定计算的瞬时状态，会唯一存在本地变量中，这些本地变量存在线程的栈中，只有执行线程才能访问。

所以，当多线程访问某个无状态的servlet的时候，线程之间是非共享状态，是单独的各自的实例，所以无状态对象是线程安全的。（无状态对象，永远是线程安全的）。

代码如：

@ThreadSafe
public class StatelessFactorizer extends GenericServlet implements Servlet {

    public void service(ServletRequest req, ServletResponse resp) {
        BigInteger i = extractFromRequest(req);
        BigInteger[] factors = factor(i);
        encodeIntoResponse(resp, factors);
    }

    void encodeIntoResponse(ServletResponse resp, BigInteger[] factors) {
    }

    BigInteger extractFromRequest(ServletRequest req) {
        return new BigInteger("7");
    }

    BigInteger[] factor(BigInteger i) {
        // Doesn't really factor
        return new BigInteger[] { i };
    }

假如在无状态对象中，加入一个状态元素，比如，统计数，或者状态值，那么它在多线程下容易遗失更新，在计数或者更新状态时，其操作，不是原子性的。代码如：

@NotThreadSafe
public class UnsafeCountingFactorizer extends GenericServlet implements Servlet {
    private long count = 0;

    public long getCount() {
        return count;
    }

    public void service(ServletRequest req, ServletResponse resp) {
        BigInteger i = extractFromRequest(req);
        BigInteger[] factors = factor(i);
        ++count;
        encodeIntoResponse(resp, factors);
    }

    void encodeIntoResponse(ServletResponse res, BigInteger[] factors) {
    }

    BigInteger extractFromRequest(ServletRequest req) {
        return new BigInteger("7");
    }

    BigInteger[] factor(BigInteger i) {
        // Doesn't really factor
        return new BigInteger[] { i };
    }
}

2.为保护状态的一致性，要在单一的原子操作中更新相互关联的状态的变量。

3.java提供了强制原子性的内置锁机制：synchronized块。一个synchronized块有两部分，锁对象的引用，以及锁的代码块。

Synchronized方法，是对跨越整个方法体的synchronized块的简短描述，至于该方法的锁，则是该方法所在的对象本身。（静态的synchronized方法从class对象上获取锁）

4.同步的弱形式：volatile变量。它确保对一个变量的更新以可预见的方式告知其他的线程。

当一个域声明为volatile后，编译器和运行时会监视这个变量：”它是共享的，而且对他的操作不会与其他的内存操作一起被重新排序”。

Volatile变量不会缓存在寄存器或者缓存在其他的处理器隐藏的地方，所以在读取某个volatile变量时，总会返回由某个线程所写入的最新的域的值。

之所以说它是轻量级的同步机制，当访问synchronized块时，会获得对象锁，此时会引起阻塞，当块内的代码执行完毕，则释放锁。而volatile的变量的操作不会加锁，也不会引起阻塞，因此相比之下，称之为轻量级。

Volatile变量对可见性的影响所产生的价值远远高于变量本身。线程a向volatile变量写入值，然后随之线程b读取该变量值，所有a执行的写操作前可见的变量的值，在b读取了volatile变量之后，成为也是对b可见的。

从内存的角度来看，写入volatile变量，就像退出了同步块，读取volatile变量，就像进入了同步块。不推荐过度依赖volatile变量所提供的可见性。因为通过使用它的这个特性的代码，比使用锁的代码，更脆弱，更难以理解。

所以，只有当volatile变量能简化实现或者同步验证策略的验证时，才使用它们。当验证正确性必须推断可见性问题时，应该避免使用volatile变量。正确的使用volatile变量的方式包括：用于确保它们所引用对象的状态的可见性，或者用于标识重要的生命周期事件，比如初始化或关闭的发生。比如以下代码：

public class CountingSheep {
    volatile boolean asleep;

    void tryToSleep() {
        while (!asleep)
            countSomeSheep();
    }

    void countSomeSheep() {
        // One, two, three...
    }
}