一、线程同步
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 来代替使用内置锁
