线程同步
一个经典的线程同步例子
一个账户有500元，一个用户取出账户的500元，同时另一个用户也在向账户取500元。会发生什么？
- 首先创建一个Account类，包含AccountNO账户的编号和balance账户的余额。
- 然后创建一个取钱的线程类
public class DrawThread extends Thread {
private Account account;
private double drawAmount;
public DrawThread(String name,Account account, double drawAmount) {
super(name);
this.account = account;
this.drawAmount = drawAmount;
}
@Override
public void run() {
if (drawAmount <= account.getBalance()) {
System.out.println(this.getName()+" 取出"+drawAmount+"元");
account.setBalance(account.getBalance() - drawAmount);
System.out.println("账户余额:"+account.getBalance());
} else {
System.out.println("余额不足");
}
}
}
- 测试同时取500会发生什么
public class test {
public static void main(String[] args) {
Account ac = new Account("123", 500);
new DrawThread("刘一",ac,500).start();
new DrawThread("陈二",ac,500).start();
}
}
输出
刘一 取出500.0元
账户余额:0.0
陈二 取出500.0元
账户余额:-600.0
为什么会发生这样的结果?
这结果肯定不是银行想要的结果。原因是线程的运行是靠线程调度来运行的，所以不是a执行完执行b，而是同步执行a，b。所以a,b同时在余额在500时候调用账户类，同时做取出操作。
那么怎么解决呢？
可以引入同步监视器来法锁定代码，任何时候只能有一个线程可以获得监视器的锁定
public class DrawThread extends Thread {
private Account account;
private double drawAmount;
public DrawThread(String name,Account account, double drawAmount) {
super(name);
this.account = account;
this.drawAmount = drawAmount;
}
@Override
public void run() {
//同步监视器锁定
synchronized (account) {
if (drawAmount <= account.getBalance()) {
System.out.println(this.getName()+" 取出"+drawAmount+"元");
account.setBalance(account.getBalance() - drawAmount);
System.out.println("账户余额:"+account.getBalance());
} else {
System.out.println("余额不足");
}
//代码执行完解除锁定
}
}
}
输出
刘一 取出500.0元
账户余额: 0.0
余额不足
这样就是线程安全。
线程安全的定义：
该类的对象可以被多个线程安全地访问
每个线程调用该对象的任意方法之后都将得到正确的结果
每个线程调用该对象的任意方法之后，该对象状态依然保持合理状态
锁
Lock提供了比synchronized方法更广泛的锁定操作，允许灵活结构
public class Draw {
private Account account;
private String name;
private final ReentrantLock lock = new ReentrantLock();
public Draw(String name,Account account) {
this.name = name;
this.account = account;
}
public void drawMoney(double money) {
//同步监视器锁定
lock.lock();
try {
if (money <= account.getBalance()) {
System.out.println(name + " 取出"+money+"元");
account.setBalance(account.getBalance() - money);
System.out.println("账户余额:"+account.getBalance());
} else {
System.out.println("余额不足");
}
//代码执行完解除锁定
} finally {
lock.unlock();
}
}
}
测试类
public class test {
public static void main(String[] args) {
Account ac = new Account("123", 500);
Draw d = new Draw("张三", ac);
new Thread(() -> {
d.drawMoney(500);
}).start();
new Thread(() -> {
d.drawMoney(500);
}).start();
}
}
输出
张三 取出500.0元
账户余额: 0.0
余额不足
死锁
倆个线程相互等待对方释放同步监视器时会发生死锁
public class test {
public static void main(String[] args) {
A a = new A();
B b = new B();
new Thread(() -> {
a.Afun(b);
}).start();;
new Thread(() -> {
b.Bfun(a);
}).start();
}
}
class A {
public synchronized void Afun(B b){
try {
Thread.sleep(200);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
b.print();
}
public synchronized void print(){
System.out.println("调用A线程");
}
}
class B {
public synchronized void Bfun(A a){
try {
Thread.sleep(200);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
a.print();
}
public synchronized void print(){
System.out.println("调用B线程");
}
}
死锁发生的原因
当a调用aFun()方法时锁定了a然后睡眠让出了资源让b执行，同样b调用bFun()锁住了b，这时a唤醒调用b的print()方法，但是被b锁定，同样事情发生在b上，造成死锁.
线程通信
使用Object类中的notify(),wait(),notifyAll()方法让线程之间进行通信，但这些方法必须通过同步监视器调用
wait()：导致当前线程等待，直到其他线程调用notify方法，或者设置等待时间。
notify()：唤醒在此同步监视器上等待的单个线程，如果有多个线程在随机唤醒一个。
notifyAll():唤醒在此同步监视器上等待的所有线程
账户类
public class Account {
private String accountNO;
private double balance;
//用flag来定义是存是取
private boolean flag;
public String getAccountNO() {
return accountNO;
}
public void setAccountNO(String accountNO) {
this.accountNO = accountNO;
}
public double getBalance() {
return balance;
}
public Account(String accountNO, double balance) {
super();
this.accountNO = accountNO;
this.balance = balance;
}
//取钱
public synchronized void draw(double number) {
try {
if (flag) {
System.out.println(Thread.currentThread().getName() + "取出:" + number);
balance -= number;
System.out.println("剩余余额:" + balance);
flag = false;
this.notifyAll();
} else {
this.wait();
}
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
//存钱
public synchronized void deposit(double number){
try {
if (!flag) {
System.out.println(Thread.currentThread().getName() + "存入:" + number);
balance += number;
System.out.println("剩余余额:" + balance);
flag = true;
this.notifyAll();
}
this.wait();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
取钱线程
public class Draw implements Runnable{
private Account account;
private double money;
public Draw(Account account,double Dmoney) {
this.account = account;
this.money = Dmoney;
}
@Override
public void run() {
for (int i = 0; i < 50; i++){
account.draw(money);
}
}
}
存钱线程
public class Deposit implements Runnable{
private Account account;
private double Dmoney;
public Deposit(Account account,double Dmoney) {
this.account = account;
this.Dmoney = Dmoney;
}
@Override
public void run() {
for (int i = 0; i < 50; i++) {
account.deposit(Dmoney);
}
}
}
测试
public class Deposit implements Runnable{
private Account account;
private double Dmoney;
public Deposit(Account account,double Dmoney) {
this.account = account;
this.Dmoney = Dmoney;
}
@Override
public void run() {
for (int i = 0; i < 50; i++) {
account.deposit(Dmoney);
}
}
}
输出
刘一存入: 500.0
剩余余额: 1500.0
张三取出: 500.0
剩余余额: 1000.0
刘一存入: 500.0
剩余余额: 1500.0
陈二取出: 500.0
剩余余额: 1000.0
...循环...
使用lock对象保证同步需要使用Condition类来控制线程通信
实例化Conditon，该类会提供三个方法await(),signal(),signalAll()。分别对应wait(),notify(),notifyAll()
