线程资源同步机制

有如下程序：

int i=0;
public int getNextId(){
    return i++;
}

以上程序在JVM中执行的步骤如下：
（1） JVM在堆中给i分配一个内存存储场所（main memory），并存储其值为1。
（2）线程启动后，自动分配一片操作数栈(working memory)，当线程执行到return i++时，JVM的动作分为以下五步：

装载i
向main memory发起read i指令。
当read i执行完毕，线程会将i的值从main memory复制到working memory中。
读取i
从main memory中读取i。
进行i+1操作
由线程完成。
存储i
将i+1的值赋值给i，然后存储到working memory中。
写入i
将i的值回写到main memory中。

从以上步骤中不难发现，从working memory到main memory的存取是需要时间的（反过来也是）；i++是由多个操作完成的（读取自增存储），如果是多线程，就会出现脏读、误读等现象。

对于多线程的脏读、误读等现象，JVM把对于working memory的操作分为了use、assign、load、store、lock和unlock。
对于main memory操作分为了read、write、lock和unlock。
不难理解lock和unlock就是锁的使用。对此，JVM提供了synchronized关键字、volatile关键字和lock/unlock机制。

采用synchronized改造如下：

public synchronized int getNextId(){
    return i++;
}

对于lock/unlock机制，可能发生死锁，可以看看如下代码：

private Object a=new Object();
private Object b=new Object();
public void callAB(){
    synchronized(a){
        synchronized(b){
            //do something
        }
    }
}
public void executeAB(){
    synchronized(b){
        synchronized(a){
            //do something
        }
    }
}

volatile机制有所不同，它仅用于控制线程中对象的可见性，并不能保证在此对象上操作的原子性。就像上面的i++操作，即使把i定义为volatile也是没用的。但对于定义为volatile的变量，线程不会将其从main memory 复制到work memory中，而是直接在main memory上操作，它的代价虽然低，但是不能保证原子性。

可见性，是指线程之间的可见性，一个线程修改的状态对另一个线程是可见的。也就是一个线程修改的结果。另一个线程马上就能看到。 用volatile修饰的变量，就会具有可见性。volatile修饰的变量不允许线程内部缓存和重排序，即直接修改内存。所以对其他线程是可见的。
volatile变量不会被缓存在寄存器或者对其他处理器不可见的地方，因此在读取volatile类型的变量时总会返回最新写入的值。

线程交互机制

线程交互最典型的就是连接池。连接池中通常会有get和return两种方法。return的时候会讲连接返回到缓存列表中，并将连接数+1。而get方法在判断可使用连接数为0后，就进入一个等待状态，当有连接返回到连接池时，应该通知get方法不需要等待了。JVM通过wait/notify/notifyAll来支持这种等待和唤醒的需求。

典型的代码如下：

public Connection get(){
    synchronized(this){
        if(free>0){
            free--;
            return cacheConnections.poll();
        }
        else{
            this.wait();
        }
    }
}
public void close(Connection conn){
    synchronized(this){
        free++;
        cacheConnection.offer(conn);
        this.notifyAll();
    }
}

在Sun JDK中，object.wait()还有可能被虚假唤醒（也就是说原本只能唤醒一个人，现在唤醒了两个人，都先后拿到了锁，然而池中只有一根冰棒，），因此需要在此确认状态是否变更了，这种做法称为double check。（具体可以看看懒汉单例模式或者生产者消费者模式）
单例模式：

public static Singleton2 getInstance(){
        if(instance == null) {
            synchronized (Singleton2.class){
                instance = new Singleton2();
            }
        }
        return instance;
    }

变更为：

public static Singleton2 getInstance(){
        if(instance == null) {
            synchronized (Singleton2.class){
                if (instance == null){
                    instance = new Singleton2();
                }
            }
        }
        return instance;
    }

这里解释一下为什么synchronized为什么不写成这样：

public static Singleton2 getInstance(){
            synchronized (Singleton2.class){
                if (instance == null){
                    instance = new Singleton2();
                }
            }
        return instance;
    }

其实这是一个效率问题：是由于如果加在synchronized下面的话，这其实与方法加锁没什么区别。每次运行进来，线程都会阻塞。而double check保证了在创建了新实例的时候，不会阻塞。