Java多线程基础篇三------synchronized

线程同步的问题在我们平时生活和工作中还是很常见的，

package chc.runnable;
import java.util.Date;
class Account {
    String name;
    float amount;
    
    public Account(String name, float amount) {
        this.name = name;
        this.amount = amount;
    }
    /*
     * 存
     */
    public synchronized void deposit(float amt) {
        float tmp = amount;
        tmp += amt;
        
        try {
            Thread.sleep(10);//模拟其它处理所需要的时间，比如刷新数据库等
        } catch (InterruptedException e) {
            // ignore
        }
        amount = tmp;
        System.out.println(new Date()+"--"+this.getName()+"存入100元 当前余额----->"+amount);
    }
    /*
     * 取
     */
    public synchronized void withdraw(float amt) {
        float tmp = amount;
        tmp -= amt;

        try {
            Thread.sleep(10);//模拟其它处理所需要的时间，比如刷新数据库等
        } catch (InterruptedException e) {
            // ignore
        }        

        amount = tmp;
        System.out.println(new Date()+"--"+this.getName()+"取出100元 当前余额----->"+amount);
    }

    public float getBalance() {
        return amount;
    }
    public String getName(){
    	return name;
    }
}

public class AccountTest{
    private static int NUM_OF_THREAD = 1000;
    static Thread[] threads = new Thread[NUM_OF_THREAD];
    
    public static void main(String[] args){
        final Account acc = new Account("呵呵", 2000.0f);
        final Account acc1 = new Account("哈哈", 1000.0f);
        for (int i = 0; i< NUM_OF_THREAD; i++) {
            threads[i] = new Thread(new Runnable() {
                public void run() {
                        acc.deposit(100.0f);
                        acc.withdraw(100.0f);
                        acc1.deposit(100.0f);
                        acc1.withdraw(100.0f);
                }
            });
            threads[i].start();
        }

        for (int i=0; i<NUM_OF_THREAD; i++){
            try {
                threads[i].join(); //等待所有线程运行结束
            } catch (InterruptedException e) {
                // ignore
            }
        }
        System.out.println("呵呵卡内还剩:" + acc.getBalance() +";    "+"哈哈卡内还剩："+acc1.getBalance());
    }
}

以上实例中描述的是不间断的对呵呵  哈哈 两人的账户进行存取操作 ，每个账户都分别进行1000次存取操作。

1、如果不使用synchronized关键字就会造成多个线程同一时间进行存 或 取的操作，导致有的线程运行结果被其他线程所覆盖，导致最终结果不准确。

给存 和 取的方法  都加上 synchronized关键字就会避免这个问题。   

2、通过程序执行结果我们看到   呵呵  和  哈哈两人的账户互不影响

总结几个结论

1、是某个对象实例内，synchronized aMethod(){}可以防止多个线程同时访问这个对象的synchronized方法（如果一个对象有多个synchronized方法，只要一个线程访问了其中的一个synchronized方法，其它线程不能同时访问这个对象中任何一个synchronized方法）。这时，不同的对象实例的synchronized方法是不相干扰的。也就是说，其它线程照样可以同时访问相同类的另一个对象实例中的synchronized方法； 

2、是某个类的范围，synchronized static aStaticMethod{}防止多个线程同时访问这个类中的synchronized static 方法。它可以对类的所有对象实例起作用。

3、除了方法前用synchronized关键字，synchronized关键字还可以用于方法中的某个区块中，表示只对这个区块的资源实行互斥访问。用法是: synchronized(this){/*区块*/}，它的作用域是当前对象；