java多线程同步5种方法

一、引言

前几天面试，被大师虐残了，好多基础知识必须得重新拿起来啊。闲话不多说，进入正题。

二、为什么要线程同步

因为当我们有多个线程要同时访问一个变量或对象时，如果这些线程中既有读又有写操作时，就会导致变量值或对象的状态出现混乱，从而导致程序异常。举个例子，如果一个银行账户同时被两个线程操作，一个取100块，一个存钱100块。假设账户原本有0块，如果取钱线程和存钱线程同时发生，会出现什么结果呢？取钱不成功，账户余额是100.取钱成功了，账户余额是0.那到底是哪个呢？很难说清楚。因此多线程同步就是要解决这个问题。

三、不同步时的代码

Bank.java

[java]  view plain  copy

1. package threadTest;  
2.   
3. /** 
4.  * @author ww 
5.  * 
6.  */  
7. public class Bank {  
8.   
9.     private int count =0;//账户余额  
10.       
11.     //存钱  
12.     public  void addMoney(int money){  
13.         count +=money;  
14.         System.out.println(System.currentTimeMillis()+"存进："+money);  
15.     }  
16.       
17.     //取钱  
18.     public  void subMoney(int money){  
19.         if(count-money < 0){  
20.             System.out.println("余额不足");  
21.             return;  
22.         }  
23.         count -=money;  
24.         System.out.println(+System.currentTimeMillis()+"取出："+money);  
25.     }  
26.       
27.     //查询  
28.     public void lookMoney(){  
29.         System.out.println("账户余额："+count);  
30.     }  
31. }  

SyncThreadTest.java

[java]  view plain  copy

1. package threadTest;  
2.   
3.   
4. public class SyncThreadTest {  
5.   
6.     public static void main(String args[]){  
7.         final Bank bank=new Bank();  
8.           
9.         Thread tadd=new Thread(new Runnable() {  
10.               
11.             @Override  
12.             public void run() {  
13.                 // TODO Auto-generated method stub  
14.                 while(true){  
15.                     try {  
16.                         Thread.sleep(1000);  
17.                     } catch (InterruptedException e) {  
18.                         // TODO Auto-generated catch block  
19.                         e.printStackTrace();  
20.                     }  
21.                     bank.addMoney(100);  
22.                     bank.lookMoney();  
23.                     System.out.println("\n");  
24.                       
25.                 }  
26.             }  
27.         });  
28.           
29.         Thread tsub = new Thread(new Runnable() {  
30.               
31.             @Override  
32.             public void run() {  
33.                 // TODO Auto-generated method stub  
34.                 while(true){  
35.                     bank.subMoney(100);  
36.                     bank.lookMoney();  
37.                     System.out.println("\n");  
38.                     try {  
39.                         Thread.sleep(1000);  
40.                     } catch (InterruptedException e) {  
41.                         // TODO Auto-generated catch block  
42.                         e.printStackTrace();  
43.                     }     
44.                 }  
45.             }  
46.         });  
47.         tsub.start();  
48.           
49.         tadd.start();  
50.     }  
51.       
52.       
53.   
54. }  

代码很简单，我就不解释了，看看运行结果怎样呢？截取了其中的一部分，是不是很乱，有写看不懂。

[java]  view plain  copy

1. 余额不足  
2. 账户余额：0  
3.   
4.   
5. 余额不足  
6. 账户余额：100  
7.   
8.   
9. 1441790503354存进：100  
10. 账户余额：100  
11.   
12.   
13. 1441790504354存进：100  
14. 账户余额：100  
15.   
16.   
17. 1441790504354取出：100  
18. 账户余额：100  
19.   
20.   
21. 1441790505355存进：100  
22. 账户余额：100  
23.   
24.   
25. 1441790505355取出：100  
26. 账户余额：100  

四、使用同步时的代码

（1）同步方法：

即有synchronized关键字修饰的方法。 由于java的每个对象都有一个内置锁，当用此关键字修饰方法时，内置锁会保护整个方法。在调用该方法前，需要获得内置锁，否则就处于阻塞状态。

修改后的Bank.java

[java]  view plain  copy

1. package threadTest;  
2.   
3. /** 
4.  * @author ww 
5.  * 
6.  */  
7. public class Bank {  
8.   
9.     private int count =0;//账户余额  
10.       
11.     //存钱  
12.     public  synchronized void addMoney(int money){  
13.         count +=money;  
14.         System.out.println(System.currentTimeMillis()+"存进："+money);  
15.     }  
16.       
17.     //取钱  
18.     public  synchronized void subMoney(int money){  
19.         if(count-money < 0){  
20.             System.out.println("余额不足");  
21.             return;  
22.         }  
23.         count -=money;  
24.         System.out.println(+System.currentTimeMillis()+"取出："+money);  
25.     }  
26.       
27.     //查询  
28.     public void lookMoney(){  
29.         System.out.println("账户余额："+count);  
30.     }  
31. }  

再看看运行结果：

[html]  view plain  copy

1. 余额不足  
2. 账户余额：0  
3.   
4.   
5. 余额不足  
6. 账户余额：0  
7.   
8.   
9. 1441790837380存进：100  
10. 账户余额：100  
11.   
12.   
13. 1441790838380取出：100  
14. 账户余额：0  
15. 1441790838380存进：100  
16. 账户余额：100  
17.   
18.   
19.   
20.   
21. 1441790839381取出：100  
22. 账户余额：0  

瞬间感觉可以理解了吧。

注： synchronized关键字也可以修饰静态方法，此时如果调用该静态方法，将会锁住整个类

（2）同步代码块

即有synchronized关键字修饰的语句块。被该关键字修饰的语句块会自动被加上内置锁，从而实现同步

Bank.java代码如下：

[java]  view plain  copy

1. package threadTest;  
2.   
3. /** 
4.  * @author ww 
5.  * 
6.  */  
7. public class Bank {  
8.   
9.     private int count =0;//账户余额  
10.       
11.     //存钱  
12.     public   void addMoney(int money){  
13.           
14.         synchronized (this) {  
15.             count +=money;  
16.         }  
17.         System.out.println(System.currentTimeMillis()+"存进："+money);  
18.     }  
19.       
20.     //取钱  
21.     public   void subMoney(int money){  
22.           
23.         synchronized (this) {  
24.             if(count-money < 0){  
25.                 System.out.println("余额不足");  
26.                 return;  
27.             }  
28.             count -=money;  
29.         }  
30.         System.out.println(+System.currentTimeMillis()+"取出："+money);  
31.     }  
32.       
33.     //查询  
34.     public void lookMoney(){  
35.         System.out.println("账户余额："+count);  
36.     }  
37. }  

运行结果如下：

[html]  view plain  copy

1. 余额不足  
2. 账户余额：0  
3.   
4.   
5. 1441791806699存进：100  
6. 账户余额：100  
7.   
8.   
9. 1441791806700取出：100  
10. 账户余额：0  
11.   
12.   
13. 1441791807699存进：100  
14. 账户余额：100  

效果和方法一差不多。

注：同步是一种高开销的操作，因此应该尽量减少同步的内容。通常没有必要同步整个方法，使用synchronized代码块同步关键代码即可。

（3）使用特殊域变量(volatile)实现线程同步

    a.volatile关键字为域变量的访问提供了一种免锁机制 
    b.使用volatile修饰域相当于告诉虚拟机该域可能会被其他线程更新 
    c.因此每次使用该域就要重新计算，而不是使用寄存器中的值 
    d.volatile不会提供任何原子操作，它也不能用来修饰final类型的变量

Bank.java代码如下：

[java]  view plain  copy

1. package threadTest;  
2.   
3. /** 
4.  * @author ww 
5.  * 
6.  */  
7. public class Bank {  
8.   
9.     private volatile int count = 0;// 账户余额  
10.   
11.     // 存钱  
12.     public void addMoney(int money) {  
13.   
14.         count += money;  
15.         System.out.println(System.currentTimeMillis() + "存进：" + money);  
16.     }  
17.   
18.     // 取钱  
19.     public void subMoney(int money) {  
20.   
21.         if (count - money < 0) {  
22.             System.out.println("余额不足");  
23.             return;  
24.         }  
25.         count -= money;  
26.         System.out.println(+System.currentTimeMillis() + "取出：" + money);  
27.     }  
28.   
29.     // 查询  
30.     public void lookMoney() {  
31.         System.out.println("账户余额：" + count);  
32.     }  
33. }  

运行效果怎样呢？

[html]  view plain  copy

1. 余额不足  
2. 账户余额：0  
3.   
4.   
5. 余额不足  
6. 账户余额：100  
7.   
8.   
9. 1441792010959存进：100  
10. 账户余额：100  
11.   
12.   
13. 1441792011960取出：100  
14. 账户余额：0  
15.   
16.   
17. 1441792011961存进：100  
18. 账户余额：100  

是不是又看不懂了，又乱了。这是为什么呢？就是因为volatile不能保证原子操作导致的，因此volatile不能代替synchronized。此外volatile会组织编译器对代码优化，因此能不使用它就不适用它吧。 它的原理是每次要线程要访问volatile修饰的变量时都是从内存中读取，而不是存缓存当中读取，因此每个线程访问到的变量值都是一样的。这样就保证了同步。

（4）使用重入锁实现线程同步

    在JavaSE5.0中新增了一个java.util.concurrent包来支持同步。ReentrantLock类是可重入、互斥、实现了Lock接口的锁， 它与使用synchronized方法和快具有相同的基本行为和语义，并且扩展了其能力。
     ReenreantLock类的常用方法有：
         ReentrantLock() : 创建一个ReentrantLock实例 
         lock() : 获得锁 
         unlock() : 释放锁 
    注：ReentrantLock()还有一个可以创建公平锁的构造方法，但由于能大幅度降低程序运行效率，不推荐使用 
Bank.java代码修改如下：

[java]  view plain  copy

1. package threadTest;  
2.   
3. import java.util.concurrent.locks.Lock;  
4. import java.util.concurrent.locks.ReentrantLock;  
5.   
6. /** 
7.  * @author ww 
8.  * 
9.  */  
10. public class Bank {  
11.   
12.     private  int count = 0;// 账户余额  
13.       
14.     //需要声明这个锁  
15.     private Lock lock = new ReentrantLock();  
16.   
17.     // 存钱  
18.     public void addMoney(int money) {  
19.         lock.lock();//上锁  
20.         try{  
21.         count += money;  
22.         System.out.println(System.currentTimeMillis() + "存进：" + money);  
23.           
24.         }finally{  
25.             lock.unlock();//解锁  
26.         }  
27.     }  
28.   
29.     // 取钱  
30.     public void subMoney(int money) {  
31.         lock.lock();  
32.         try{  
33.               
34.         if (count - money < 0) {  
35.             System.out.println("余额不足");  
36.             return;  
37.         }  
38.         count -= money;  
39.         System.out.println(+System.currentTimeMillis() + "取出：" + money);  
40.         }finally{  
41.             lock.unlock();  
42.         }  
43.     }  
44.   
45.     // 查询  
46.     public void lookMoney() {  
47.         System.out.println("账户余额：" + count);  
48.     }  
49. }  

运行效果怎么样呢？

[html]  view plain  copy

1. 余额不足  
2. 账户余额：0  
3.   
4.   
5. 余额不足  
6. 账户余额：0  
7.   
8.   
9. 1441792891934存进：100  
10. 账户余额：100  
11.   
12.   
13. 1441792892935存进：100  
14. 账户余额：200  
15.   
16.   
17. 1441792892954取出：100  
18. 账户余额：100  

效果和前两种方法差不多。

如果synchronized关键字能满足用户的需求，就用synchronized，因为它能简化代码 。如果需要更高级的功能，就用ReentrantLock类，此时要注意及时释放锁，否则会出现死锁，通常在finally代码释放锁 

（5）使用局部变量实现线程同步

Bank.java代码如下：

[java]  view plain  copy

1. package threadTest;  
2.   
3.   
4. /** 
5.  * @author ww 
6.  * 
7.  */  
8. public class Bank {  
9.   
10.     private static ThreadLocal<Integer> count = new ThreadLocal<Integer>(){  
11.   
12.         @Override  
13.         protected Integer initialValue() {  
14.             // TODO Auto-generated method stub  
15.             return 0;  
16.         }  
17.           
18.     };  
19.       
20.   
21.     // 存钱  
22.     public void addMoney(int money) {  
23.         count.set(count.get()+money);  
24.         System.out.println(System.currentTimeMillis() + "存进：" + money);  
25.           
26.     }  
27.   
28.     // 取钱  
29.     public void subMoney(int money) {  
30.         if (count.get() - money < 0) {  
31.             System.out.println("余额不足");  
32.             return;  
33.         }  
34.         count.set(count.get()- money);  
35.         System.out.println(+System.currentTimeMillis() + "取出：" + money);  
36.     }  
37.   
38.     // 查询  
39.     public void lookMoney() {  
40.         System.out.println("账户余额：" + count.get());  
41.     }  
42. }  

运行效果：

[html]  view plain  copy

1. 余额不足  
2. 账户余额：0  
3.   
4.   
5. 余额不足  
6. 账户余额：0  
7.   
8.   
9. 1441794247939存进：100  
10. 账户余额：100  
11.   
12.   
13. 余额不足  
14. 1441794248940存进：100  
15. 账户余额：0  
16.   
17.   
18. 账户余额：200  
19.   
20.   
21. 余额不足  
22. 账户余额：0  
23.   
24.   
25. 1441794249941存进：100  
26. 账户余额：300  

看了运行效果，一开始一头雾水，怎么只让存，不让取啊？看看ThreadLocal的原理：

如果使用ThreadLocal管理变量，则每一个使用该变量的线程都获得该变量的副本，副本之间相互独立，这样每一个线程都可以随意修改自己的变量副本，而不会对其他线程产生影响。现在明白了吧，原来每个线程运行的都是一个副本，也就是说存钱和取钱是两个账户，知识名字相同而已。所以就会发生上面的效果。

ThreadLocal与同步机制 
a.ThreadLocal与同步机制都是为了解决多线程中相同变量的访问冲突问题

b.前者采用以"空间换时间"的方法，后者采用以"时间换空间"的方式 

同步的方法：

一、同步方法

　　即有synchronized关键字修饰的方法。 由于java的每个对象都有一个内置锁，当用此关键字修饰方法时， 内置锁会保护整个方法。在调用该方法前，需要获得内置锁，否则就处于阻塞状态。

注： synchronized关键字也可以修饰静态方法，此时如果调用该静态方法，将会锁住整个类。

 

二、同步代码块

　　即有synchronized关键字修饰的语句块。 被该关键字修饰的语句块会自动被加上内置锁，从而实现同步

    代码如： 

synchronized(object){ 
}

    注：同步是一种高开销的操作，因此应该尽量减少同步的内容。通常没有必要同步整个方法，使用synchronized代码块同步关键代码即可。 

    package com.xhj.thread;
 
    /**
     * 线程同步的运用
     * 
     * @author XIEHEJUN
     * 
     */
    public class SynchronizedThread {
 
        class Bank {
            private int account = 100;
            public int getAccount() {
                return account;
            }
 
            /**
             * 用同步方法实现
             * 
             * @param money
             */
            public synchronized void save(int money) {
                account += money;
            }
 
            /**
             * 用同步代码块实现
             * 
             * @param money
             */
            public void save1(int money) {
                synchronized (this) {
                    account += money;
                }
            }
        }

class NewThread implements Runnable {
            private Bank bank;
 
            public NewThread(Bank bank) {
                this.bank = bank;
            }
 
            @Override
            public void run() {
                for (int i = 0; i < 10; i++) {
                    // bank.save1(10);
                    bank.save(10);
                    System.out.println(i + "账户余额为：" + bank.getAccount());
                }
            }
 
        }
 
        /**
         * 建立线程，调用内部类
         */
        public void useThread() {
            Bank bank = new Bank();
            NewThread new_thread = new NewThread(bank);
            System.out.println("线程1");
            Thread thread1 = new Thread(new_thread);
            thread1.start();
            System.out.println("线程2");
            Thread thread2 = new Thread(new_thread);
            thread2.start();
        }
 
        public static void main(String[] args) {
            SynchronizedThread st = new SynchronizedThread();
            st.useThread();
        }
 
    }

 

        

=====================================

示例加讲解

同步是多线程中的重要概念。同步的使用可以保证在多线程运行的环境中，程序不会产生设计之外的错误结果。同步的实现方式有两种，同步方法和同步块，这两种方式都要用到synchronized关键字。

同步方法:给一个方法增加synchronized修饰符之后就可以使它成为同步方法，这个方法可以是静态方法和非静态方法，但是不能是抽象类的抽象方法，也不能是接口中的接口方法。下面代码是一个同步方法的示例：

public synchronized void aMethod() { 
    // do something 
} 

public static synchronized void anotherMethod() { 
    // do something 
} 

线程在执行同步方法时是具有排它性的。当任意一个线程进入到一个对象的任意一个同步方法时，这个对象的所有同步方法都被锁定了，在此期间，其他任何线程都不能访问这个对象的任意一个同步方法，直到这个线程执行完它所调用的同步方法并从中退出，从而导致它释放了该对象的同步锁之后。在一个对象被某个线程锁定之后，其他线程是可以访问这个对象的所有非同步方法的。

同步块：同步块是通过锁定一个指定的对象，来对同步块中包含的代码进行同步；而同步方法是对这个方法块里的代码进行同步，而这种情况下锁定的对象就是同步方法所属的主体对象自身。如果这个方法是静态同步方法呢？那么线程锁定的就不是这个类的对象了，也不是这个类自身，而是这个类对应的java.lang.Class类型的对象。同步方法和同步块之间的相互制约只限于同一个对象之间，所以静态同步方法只受它所属类的其它静态同步方法的制约，而跟这个类的实例（对象）没有关系。

如果一个对象既有同步方法，又有同步块，那么当其中任意一个同步方法或者同步块被某个线程执行时，这个对象就被锁定了，其他线程无法在此时访问这个对象的同步方法，也不能执行同步块。

synchronized 关键字用于保护共享数据。请大家注意“共享数据”，你一定要分清哪些数据是共享数据，请看下面的例子：

public class ThreadTest implements Runnable{

public synchronized void run(){
　　for(int i=0;i<10;i++) {
　　　　System.out.print(" " + i);
　　}
}

public static void main(String[] args) {
　　Runnable r1 = new ThreadTest(); //也可写成ThreadTest r1 = new ThreadTest();
　　Runnable r2 = new ThreadTest();
　　Thread t1 = new Thread(r1);
　　Thread t2 = new Thread(r2);
　　t1.start();
　　t2.start();
}}

 

在这个程序中，run()虽然被加上了synchronized 关键字，但保护的不是共享数据。因为这个程序中的t1,t2 是两个对象（r1,r2）的线程。而不同的对象的数据是不同的，r1,r2 有各自的run()方法，所以输出结果无法预知。

synchronized的目的是使同一个对象的多个线程，在某个时刻只有其中的一个线程可以访问这个对象的synchronized 数据。每个对象都有一个“锁标志”，当这个对象的一个线程访问这个对象的某个synchronized 数据时，这个对象的所有被synchronized 修饰的数据将被上锁（因为“锁标志”被当前线程拿走了），只有当前线程访问完它要访问的synchronized 数据时，当前线程才会释放“锁标志”，这样同一个对象的其它线程才有机会访问synchronized 数据。

示例3：

public class ThreadTest implements Runnable{

public synchronized void run(){
　　for(int i=0;i<10;i++){
　　　　System.out.print(" " + i);
　　}
}

public static void main(String[] args){
　　Runnable r = new ThreadTest();
　　Thread t1 = new Thread(r);
　　Thread t2 = new Thread(r);
　　t1.start();
　　t2.start();
}}

 

如果你运行1000 次这个程序，它的输出结果也一定每次都是：0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9。因为这里的synchronized 保护的是共享数据。t1,t2 是同一个对象（r）的两个线程，当其中的一个线程（例如：t1）开始执行run()方法时，由于run()受synchronized保护，所以同一个对象的其他线程（t2）无法访问synchronized 方法（run 方法）。只有当t1执行完后t2 才有机会执行。

示例4：

public class ThreadTest implements Runnable{

public void run(){

    synchronized(this){
    for(int i=0;i<10;i++){
        System.out.print(" " + i);
    }
} 
}

public static void main(String[] args){
    Runnable r = new ThreadTest();
    Thread t1 = new Thread(r);
    Thread t2 = new Thread(r);
    t1.start();
    t2.start();
}
}    

 

这个程序与示例3 的运行结果一样。在可能的情况下，应该把保护范围缩到最小，可以用示例4 的形式，this 代表“这个对象”。没有必要把整个run()保护起来，run()中的代码只有一个for循环，所以只要保护for 循环就可以了。

示例5：

public class ThreadTest implements Runnable{

public void run(){
　　for(int k=0;k<5;k++){
　　　　System.out.println(Thread.currentThread().getName()+ " : for loop : " + k);
　　}

synchronized(this){
　　for(int k=0;k<5;k++) {
　　　　System.out.println(Thread.currentThread().getName()+ " : synchronized for loop : " + k);
　　}} }

public static void main(String[] args){
　　Runnable r = new ThreadTest();
　　Thread t1 = new Thread(r,"t1_name");
　　Thread t2 = new Thread(r,"t2_name");
　　t1.start();
　　t2.start();
} }

 

运行结果：

t1_name : for loop : 0

t1_name : for loop : 1

t1_name : for loop : 2

t2_name : for loop : 0

t1_name : for loop : 3

t2_name : for loop : 1

t1_name : for loop : 4

t2_name : for loop : 2

t1_name : synchronized for loop : 0

t2_name : for loop : 3

t1_name : synchronized for loop : 1

t2_name : for loop : 4

t1_name : synchronized for loop : 2

t1_name : synchronized for loop : 3

t1_name : synchronized for loop : 4

t2_name : synchronized for loop : 0

t2_name : synchronized for loop : 1

t2_name : synchronized for loop : 2

t2_name : synchronized for loop : 3

t2_name : synchronized for loop : 4

第一个for 循环没有受synchronized 保护。对于第一个for 循环，t1,t2 可以同时访问。运行结果表明t1 执行到了k=2 时，t2 开始执行了。t1 首先执行完了第一个for 循环，此时t2还没有执行完第一个for 循环（t2 刚执行到k=2）。t1 开始执行第二个for 循环，当t1的第二个for 循环执行到k=1 时，t2 的第一个for 循环执行完了。t2 想开始执行第二个for 循环，但由于t1 首先执行了第二个for 循环，这个对象的锁标志自然在t1 手中（synchronized 方法的执行权也就落到了t1 手中），在t1 没执行完第二个for 循环的时候，它是不会释放锁标志的。所以t2 必须等到t1 执行完第二个for 循环后，它才可以执行第二个for 循环。

=====================================

三、wait与notify

wait():使一个线程处于等待状态，并且释放所持有的对象的lock。

sleep():使一个正在运行的线程处于睡眠状态，是一个静态方法，调用此方法要捕捉InterruptedException异常。
notify():唤醒一个处于等待状态的线程，注意的是在调用此方法的时候，并不能确切的唤醒某一个等待状态的线程，而是由JVM确定唤醒哪个线程，而且不是按优先级。
Allnotity():唤醒所有处入等待状态的线程，注意并不是给所有唤醒线程一个对象的锁，而是让它们竞争。

详细见：wait、notify、notifyAll的使用方法

四、使用特殊域变量(volatile)实现线程同步

    a.volatile关键字为域变量的访问提供了一种免锁机制

    b.使用volatile修饰域相当于告诉虚拟机该域可能会被其他线程更新

    c.因此每次使用该域就要重新计算，而不是使用寄存器中的值 

    d.volatile不会提供任何原子操作，它也不能用来修饰final类型的变量 

    

    例如： 

        在上面的例子当中，只需在account前面加上volatile修饰，即可实现线程同步。 

    

    代码实例： 

 

        //只给出要修改的代码，其余代码与上同
        class Bank {
            //需要同步的变量加上volatile
            private volatile int account = 100;
 
            public int getAccount() {
                return account;
            }
            //这里不再需要synchronized 
            public void save(int money) {
                account += money;
            }
        ｝

    注：多线程中的非同步问题主要出现在对域的读写上，如果让域自身避免这个问题，则就不需要修改操作该域的方法。 

    用final域，有锁保护的域和volatile域可以避免非同步的问题。 

五、使用重入锁实现线程同步

    在 JavaSE5.0中新增了一个java.util.concurrent包来支持同步。 

    ReentrantLock类是可重入、互斥、实现了Lock接口的锁，它与使用synchronized方法和快具有相同的基本行为和语义，并且扩展了其能力。

 ReenreantLock类的常用方法有：

ReentrantLock() : 创建一个ReentrantLock实例 
lock() : 获得锁 
unlock() : 释放锁 

注：ReentrantLock()还有一个可以创建公平锁的构造方法，但由于能大幅度降低程序运行效率，不推荐使用 

        

    例如： 

        在上面例子的基础上，改写后的代码为: 

       //只给出要修改的代码，其余代码与上同
        class Bank {
            
            private int account = 100;
            //需要声明这个锁
            private Lock lock = new ReentrantLock();
            public int getAccount() {
                return account;
            }
            //这里不再需要synchronized 
            public void save(int money) {
                lock.lock();
                try{
                    account += money;
                }finally{
                    lock.unlock();
                }
                
            }
        ｝

     注：关于Lock对象和synchronized关键字的选择： 

        a.最好两个都不用，使用一种java.util.concurrent包提供的机制，能够帮助用户处理所有与锁相关的代码。 

        b.如果synchronized关键字能满足用户的需求，就用synchronized，因为它能简化代码 

        c.如果需要更高级的功能，就用ReentrantLock类，此时要注意及时释放锁，否则会出现死锁，通常在finally代码释放锁 

 

六、使用局部变量实现线程同步

    如果使用ThreadLocal管理变量，则每一个使用该变量的线程都获得该变量的副本，副本之间相互独立，这样每一个线程都可以随意修改自己的变量副本，而不会对其他线程产生影响。

     ThreadLocal 类的常用方法

ThreadLocal() : 创建一个线程本地变量 
get() : 返回此线程局部变量的当前线程副本中的值 
initialValue() : 返回此线程局部变量的当前线程的"初始值" 
set(T value) : 将此线程局部变量的当前线程副本中的值设置为value

    例如： 

        在上面例子基础上，修改后的代码为： 

        //只改Bank类，其余代码与上同
        public class Bank{
            //使用ThreadLocal类管理共享变量account
            private static ThreadLocal<Integer> account = new ThreadLocal<Integer>(){
                @Override
                protected Integer initialValue(){
                    return 100;
                }
            };
            public void save(int money){
                account.set(account.get()+money);
            }
            public int getAccount(){
                return account.get();
            }
        }

    注：ThreadLocal与同步机制 

        a.ThreadLocal与同步机制都是为了解决多线程中相同变量的访问冲突问题。 

        b.前者采用以"空间换时间"的方法，后者采用以"时间换空间"的方式

 

七、使用阻塞队列实现线程同步

前面5种同步方式都是在底层实现的线程同步，但是我们在实际开发当中，应当尽量远离底层结构。 使用javaSE5.0版本中新增的java.util.concurrent包将有助于简化开发。 本小节主要是使用LinkedBlockingQueue<E>来实现线程的同步 LinkedBlockingQueue<E>是一个基于已连接节点的，范围任意的blocking queue。 队列是先进先出的顺序（FIFO），关于队列以后会详细讲解~LinkedBlockingQueue 类常用方法 LinkedBlockingQueue() : 创建一个容量为Integer.MAX_VALUE的LinkedBlockingQueue put(E e) : 在队尾添加一个元素，如果队列满则阻塞 size() : 返回队列中的元素个数 take() : 移除并返回队头元素，如果队列空则阻塞代码实例： 实现商家生产商品和买卖商品的同步

注：BlockingQueue<E>定义了阻塞队列的常用方法，尤其是三种添加元素的方法，我们要多加注意，当队列满时：

　　add()方法会抛出异常

　　offer()方法返回false

　　put()方法会阻塞

7.使用原子变量实现线程同步

需要使用线程同步的根本原因在于对普通变量的操作不是原子的。

那么什么是原子操作呢？原子操作就是指将读取变量值、修改变量值、保存变量值看成一个整体来操作即-这几种行为要么同时完成，要么都不完成。在java的util.concurrent.atomic包中提供了创建了原子类型变量的工具类，使用该类可以简化线程同步。其中AtomicInteger 表可以用原子方式更新int的值，可用在应用程序中(如以原子方式增加的计数器)，但不能用于替换Integer；可扩展Number，允许那些处理机遇数字类的工具和实用工具进行统一访问。

AtomicInteger类常用方法：

AtomicInteger(int initialValue) : 创建具有给定初始值的新的

AtomicIntegeraddAddGet(int dalta) : 以原子方式将给定值与当前值相加

get() : 获取当前值

代码实例：

只改Bank类，其余代码与上面第一个例子同

class Bank {
    private AtomicInteger account = new AtomicInteger(100);
    public AtomicInteger getAccount() {
        return account; 
    } 
    public void save(int money) {
        account.addAndGet(money);
    }
}

补充--原子操作主要有：　　

对于引用变量和大多数原始变量(long和double除外)的读写操作；　　

对于所有使用volatile修饰的变量(包括long和double)的读写操作。