多线程同步

多线程同步的实现方式有多种：

1、同步方法：即由synchronized修饰的同步方法

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

2、同步代码块：即由synchronized修饰的语句块。

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

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

3、使用volatile：

　  每次要线程要访问volatile修饰的变量时都是从内存中读取，每个线程访问到的变量值都是一样的。这样就保证了同步。volatile不会提供任何原子操作，它也不能用来修饰final类型的变量。

4、重入锁实现线程同步：lock()

      ReentrantLock类是可重入、互斥、实现了Lock接口的锁。通常在finally代码释放锁。

5、使用局部变量实现线程同步（ThreadLocal修饰的变量）：

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

一个银行账户同时被两个线程操作，一个取100块，一个存钱100块。假设账户余额为0：

示例代码：

1、synchroized代码块示例

package com.thread;


/** 
* @author 作者：方o丈
* @version 创建时间：2018年6月10日 下午3:46:03 
* 类说明：账户操作。
* 目的：练习多线程同步。使用Synchroized同步块实现线程同步
*/
public class TestSynchroized {

    //账户
    private int account = 0;
    
    /**
     * 存钱
     * @param money
     */
    public void addMoney(int money){
        //存钱
        synchronized(this){
            account += money;
        }
        System.out.println(System.currentTimeMillis()+" 存入了："+money+"，账户余额："+account+"\n");
    }
    
    /**
     * 取钱
     * @param money
     */
    public void subTractMoney(int money){
        synchronized(this){
            if(account - money < 0){
                System.out.println(System.currentTimeMillis()+" 账户余额不足。。。\n");
                return;
            }
            //取钱
            account -= money;
        }
        System.out.println(System.currentTimeMillis()+" 取出了："+money+"，账户余额："+account+"\n");
    }
    
    /**
     * 查询余额
     */
    public void selectMoney(){
        System.out.println(account);
    }
    
}

package com.thread;


/**
 * @author 作者：方o丈
 * @version 创建时间：2018年6月10日 下午4:21:13 
 * 多线程实现方式：1：继承Thread类、2：实现 Runnable接口
 * 类说明：测试多线程同步。
 */
public class Test{

    private static int number = 10;
    
    public static void main(String[] args) {
        final TestSynchroized demo1 = new TestSynchroized();
        //创建存钱线程
        Thread addThread = new Thread(new Runnable() {
            
            @Override
            public void run() {
                while(number >0){
                    try {
                        Thread.sleep(1000);
                        demo1.addMoney(100);
                        number--;
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        });
        
        //创建取钱线程
        Thread subTractThread = new Thread(new Runnable() {
            
            @Override
            public void run() {
                while (number >0) {
                    try {
                        demo1.subTractMoney(100);
                        number--;
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        });
        
        //启动存钱线程
        addThread.start();
        //启动取钱线程
        subTractThread.start();
    }
    
}

执行结果：

 

2、可重入锁代码示例

package com.thread;

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/** 
* @author 作者：方o丈
* @version 创建时间：2018年6月10日 下午9:36:47 
* 类说明：账户操作。
* 目的：练习多线程同步。使用Lock同步块实现线程同步
*/
public class TestLock {

    //声明一个 可重入锁
    private Lock lock = new ReentrantLock();
    
    //账户
    private int account = 0;
    
    /**
     * 存钱
     * @param money
     */
    public void addMoney(int money){
        
        //获得锁
        lock.lock();
        try{
            account += money;
            System.out.println(System.currentTimeMillis()+" 存入了："+money+"，账户余额："+account+"\n");
        }finally{
            //释放锁
            lock.unlock();
        }
    }
    
    /**
     * 取钱
     * @param money
     */
    public void subTractMoney(int money){
        //获得锁
        lock.lock();
        try{
            if(account - money < 0){
                System.out.println(System.currentTimeMillis()+" 账户余额不足。。。\n");
                return;
            }
            //取钱
            account -= money;
        }finally{
            //释放锁
            lock.unlock();
        }
        System.out.println(System.currentTimeMillis()+" 取出了："+money+"，账户余额："+account+"\n");
    }
    
    /**
     * 查询余额
     */
    public void selectMoney(){
        System.out.println(account);
    }
    
}

执行结果：

 

3、局部变量（ThreadLocal修饰的变量）

 

package com.thread;


/** 
* @author 作者：方o丈
* @version 创建时间：2018年6月10日 下午10:46:03 
* 类说明：账户操作。
* 目的：练习多线程同步。使用ThreadLocal局部变量来实现
*/
public class TestThreadLocal {
    
    //账户
    private static ThreadLocal<Integer> account = new ThreadLocal<Integer>() {
        @Override
        protected Integer initialValue() {
            return 0;
        }
    };
    
    /**
     * 存钱
     * @param money
     */
    public void addMoney(int money){
        account.set(account.get() + money);
        System.out.println(System.currentTimeMillis()+" 存入了："+money+"，账户余额："+account.get()+"\n");
    }
    
    /**
     * 取钱
     * @param money
     */
    public void subTractMoney(int money){
        if(account.get() - money < 0){
            System.out.println(System.currentTimeMillis()+" 账户余额不足。。。\n");
            return;
        }
        //取钱
        account.set(account.get() - money);
        System.out.println(System.currentTimeMillis()+" 取出了："+money+"，账户余额："+account.get()+"\n");
    }
    
}

执行结果：

 

从上面三段示例代码可以看出：synchroized和ReentrantLock都能实现同步，ThreadLocal则是不适合本场景，最常见的ThreadLocal使用场景为 用来解决 数据库连接、Session管理等

synchronized跟ReentrantLock相比，有几点局限性：

• 加锁的时候不能设置超时。ReentrantLock有提供tryLock方法，可以设置超时时间，如果超过了这个时间并且没有获取到锁，就会放弃，而synchronized却没有这种功能
• ReentrantLock可以选择公平锁和非公平锁，synchronized只是简单的一个独占锁
• ReentrantLock可以使用多个Condition，而synchronized却只能有1个
• 不能中断一个试图获得锁的线程
• ReentrantLock可以获得正在等待线程的个数，计数器等

条件对象的意义在于，对于一个已经获取锁的线程，如果还需要等待其他条件才能继续执行的情况下，才会使用Condition条件对象。

 

参考网址：

https://blog.csdn.net/liuao107329/article/details/53214378

https://blog.csdn.net/pdw2009/article/details/52373947

http://www.cnblogs.com/dolphin0520/p/3920407.html