1.提出问题
当多个用户对同一个银行账户进行操作或多个乘客购买车票时,应提前对账户进行检查,看余额或余票是否足够。这时我们就利用多线程,使用Runnable方式,开发一个取款、售票的线程类,将每一个用户对应一个线程对象,用多线程共享的方式去解决此类问题。
2.发现问题(以银行取款为例)
当我们遇到银行取款问题时,一般会使用以下的代码进行编写,经过多次运行,发现每次代码的结构都是正确的,这是因为CPU的运行速度较快,未出现并发运行的情况,导致小李取款成功、小红失败。
代码为:
public class Account {
private int balance=600;
//取款
public void subMoney(int money) {
this.balance=this.balance-money;
}
//返回余额
public int getBalance() {
return balance;
}
}
public class AccountRunnable implements Runnable{
private Account account=new Account();
@Override
public void run() {
// TODO Auto-generated method stub
if(account.getBalance()>=400) {
account.subMoney(400);
System.out.println(Thread.currentThread().getName()+"取款成功,余额为"+account.getBalance());
}
else
{
System.out.println(Thread.currentThread().getName()+"余额不足,余额为"+account.getBalance());
}
}
}
public class Test {
public static void main(String[] args) {
Runnable runnable=new AccountRunnable();
Thread xiaoli=new Thread(runnable,"小李");
Thread xiaohong=new Thread(runnable,"小红");
xiaoli.start();
xiaohong.start();
}
}
结果为:
小李取款成功,余额为200
小红余额不足,余额为200
当我们用Thread.sleep(1)让CPU休息1ms时,就会将问题放大,出现小李、小红取款都成功,余额为-200的情况。
代码为:
public class Account {
private int balance=600;
//取款
public void subMoney(int money) {
this.balance=this.balance-money;
}
//返回余额
public int getBalance() {
return balance;
}
}
public class AccountRunnable implements Runnable{
private Account account=new Account();
@Override
public void run() {
// TODO Auto-generated method stub
if(account.getBalance()>=400) {
try {
Thread.sleep(1);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
account.subMoney(400);
System.out.println(Thread.currentThread().getName()+"取款成功,余额为"+account.getBalance());
}
else
{
System.out.println(Thread.currentThread().getName()+"余额不足,余额为"+account.getBalance());
}
}
}
public class Test {
public static void main(String[] args) {
Runnable runnable=new AccountRunnable();
Thread xiaoli=new Thread(runnable,"小李");
Thread xiaohong=new Thread(runnable,"小红");
xiaoli.start();
xiaohong.start();
}
}
结果为:
小李取款成功,余额为-200
小红取款成功,余额为-200
3.解决问题(以银行取款为例)
从上面的案例我们可以看到,当多个线程访问一个数据是,容易出现线程安全问题。需要让线程同步,保证数据安全。接下来将介绍三种线程同步的方法:同步代码块、同步方法和Lock锁,来解决线程同步问题。
同步代码块
使用同步代码块的代码如下:
public class Account {
private int balance=600;
//取款
public void subMoney(int money) {
this.balance=this.balance-money;
}
//返回余额
public int getBalance() {
return balance;
}
}
public class AccountRunnable implements Runnable{
private Account account=new Account();
@Override
public void run() {
// TODO Auto-generated method stub
synchronized (account) {
if(account.getBalance()>=400) {
try {
Thread.sleep(1);
} catch (Exception e) {
// TODO: handle exception
e.printStackTrace();
}
account.subMoney(400);
System.out.println(Thread.currentThread().getName()+"取款成功,余额为"+account.getBalance());
}
else
{
System.out.println(Thread.currentThread().getName()+"余额不足,余额为"+account.getBalance());
}
}
}
}
public class Test {
public static void main(String[] args) {
Runnable runnable=new AccountRunnable();
Thread xiaoli=new Thread(runnable,"小李");
Thread xiaohong=new Thread(runnable,"小红");
xiaoli.start();
xiaohong.start();
}
}
应用同步代码块的方法,及时让CPU休眠,也能得到正确的结果。
结果为:
小李取款成功,余额为200
小红余额不足,余额为200
同步代码块的相关知识:
①认识同步监视器(锁子) synchronized(同步监视器){ }
必须是引用数据类型,不能是基本数据类型。在同步代码块中可以改变同步监视器对象的值,不能改变其引用。尽量不要String和包装类Integer做同步监视器。如果使用了,只要保证代码块中不对其进行任何操作也没有关系。一般使用共享资源做同步监视器即可,也可以创建一个专门的同步监视器。
②同步代码块的执行过程
第一个线程来到同步代码块,发现同步监视器open状态,需要close,然后执行其中的代码。第一个线程执行过程中,发生了线程切换(阻塞 就绪),第一个线程失去了cpu,但是没有开锁open。第二个线程获取了cpu,来到了同步代码块,发现同步监视器close状态,无法执行其中的代码,第二个线程也进入阻塞状态。第一个线程再次获取CPU,接着执行后续的代码;同步代码块执行完毕,释放锁open。第二个线程也再次获取cpu,来到了同步代码块,发现同步监视器open状态,重复第一个线程的处理过程(加锁)。
同步方法
使用同步方法的代码如下:
public class Account {
private int balance=600;
//取款
public void subMoney(int money) {
this.balance=this.balance-money;
}
//返回余额
public int getBalance() {
return balance;
}
}
public class AccountRunnable implements Runnable{
private Account account=new Account();
@Override
public void run() {
// TODO Auto-generated method stub
if(account.getBalance()>=400) {
account.subMoney(400);
System.out.println(Thread.currentThread().getName()+"取款成功,余额为"+account.getBalance());
}
else
{
System.out.println(Thread.currentThread().getName()+"余额不足,余额为"+account.getBalance());
}
}
public synchronized void sybMoney() {
try
{
Thread.sleep(1);
}
catch (Exception e)
{
// TODO: handle exception
if(account.getBalance()>=400)
{
account.subMoney(400);
System.out.println(Thread.currentThread().getName()+"取款成功,余额为"+account.getBalance());
}
else
{
System.out.println(Thread.currentThread().getName()+"余额不足,余额为"+account.getBalance());
}
}
}
}
public class Test {
public static void main(String[] args) {
Runnable runnable=new AccountRunnable();
Thread xiaoli=new Thread(runnable,"小李");
Thread xiaohong=new Thread(runnable,"小红");
xiaoli.start();
xiaohong.start();
}
}
结果为:
小李取款成功,余额为200
小红余额不足,余额为200
同步方法的相关知识:
不能将run()定义为同步方法。同步方法的同步监视器是this。同步代码块的效率要高于同步方法,同步方法的锁是this,一旦锁住一个方法,就锁住了所有的同步方法;同步代码块只是锁住使用该同步监视器的代码块,而没有锁住使用其他监视器的代码块。同步方法是将线程锁在了方法的外部,而同步代码块锁将线程锁在了代码块的外部,但是却是方法的内部。
Lock锁
JDk1.5中,新增了Lock锁,与采用synchronized相比,lock可提供多种锁方案,更灵活。
使用Lock锁的代码如下:
public class Account {
private int balance=600;
//取款
public void subMoney(int money) {
this.balance=this.balance-money;
}
//返回余额
public int getBalance() {
return balance;
}
}
public class AccountRunnable implements Runnable{
private Account account=new Account();
Lock lock=new ReentrantLock();
@Override
public void run() {
// TODO Auto-generated method stub
try {
lock.lock();
if(account.getBalance()>=400)
{
try
{
Thread.sleep(1);
}
catch (Exception e)
{
// TODO: handle exception
e.printStackTrace();
}
account.subMoney(400);
System.out.println(Thread.currentThread().getName()+"取款成功,余额为"+account.getBalance());
}
else
{
System.out.println(Thread.currentThread().getName()+"余额不足,余额为"+account.getBalance());
}
}
finally
{
lock.unlock();
}
}
}
public class Test {
public static void main(String[] args) {
Runnable runnable=new AccountRunnable();
Thread xiaoli=new Thread(runnable,"小李");
Thread xiaohong=new Thread(runnable,"小红");
xiaoli.start();
xiaohong.start();
}
}
结果为:
小李取款成功,余额为200
小红余额不足,余额为200
Lock的相关知识:
①java.util.concurrent.lock 中的 Lock 框架是锁定的一个抽象,它允许把锁定的实现作为 Java 类,而不是作为语言的特性来实现,这就为 Lock 的多种实现留下了空间,各种实现可能有不同的调度算法、性能特性或者锁定语义。ReentrantLock 类实现了 Lock ,它拥有与 synchronized 相同的并发性和内存语义, 但是添加了类似锁投票、定时锁等候和可中断锁等候的一些特性。此外,它还提供了在激烈争用情况下更佳的性能。注意:如果同步代码有异常,要将unlock()写入finally语句块
②Lock和synchronized的区别
Lock是显式锁(手动开启和关闭锁,别忘记关闭锁),synchronized是隐式锁,遇到异常自动解锁。Lock只有代码块锁,synchronized有代码块锁和方法锁。Lock锁可以对读不加锁,对写加锁,synchronized不可以。Lock锁可以有多种获取锁的方式,可以从sleep的线程中抢到锁,synchronized不可以。使用Lock锁,JVM将花费较少的时间来调度线程,性能更好,并且具有更好的扩展性(提供更多的子类)。
③优先使用顺序:
Lock--同步代码块(已经进入了方法体,分配了相应资源)--同步方法(在方法体之外)