使用synchronized实现同步方法

1、简介

使用synchronized关键字来控制一个方法的并发访问。如果一个对象已用synchronized关键字声明，那么只允许一个执行线程访问它。如果其他某个线程试图访问这个对象的其他方法，它将被阻塞直到第一个线程执行完正在运行的方法。

每一个用synchronized关键字申明的方法都是临界区，在java中，同一对象的临界区，在同一时间只有一个允许被访问。

2、代码实例

package com.xxx.util;

/**
 * Created with IntelliJ IDEA.
 * Date: 15-4-21
 * Time: 下午3:45
 * To change this template use File | Settings | File Templates.
 */
public class Account {

    private double balance;

    public double getBalance() {
        return balance;
    }

    public void setBalance(double balance) {
        this.balance = balance;
    }

    public synchronized void addAmount(double amount){
        double temp = balance;
        temp +=amount;
        try {
            Thread.sleep(10);//模拟其它处理所需要的时间，比如刷新数据库等
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        balance = temp;
    }

    public synchronized void subtractAmount(double amount){
        double temp = balance;
        temp -=amount;
        try {
            Thread.sleep(10);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        balance = temp;
    }

}

package com.xxx.util;

/**
 * Created with IntelliJ IDEA.
 * Date: 15-4-21
 * Time: 下午3:51
 * To change this template use File | Settings | File Templates.
 */
public class Bank implements Runnable {

    private Account account;

    public Bank(Account account){
        this.account = account;
    }

    @Override
    public void run() {
        for(int i=0;i<100;i++){
            account.subtractAmount(1000);
        }
    }
}

package com.xxx.util;

/**
 * Created with IntelliJ IDEA.
 * Date: 15-4-21
 * Time: 下午3:54
 * To change this template use File | Settings | File Templates.
 */
public class Company implements Runnable {

    private Account account;

    public Company(Account account){
        this.account = account;
    }

    @Override
    public void run() {
        for(int i=0;i<100;i++){
            account.addAmount(1000);
        }
    }
}

package com.xxx.util;

/**
 * Created with IntelliJ IDEA.
 * Date: 15-4-21
 * Time: 下午3:56
 * To change this template use File | Settings | File Templates.
 */
public class SynchronizedThreadMain {

    public static void main(String[] args){
        Account account = new Account();
        account.setBalance(1000);
        System.out.printf("Acount: initial balance:%.2f\n",account.getBalance());
        Company company = new Company(account);
        Thread companyThread = new Thread(company);
        Bank bank = new Bank(account);
        Thread bankThread = new Thread(bank);
        companyThread.start();
        bankThread.start();
        try {
            companyThread.join();//等待线程companyThread运行结束
            bankThread.join();
            System.out.printf("Acount: final balance:%.2f\n",account.getBalance());
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

}

3、运行结果

4、总结

（1）、synchronized关键字的作用域有二种： 
1）是某个对象实例内，synchronized aMethod(){}可以防止多个线程同时访问这个对象的synchronized方法（如果一个对象有多个synchronized方法，只要一个线程访问了其中的一个synchronized方法，其它线程不能同时访问这个对象中任何一个synchronized方法）。这时，不同的对象实例的synchronized方法是不相干扰的。也就是说，其它线程照样可以同时访问相同类的另一个对象实例中的synchronized方法； 
2）是某个类的范围，synchronized static aStaticMethod{}防止多个线程同时访问这个类中的synchronized static 方法。它可以对类的所有对象实例起作用。

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

（3）、synchronized关键字是不能继承的，也就是说，基类的方法synchronized f(){} 在继承类中并不自动是synchronized f(){}，而是变成了f(){}。继承类需要你显式的指定它的某个方法为synchronized方法；

Java语言的关键字，当它用来修饰一个方法或者一个代码块的时候，能够保证在同一时刻最多只有一个线程执行该段代码。

     一、当两个并发线程访问同一个对象object中的这个synchronized(this)同步代码块时，一个时间内只能有一个线程得到执行。另一个线程必须等待当前线程执行完这个代码块以后才能执行该代码块。

     二、然而，当一个线程访问object的一个synchronized(this)同步代码块时，另一个线程仍然可以访问该object中的非synchronized(this)同步代码块。

     三、尤其关键的是，当一个线程访问object的一个synchronized(this)同步代码块时，其他线程对object中所有其它synchronized(this)同步代码块的访问将被阻塞。

     四、当一个线程访问object的一个synchronized(this)同步代码块时，它就获得了这个object的对象锁。结果，其它线程对该object对象所有同步代码部分的访问都被暂时阻塞。

     五、以上规则对其它对象锁同样适用.