一、线程同步
1)模拟多个用户同时从银行账户里面取钱
● Account 类:银行账户类,里面有一些账户的基本信息,以及操作账户信息的方法
//模拟银行账户
classAccount {private String accountNo;//账号
private double balance;//余额
publicAccount() {
}public Account(String accountNo, doublebalance) {super();this.accountNo =accountNo;this.balance =balance;
}publicString getAccountNo() {returnaccountNo;
}public voidsetAccountNo(String accountNo) {this.accountNo =accountNo;
}public doublegetBalance() {returnbalance;
}public void setBalance(doublebalance) {this.balance =balance;
}
}
Account.java
● DrawThread 类继承了Thread,是一个多线程类,用于模拟多个用户操作同一个账户的信息
class DrawThread extendsThread {private Account account;//银行账户
private double money;//操作金额
public DrawThread(String name, Account account, doublemoney) {super(name);this.account =account;this.money =money;
}//多个线程修改同一个共享数据,可能发生线程安全问题
@Overridepublic voidrun() {if (account.getBalance() >money) {
System.out.println("【" + getName() + "】取钱:" + " " +money);try{
Thread.sleep(500);
}catch(Exception e) {
e.printStackTrace();
}
account.setBalance(account.getBalance()-money);
System.out.println("\t账户余额为" + " " +account.getBalance());
}else{
System.out.println("【" + getName() + "】取钱:余额不足");}
}
}
● 测试类
public classTest {public static voidmain(String[] args) {//初始账户
Account account = new Account("88888888", 1000);//模拟两个线程同时操作账号
new DrawThread("甲", account, 800).start();new DrawThread("乙", account, 800).start();
}
}
我们现在希望实现的操作是模拟多个用户同时从银行账户里面取钱,如果用户取钱数小于等于当前账户余额,则提示取款成功,并将余额减去取款钱数,如果余额不足,则提示余额不足,取款失败。
- 运行程序可能会看到如下运行结果:
同一账户同时操作,造成数据异常。因为线程调度的不确定性,所以出现了线程安全问题。
2)线程安全问题产生的原因
① 多个线程在操作共享数据
② 操作共享数据的线程代码有多条
当一个线程在执行操作共享数据的多条代码过程中,其他线程参与了运算,就会导致线程安全问题的产生。
3)解决思路
① 将多条操作的共享数据的线程代码封装起来,当有线程在执行这些代码的时候,其它线程时不可以参与运算。
② 必须要当前线程把这些代码执行完毕后,其它线程才可以参与运算。
4)解决线程安全问题
在java中,使用同步解决这个问题
● 同步的好处:解决了线程安全的问题
● 同步的弊端:相对降低了效率,因为同步外的线程都会判断同步锁
● 同步的前提:同步中必须有多个线程并使用同一个锁
① 同步代码块 - 使用的锁可以是任意对象 - 通常在继承Thread中使用
synchronized(obj){//需要被同步的代码;}
② 同步方法 -synchronized作为函数修饰符
普通方法同步:使用的锁是 当前对象 固定的this
静态方法同步:使用的锁是 当前类的Class对象,可以用getClass()方法获取,也可以用当前类名.class表示
public synchronized voidmethod(){// 需要被同步的代码;}
③ 同步锁 - 通常在实现Runnable中使用
从Java5开始,Java提供了一种功能更强大的线程同步机制 —— 通过显式定义同步锁对象来实现同步,在这种机制下,同步锁由Lock对象充当。
Lock提供了比 synchronized 方法和 synchronized代码块 更广泛的锁定操作,Lock允许实现更灵活的结构,可以具有差别很大的属性,并且支持多个相关的 Condition 对象。
在实现线程安全的控制中,比较常用的是 ReentrantLock(可重入锁)。使用该Lock对象可以显式加锁、释放锁。
● Lock接口(互斥锁):替代了同步代码块或同步函数,将同步的隐式锁操作变成了实现锁操作。同时更为灵活,可以一个锁使用多组监视器。
lock():获取锁
unlock():释放锁,通常需要定义在finally代码块中。
● Condition接口(监视器):将这些监视器方法单独进行了封装,变成了Condition监视器对象。可以任意锁进行组合
await():替代了Object中的 wait 方法。
signal():替代了Object中的 notify 方法。
signalAll():替代了Object中的 notifyAll 方法。
classD {//定义锁对象
private final ReentrantLock lock = newReentrantLock();//...//定义需要保护线程安全的方法
public voidmethod() {//加锁
lock.lock();try{//需要保证线程安全的代码//...method body
} finally{//释放锁
lock.unlock();
}
}
}
5)将上面银行中DrawThread类作如下修改
class DrawThread extendsThread {private Account account;//模拟用户账户
private double money;//操作金额
public DrawThread(String name, Account account, doublemoney) {super(name);this.account =account;this.money =money;
}//多个线程修改同一个共享数据,可能发生线程安全问题
@Overridepublic voidrun() {//使用account作为同步监视器,任何线程在进入下面同步代码块之前//必须先获得account账户的锁定,其他线程无法获得锁,也就无法修改它//这种做法符合:"加锁-修改-释放锁"的逻辑
synchronized(account) {if (account.getBalance() >money) {
System.out.println("【" + getName() + "】取钱:" + " " +money);try{
Thread.sleep(500);
}catch(Exception e) {
e.printStackTrace();
}
account.setBalance(account.getBalance()-money);
System.out.println("\t账户余额为" + " " +account.getBalance());
}else{
System.out.println("【" + getName() + "】取钱:余额不足");
}
}
}
}public classTest {public static voidmain(String[] args) {//初始账户
Account account = new Account("88888888", 1000);//模拟两个线程同时操作账号
new DrawThread("甲", account, 800).start();new DrawThread("乙", account, 800).start();
}
}
再次运行的结果:
二、线程死锁(应避免发生)
当两个线程相互等待对方释放同步监视器时就会发生死锁,Java虚拟机没有监测,也没有采取措施来处理死锁情况,所以多线程编程时应该采取措施避免死锁岀现。
一旦岀现死锁,整个程序既不会发生任何异常,也不会给出任何提示,只是所有线程处于阻塞状态,无法继续。
死锁是很容易发生的,尤其在系统中出现多个同步监视器的情况下,如下程序将会出现死锁
class Mylock//建立静态锁对象
{public static Object locka = newObject();public static Object lockb = newObject();
}class Test implementsRunnable {private booleanflag;
Test(booleanflag) {this.flag =flag;
}public voidrun() {if (!flag) {while (true) {
System.out.println(Thread.currentThread().getName()+ "...run...");synchronized (Mylock.locka)//线程0持a锁进来时if,
{
System.out.println(Thread.currentThread().getName()+ "...if...locka");synchronized (Mylock.lockb)//线程0持b锁进来时if,线程1持有锁b锁还没有释放,进入阻塞状态
{
System.out.println(Thread.currentThread().getName()+ "...if...lockb");
}
}
}
}else{while (true) {
System.out.println(Thread.currentThread().getName()+ "...run...");synchronized (Mylock.lockb)//线程1持b锁进入else,
{
System.out.println(Thread.currentThread().getName()+ "...elae...lockb");synchronized (Mylock.locka)/// 线程1持a锁进来时else,线程0持有锁a锁还没有释放,进入阻塞状态
{
System.out.println(Thread.currentThread().getName()+ "...elae...locka");
}
}
}
}
}
}classDeadLockTest {public static voidmain(String[] args) {new Thread(new Test(false), "A线程").start();new Thread(new Test(true), "B线程").start();
}
}
运行结果:
从运行结果可看到,线程A拿到了a锁,并尝试去获取b锁,与此同时线程B拿到了b锁并尝试去获取a锁,此时线程A和线程B就陷入了无限的等待,形成死锁。
当一个线程永远地持有一个锁,并且其他线程都尝试获得这个锁时,那么它们将永远被阻塞。
1)预防死锁
下面介绍几个常见方法:
① 避免一个线程同时获取多个锁
② 避免一个线程在锁内同时占用多个资源,尽量保证每个锁只占用一个资源
③ 尝试使用定时锁,使用 lock.tryLock 来代替使用内置锁