这一节主要是继上次提到的线程同步三大方法：同步代码块、同步方法、Lock锁。
- 同步代码块，把出现线程安全问题的核心代码给上锁。
还是继上次的例子，对代码块加上synchronized ("getMoney") {}之后就不会出现线程安全问题了：
public void getMoney(double money) { String names = Thread.currentThread().getName(); System.out.println(names+"进来取钱了！"); //会出现问题的代码块 synchronized ("getMoney") {//同步锁对象getMoney， if (this.money >= money) { System.out.println(names + "取出" + money); this.money -= money; System.out.println(ID + "剩余" + this.money); } else System.out.println(names + "取钱" + money + " 失败，" + "剩余" + this.money); } }
锁对象唯一（字符串"getMoney"）不太好,会锁住其他全部非共享线程。因此建议使用共享资源作为锁对象，对于实例方法建议使用this作为锁对象。 对于静态方法建议使用字节码（类名.class）对象作为锁对象。
- 同步方法，出现线程安全问题的核心方法给上锁。
只需要在方法加上synchronized 修饰，这种方法就使得一整个方法加上了锁。
public synchronized void getMoney(double money){
该方法在底层是有隐式锁对象的，对于两个共享资源是不冲突的。
- Lock锁，一个新的锁对象Lock。
在共享资源类里面加上private final Lock lock=new ReentrantLock(); —final了，唯一不可替换的锁。所以例子中，在账户里面加上这句，同一个账户就是同一把锁。然后再取钱方法中加上lock()上锁，使用完用unlock()解锁。
public void getMoney(double money){ String name=Thread.currentThread().getName(); // lock.lock(); if(this.money>=money){ System.out.println(name+"取出"+money); this.money-=money; System.out.println(ID+"剩余"+this.money); } else System.out.println(name+"取钱"+money+" 失败"+"剩余"+this.money); lock.unlock(); }
为了防止加锁后出现异常，导致解锁问题，通常使用try...catch...finally；
lock.lock(); try { if (this.money >= money) { System.out.println(name + "取出" + money); this.money -= money; System.out.println(ID + "剩余" + this.money); } else System.out.println(name + "取钱" + money + " 失败" + "剩余" + this.money); } finally { lock.unlock(); }
- 线程通信
线程通信就是线程间相互发送数据，线程间共享一个资源即可实现线程通信，（保证线程安全的前提）。例如在生产者与消费者模型中,一个有限的空间仓库中，生产者线程生产完内容后唤醒消费者，然后停下来等待生产，消费者消费完该产品后唤醒生产者，停止消费。
线程通信的三个常见方法（Object类，当前同步锁对象进行调用）：
void wait() ：让当前线程等待并释放所占锁，直到另一个线程调用notify()方法或 notifyAll()方法；
void notify()：唤醒正在等待的单个线程；
void notifyAll()：唤醒正在等待的所有线程。
- 示例，简单的生产者与消费者模型案例：有一个亲情账户，最大金额是10,000，孩子可以取钱，父母存钱，还是假设每次都只能存取10000元为例。
- 创建一个账户类，有存、取方法；父母进行存操作方法后，存钱成功（当账户余0）就会唤醒其他进程（让消费者进行消费）并进入等待，存钱失败（账户余10,000）就自己等待；孩子进行取操作方法后，取钱成功（当账户有钱）就会唤醒其他进程（让生产者进行生产）并进入等待，取钱失败（账户余0）就自己等待；
class account{ private String ID; private double money; public account(){} public account(String id,double money){ this.ID=id; this.money=money; } //取 public synchronized void getMoney(double money){ String name=Thread.currentThread().getName(); System.out.println(name + " 取锁 *****"); try { if (this.money >= money) { System.out.print(name + "取出" + money+" - "); this.money -= money; System.out.println(ID + "剩余" + this.money); this.notifyAll();//取完之后唤醒其他线程 this.wait();//自己等待，会释放锁 } else { System.out.println(name + "取出失败！"); this.wait(); } }catch (InterruptedException e){ e.printStackTrace(); } } //存 public synchronized void inMoney(double money) { String name=Thread.currentThread().getName(); System.out.println(name + " 取锁 *****"); // try { if (this.money == 0) { System.out.print(name + "存钱 " + money+" - "); this.money += money; System.out.println(ID + "剩余" + this.money); this.notifyAll(); this.wait(); } else { System.out.println(name + "存入失败！"); this.wait(); } }catch (InterruptedException e){ e.printStackTrace(); } } }
- 两个线程类的实现继承Thread，在里面无限次存取操作；
class getMoneyThread extends Thread{ private account a; public getMoneyThread(account a,String name){ super(name); this.a=a; } @Override public void run() { while (true) { a.getMoney(10000); try{ Thread.sleep(3000); } catch (InterruptedException e) { e.printStackTrace(); } } } } class inMoneyThread extends Thread{ private account a; public inMoneyThread(account a,String name){ super(name); this.a=a; } @Override public void run() { while (true) { a.inMoney(10000); try{ Thread.sleep(3000); } catch (InterruptedException e) { e.printStackTrace(); } } } }
- 创建账户对象和生产者消费者对象；
/** * 多线程通信 */ public class Demo_lock { public static void main(String[] args) { account acc=new account("happy",10000); //消费者 new getMoneyThread(acc,"熊大").start(); new getMoneyThread(acc,"熊二").start(); //生产者 new inMoneyThread(acc,"父亲").start(); new inMoneyThread(acc,"母亲").start(); } }
- 结果
