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();
4000

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 + "拿着镜子~~~");
}
}

}

}

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

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