[转]java线程安全总结
http://www.iteye.com/wiki/jvm/2877-synchronized-volatile

一.java的内存模型JMM(解决可见性和有序性) 规定了jvm主内存
多线程不能相互传递数据,用共享变量

每个线程都有工作内存,其存储了主内存某些对象的副本.:
1)从主存复制对象到当前工作内存(read and load)
2)改变共享内存(use and assign) (其他线程可见)
3)工作内存数据刷新主存相关内容(store and write)

多次赋值时,可能只对工作内存副本操作,最后一次才同步到主存
导致不同步会出问题.
synchronized关键字保证了多个线程对于同步块是互斥的
而volatile关键字之解决多线程的内存可见性问题
二.java的线程同步机制

//不同步package com.test;public class Account {private int balance;public Account(int balance) {this.balance = balance;}public int getBalance() {return balance;}public void add(int num) {balance = balance + num;}public void withdraw(int num) {balance = balance - num;}public static void main(String[] args) throws InterruptedException {for (int i = 0; i < 100; i++) {Account account = new Account(1000);Thread a = new Thread(new AddThread(account, 20), "add");//创建threadThread b = new Thread(new WithdrawThread(account, 20), "withdraw");a.start();//启动b.start();a.join();b.join();System.out.println(i+":"+account.getBalance());}}static class AddThread implements Runnable {Account account;int amount;public AddThread(Account account, int amount) {this.account = account;this.amount = amount;}public void run() {for (int i = 0; i < 1000000; i++) {account.add(amount);}}}static class WithdrawThread implements Runnable {Account account;int amount;public WithdrawThread(Account account, int amount) {this.account = account;this.amount = amount;}public void run() {for (int i = 0; i < 1000000; i++) {account.withdraw(amount);}}}}

public synchronized void add(int num) //锁方法所在对象
public static synchronized void add(int num) //锁方法所在的class

//在并发环境下，一个没有共享的对象作为锁是没有意义的
Object lock=new Object();
synchronized (lock){
//do something
}

锁有两个队列 :就绪(将获得锁),阻塞(被阻塞的进程)

wait(放弃锁)-->阻塞-->notify-->就绪-->cpu调度
临界区代码:
1)获得同步锁
2)清空工作内存
3)主存copy变量到工作内存
4)处理
5)工作内存-->主存
6)释放锁

//线程安全public class Account {List<Object> eggs = new ArrayList<Object>();public synchronized Object getEgg() {if (eggs.size() == 0) {try {wait(); // 放弃锁} catch (InterruptedException e) {}}Object egg = eggs.get(0);//System.out.println("Get Egg,Eggs' size:" + eggs.size());System.out.println("============================");eggs.clear();// 清空盘子notify(); // 唤醒return egg;}public synchronized void putEgg(Object egg) {if (eggs.size() > 0) {try {wait();} catch (InterruptedException e) {}}eggs.add(egg);// 往盘子里放鸡蛋System.out.println("Put Egg,Eggs' Size:" + eggs.size());notify();// 唤醒阻塞队列的某线程到就绪队列}public static void main(String[] args) throws InterruptedException {Account account = new Account();Thread put = new Thread(new Put(account));Thread get = new Thread(new Get(account));put.start();get.start();// put.join();// get.join();}static class Put implements Runnable {Account account;Put(Account a) {this.account = a;}public void run() {for (int i = 0; i < 100000; i++) {Object egg = new Object();account.putEgg(egg);}}}static class Get implements Runnable {Account account;Get(Account a) {this.account = a;}public void run() {for (int i = 0; i < 1000000; i++) {account.getEgg();}}}}

1 开始，A调用plate.putEgg方法，此时eggs.size()为0，因此顺利将鸡蛋放到盘子，还执行了notify()方法，唤醒锁的阻塞队列的线程，此时阻塞队列还没有线程。
2 又有一个A线程对象调用plate.putEgg方法，此时eggs.size()不为0，调用wait()方法，自己进入了锁对象的阻塞队列。
3 此时，来了一个B线程对象，调用plate.getEgg方法，eggs.size()不为0，顺利的拿到了一个鸡蛋，还执行了notify()方法，唤醒锁的阻塞队列的线程，此时阻塞队列有一个A线程对象，唤醒后，它进入到就绪队列，就绪队列也就它一个，因此马上得到锁，开始往盘子里放鸡蛋，此时盘子是空的，因此放鸡蛋成功。
4 假设接着来了线程A，就重复2；假设来料线程B，就重复3。


任何被volatile修饰的变量，都不拷贝副本到工作内存，任何修改都及时写在主存
只保证可见性,不保证有序性
public class VolatileTest{
public volatile int a;
public void add(int count){
a=a+count;
}
}

//适合场景
满足条件
1)对变量的写操作不依赖于当前值。
2)该变量没有包含在具有其他变量的不变式中
用volatile声明了，读取主存副本到工作内存和同步a到主存的步骤，相当于是一个原子操作
public void setA(int a){
this.a=a;
}