Java多线程——Java线程同步问题

什么是线程同步

• 同步问题的提出
  现实生活中，我们会遇到“同一个资源，多个人都想使用”的问题。比如：一个拥有好装备的游戏账号，多个人都想使用装大佬。这样，天然的解决办法就是，前一个人使用结束后，后一个人再进行使用。
• 线程同步的概念
  处理多线程的问题时，多个线程访问同一个对象，并且某些线程还想修改这个对象。这时候，我们就需要用到“线程同步”。线程同步其实就是一种等待机制，多个需要同时访问此对象的线程进入这个对象的等待池形成队列，等待前面的线程使用完毕后，下一个线程再使用。

下面看一个小Demo，多线程操作同一个对象（未使用线程同步）

package com.shenqi.sync;

public class TestSync {

    public static void main(String[] args) {
        Account account = new Account(100, "某某某");
        Drawings baby = new Drawings(60, account);//本宝宝进行取钱
        baby.start();
        Drawings bebe = new Drawings(60, account);//我劳工贝贝进行取钱
        bebe.start();
    }

}


/**
 * 
 * @author xiaobaiyang
 *  简单表示银行账户类
 *
 */
class Account{

    int money;

    String name;

    public Account(int money, String name) {
        super();
        this.money = money;
        this.name = name;
    }

}


/**
 * 
 * @author xiaobaiyang
 *  模拟提款操作
 */
class Drawings extends Thread{

    //取多少钱
    int drawingNum;
    //要取钱的账户
    Account account;
    //总共取的钱数
    int expenseTotal;

    public Drawings(int drawingNum, Account account) {
        super();
        this.drawingNum = drawingNum;
        this.account = account;
    }

    @Override
    public void run() {
        if(account.money - drawingNum < 0){
            return;
        }

        try {
            //判断完后阻塞。其他线程开始运行。
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        account.money -= drawingNum;
        expenseTotal += drawingNum;
        System.out.println(this.getName() + " 账户余额：" + account.money);
        System.out.println(this.getName() + " 总共取了：" + expenseTotal);
    }


}

运行结果如下所示：

Thread-0 账户余额：-20
Thread-1 账户余额：-20
Thread-0 总共取了：60
Thread-1 总共取了：60

没有线程同步机制，两个线程同时操作同一个账户对象，本宝宝和我劳工贝贝竟然从仅有100元的账户，轻轻松松的取出 60 * 2 = 120元，账户余额竟然成为了-20。这么大的问题，银行肯定不会允许这样操作的。不然的话，我和我劳工贝贝肯定会一夜暴富的呢。

实现线程同步

由于同一进程的多个线程共享同一块存储空间，在带来方便的同时，也带来了访问冲突的问题。Java语言提供了专门的机制来解决这种冲突，有效避免了同一个数据对象被多个线程同时访问造成的这种问题。

由于我们可以通过private关键字来保证数据对象只能被方法访问，所以我们只需针对方法提出一套机制，这套机制就是synchronized关键字，它包含两种用法：synchronized方法和synchronized块。

• synchronized方法
  通过在方法声明中加入synchronized关键字来声明，语法如下：

public synchronized void methodName(int args);

• synchronized方法控制对“对象的类成员变量”的访问：每个对象对应一把锁，每个synchronized方法都必须获得调用该方法的对象的锁方能执行，否则所属线程阻塞，方法一旦执行，就独占该锁，直到从该方法返回时才将锁释放，此后被阻塞的线程方能获得该锁。重新进入可执行状态。
• synchronized块
  synchronized方法的缺陷：若将一个大的方法声明为synchronized将会大大影响效率。
  Java为我们提供了更好的解决方法，那就是synchronized块。块可以让我们精确地控制到具体的“成员变量”，缩小同步的范围，提高效率。
  synchronized：通过synchronized关键字来声明synchronized块，语法如下：

synchronized(syncObject){

        //允许访问控制的代码

    }

知道了synchronized关键字的用法，下面来看一个小Demo。多线程操作同一个对象（使用线程同步）

package com.shenqi.sync;

public class TestSyncOne{

    public static void main(String[] args) {
        AccountOne account = new AccountOne(100, "小白阳");
        DrawingsOne baby = new DrawingsOne(60, account);//本宝宝进行取钱
        baby.start();
        DrawingsOne bebe = new DrawingsOne(60, account);//我劳工贝贝进行取钱
        bebe.start();
    }

}


/**
* 
* @author xiaobaiyang
*   简单表示银行账户类
*
*/
class AccountOne{

    int money;

    String name;

    public AccountOne(int money, String name) {
        super();
        this.money = money;
        this.name = name;
    }

}


/**
* 
* @author xiaobaiyang
*   模拟提款操作
*/
class DrawingsOne extends Thread{

    //取多少钱
    int drawingNum;
    //要取钱的账户
    AccountOne accountone;
    //总共取的钱数
    int expenseTotal;

    public DrawingsOne(int drawingNum, AccountOne account) {
        super();
        this.drawingNum = drawingNum;
        this.accountone = account;
    }

    @Override
    public void run() {
        withdraw();
    }

    private void withdraw() {

        synchronized (accountone) {
            if(accountone.money - drawingNum < 0){
                System.out.println(this.getName() + "取款，余额不足！");
                return;
            }

            try {
                //判断完后阻塞。其他线程开始运行。
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            accountone.money -= drawingNum;
            expenseTotal += drawingNum;
            System.out.println(this.getName() + " 账户余额：" + accountone.money);
            System.out.println(this.getName() + " 总共取了：" + expenseTotal);
        }

    }

}

运行结果如下所示：

Thread-0 账户余额：40
Thread-0 总共取了：60
Thread-1取款，余额不足！

“synchronized (accountone) “意味着线程需要获得account对象的“锁”才有资格运行同步块中的代码。AccountOne对象的“锁”也称为“互斥锁”，在同一时刻只能被一个线程使用。线程A拥有锁，则可以调用“同步块”中的代码，线程B没有锁，则进入accountone对象的“锁池队列”等待，知道线程A使用完毕释放了accountone对象的锁，线程B才可以开始调用“同步块”中的代码。

咱们说到了“锁”这个概念，那再往里面专研一下。来看看死锁及它的解决方案。

死锁及解决方案

死锁的概念：

多个线程各自占有一些共享资源，并且互相等待其他线程占有的资源才能进行，而导致两个或者多个线程都在等待对方释放资源，都停止执行的情形。

因此，某一个同步块需要同时拥有“两个以上对象的锁”时，就可能会发生“死锁”的问题。（因为本宝宝和我劳工贝贝脸上的小痘痘比较多，经常需要镜子和药膏来进行消除脸上的逗逗，经常争抢镜子）下面Demo中，“消痘痘线程”需要同时拥有“镜子对象”、“药膏对象”才能运行同步块。那么，实际运行时，本宝宝的“消痘痘线程”拥有了“镜子对象”（嘻嘻，还是我厉害，抢到镜子了呢），我劳工贝贝的“消痘痘线程”拥有了“药膏对象”，都在互相等待对方释放资源，才能进行消痘痘。这样，两个线程就形成了互相等待，无法继续运行的“死锁状态”。

package com.shenqi.deadlock;

public class TestDeadLock {

    public static void main(String[] args) {
        EliminateBlainBlain baby = new EliminateBlainBlain();
        baby.code = "本宝宝";
        baby.flag = 0;
        EliminateBlainBlain bebe = new EliminateBlainBlain();
        bebe.code = "劳工贝贝";
        bebe.flag = 1;
        baby.start();
        bebe.start();
    }

}

/**
 * 
 * @author xiaobaiyang
 *  镜子类
 *
 */
class Mirror{

}

/**
 * 
 * @author xiaobaiyang
 * 药膏类
 *
 */
class Unguent{

}

/**
 * 
 * @author xiaobaiyang
 *  消痘痘类继承了Thread类
 *
 */
class EliminateBlainBlain extends Thread{

    public int flag;

    public String code;

    public static Mirror mirror = new Mirror();
    public static Unguent unguent = new Unguent();

    @Override
    public void run() {
        EliminateBlain();
    }

    private void EliminateBlain() {

        if(flag == 0){
            //需要得到镜子的“锁”
            synchronized (mirror) {
                System.out.println(code + "拿着镜子~~~");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
                //需要得到药膏的“锁”
                synchronized (unguent) {
                    System.out.println(code + "拿着药膏~~~");
                }
            }

        } else if(flag == 1){
            //需要得到药膏的“锁”
            synchronized (unguent) {
                System.out.println(code + "拿着药膏~~~");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
                //需要得到镜子的“锁”
                synchronized (mirror) {
                    System.out.println(code + "拿着镜子~~~");
                }
            }
        }

    }

}

执行结果如下所示：（注：两线程都在等对方资源，都处于停滞状态）

劳工贝贝拿着药膏~~~
本宝宝拿着镜子~~~

死锁的解决方法

死锁是由于“同步块需要同时持有多个对象锁造成”的，要解决这个问题，思路很简单，就是：同一个代码块，不要同时持有两个对象锁。如上面的死锁Demo，现在对上面的死锁Demo，进行一下修改。代码如下所示：

package com.shenqi.deadlock;

public class TestDeadLockOne {

    public static void main(String[] args) {
        EliminateBlainBlainOne baby = new EliminateBlainBlainOne();
        baby.code = "本宝宝";
        baby.flag = 0;
        EliminateBlainBlainOne bebe = new EliminateBlainBlainOne();
        bebe.code = "劳工贝贝";
        bebe.flag = 1;
        baby.start();
        bebe.start();
    }

}

/**
 * 
 * @author xiaobaiyang
 *  镜子类
 *
 */
class MirrorOne{

}

/**
 * 
 * @author xiaobaiyang
 * 药膏类
 *
 */
class UnguentOne{

}

/**
 * 
 * @author xiaobaiyang
 *  消痘痘类继承了Thread类
 *
 */
class EliminateBlainBlainOne extends Thread{

    public int flag;

    public String code;

    public static MirrorOne mirror = new MirrorOne();
    public static UnguentOne unguent = new UnguentOne();

    @Override
    public void run() {
        EliminateBlain();
    }

    private void EliminateBlain() {

        if(flag == 0){
            //需要得到镜子的“锁”
            synchronized (mirror) {
                System.out.println(code + "拿着镜子~~~");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
            //需要得到药膏的“锁”
            synchronized (unguent) {
                System.out.println(code + "拿着药膏~~~");
            }

        } else if(flag == 1){
            //需要得到药膏的“锁”
            synchronized (unguent) {
                System.out.println(code + "拿着药膏~~~");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
            //需要得到镜子的“锁”
            synchronized (mirror) {
                System.out.println(code + "拿着镜子~~~");
            }
        }

    }

}

运行结果如下所示：（注：两线程都可以得到需要的资源，程序会正常运行结束）

劳工贝贝拿着药膏~~~
本宝宝拿着镜子~~~
本宝宝拿着药膏~~~
劳工贝贝拿着镜子~~~