栏目分类:
子分类:
返回
名师互学网用户登录
快速导航关闭
当前搜索
当前分类
子分类
实用工具
热门搜索
名师互学网 > IT > 软件开发 > 后端开发 > Java

【面试:并发篇03:多线程:锁】卖票程序

Java 更新时间: 发布时间: IT归档 最新发布 模块sitemap 名妆网 法律咨询 聚返吧 英语巴士网 伯小乐 网商动力

【面试:并发篇03:多线程:锁】卖票程序

【面试:并发篇03:多线程:锁】卖票程序 00.前言

有任何问题请指出,感谢各位。

01.介绍

什么是锁:锁是为了保证线程安全,即多线程运行过程中,保证某一部分只能让当前线程运行完,而不能在当前线程运行过程中切换其他线程。总的来说:多线程保证线程安全就是让多个线程执行的情况和单线程一样。

什么是卖票程序:卖票程序就是生产消费者模式,我们有很多的卖票点卖票可以卖给很多人,但所有票都在一个票池里,卖票分为两个过程:卖票,总票数减一。这样如果不用锁处理就会出现线程安全问题,比如某一个线程在卖票但票数还没有来得及减一,就切换到另一个线程了然后这个线程又把这张票卖了一次,显然不符合要求。解决这个问题我们就要靠锁即线程同步来解决。

02.卖票程序 原版
class A implements Runnable
{
	public static int tickets = 100;
	public void run()
	{
		while(true)
		{
			if(tickets>0)
			{
				System.out.printf("%s线程正在卖出第%d张票n",Thread.currentThread().getName(),tickets);
				tickets--;				
			}
			else
				break;
		}	
	}	
}
public class TestTickets
{
	public static void main(String[] args)
	{
		A aa1=new A();
		Thread t1=new Thread(aa1);
		t1.start();	
		A aa2=new A();
		Thread t2=new Thread(aa2);
		t2.start();
	}	
	
}

结果

Thread-1线程正在卖出第100张票
…
Thread-1线程正在卖出第82张票
Thread-0线程正在卖出第100张票
Thread-0线程正在卖出第80张票
Thread-0线程正在卖出第79张票
Thread-0线程正在卖出第78张票
Thread-0线程正在卖出第77张票

…

可以看到线程1已经卖到了第82张票但此时线程0又卖了一次之前的第100张票,它的逻辑是这样的:最开始线程1运行了System.out.printf(“%s线程正在卖出第%d张票n”,Thread.currentThread().getName(),tickets);语句但是并没有减1,然后切换到了线程0,然后线程0已经加载了System.out.printf(“%s线程正在卖出第%d张票n”,Thread.currentThread().getName(),tickets);语句但此时还没有来的及输出**(注意:因为输出语句已经加载好 所以此时要输出的应该是Thread-0线程正在卖出第100张票 只是没有来得及输出)**,之后又切换到了线程1继续从上次线程1运行的地方运行 此时运行tickets–;,然后一直到Thread-0线程正在卖出第100张票之前都是线程1在正常运行 运行到Thread-1线程正在卖出第82张票,此时切换到线程0 因为之前线程0已经加载了==System.out.printf(“%s线程正在卖出第%d张票n”,Thread.currentThread().getName(),tickets);所以继续从这里运行 所以接下来运行System.out.printf(“%s线程正在卖出第%d张票n”,Thread.currentThread().getName(),tickets);语句输出Thread-0线程正在卖出第100张票 但是此时的票数实际上是81 然后线程0运行tickets–==后 此时票数是80,所以之后线程0才会输入Thread-0线程正在卖出第80张票,那么第81张呢?其实第81张也是和第100张的情况一样,第81张被线程1的输出语句加载但还没有输出 但是之后 再次切换到线程1时会再次输出81。

加锁(线程同步)

前提知识

线程同步实际上是通过synchronized关键字实现的,它的作用是规定一个锁 这个锁可以锁定一块代码段也可以锁定一个方法, 这个锁 锁住一个公共对象 只有拿到这个锁的线程才可以运行锁内部的代码且不可被打断 直到这块代码运行完毕 释放锁 之后所有线程再来争抢锁。这样做的目的是为了 公共资源部分的代码在同一时刻只能由一个线程运行,避免线程不安全。对于卖票程序来说 它们的公共资源的就是 票池 锁住的部分就是卖票和票数减一。实质上 锁 锁住的对象叫做监听器 锁住对象的动作叫做锁定。

代码

class A implements Runnable
{
	public static int tickets = 10000;//写法一的话 static可以不用加 但写法二必须加
	String str = new String("aa");//a  这样写 只有写法一正确
	//static String str = new String("aa"); //b  这样写 写法二写法一都正确
	public A()
	{
		System.out.println(this);	
	}
	public void run()
	{
		while(true)
		{
			//synchronized(this)//这样写 只有写法一正确
			synchronized(str)//这样写写法一一定正确,但写法二 只有在b的情况下才能正确
			{
				if(tickets>0)
				{
					System.out.printf("%s线程正在卖出第%d张票n",Thread.currentThread().getName(),tickets);
					tickets--;				
				}
				else
				{
					break;
				}
			}
		}	
	}	
}

public class TestTickets_2
{
	public static void main(String[] args)
	{
		A aa=new A();
		Thread t1=new Thread(aa);	
		Thread t2=new Thread(aa);
		t1.start();
		t2.start();//写法一
		
		
	}	
}

结果

测试了一万张票,没有出现错误。

解释

大家认真看上述代码即注释

我们可以发现写法一 实质上就是把A的实例对象aa或者aa对象的成员或者A类的成员作为监听器 把aa对象的tickets或者A类的tickets作为票池

写法二的实质是把A类的成员作为监听器 A类的tickets作为票池

实际中我们采用写法一

其他代码

class A extends Thread
{
	public static int tickets = 10000;
	static String str = new String("aa");
	public void run()
	{
		while(true)
		{
			synchronized(str)
			{
				if(tickets>0)
				{
					System.out.printf("%s线程正在卖出第%d张票n",Thread.currentThread().getName(),tickets);
					tickets--;				
				}
				else
				{
					break;
				}
					
			}
		}	
	}	
}

public class TestTickets_3
{
	public static void main(String[] args)
	{
		A aa1=new A();
		A aa2=new A();
		aa1.start();
		aa2.start();
		
	}	
}

解释:本质和写法二一样,只是之前的两种写法是用Runnable接口实现 这个写法是直接继承Thread类

错误代码1

class A implements Runnable
{
	public int tickets = 10000;
	public A()
	{
		System.out.println(this);	
	}
	public synchronized void run()
	//错误写法 对于此程序来说synchronized加在这里会导致 只有一个线程卖票 另一个线程完全不能卖
	//因为放在方法前是保证此方法完全运行 但此方法就是卖10000张票 会导致一个线程把这10000张票全部卖完
	//放在代码块是为了 保证 每卖一张票就必须减一张票 这个才是本程序的真正目的
	{
		while(true)
		{
			if(tickets>0)
			{
				System.out.printf("%s线程正在卖出第%d张票n",Thread.currentThread().getName(),tickets);
				tickets--;				
			}
			else
			{
				break;
			}
					
		}	
	}	
}

public class TestTickets_4
{
	public static void main(String[] args)
	{
		A aa=new A();
		Thread t1=new Thread(aa);	
		Thread t2=new Thread(aa);
		t1.start();
		t2.start();
	}	
}

解释:这里的错误很明显 此时锁定的是整个方法 这样会导致 某一个线程先得到锁 就会直接把票卖完 另一个线程完全陷入阻塞

错误代码2

class A implements Runnable
{
	public int tickets = 10000;
	public A()
	{
		System.out.println(this);	
	}
	public  void run()
	{
		//String str=new String("aa");//错误写法 此时str是局部变量 不再是属性对象
		String str="aa";//正确写法 因为字符串存放在统一的数据区
		while(true)
		{
			synchronized(str)//锁定的不是同一个str对象
			{
				if(tickets>0)
				{
					System.out.printf("%s线程正在卖出第%d张票n",Thread.currentThread().getName(),tickets);
					tickets--;				
				}
				else
				{
					break;
				}
			}	
		}	
	}	
}

public class TestTickets_5
{
	public static void main(String[] args)
	{
		A aa=new A();
		Thread t1=new Thread(aa);	
		Thread t2=new Thread(aa);
		t1.start();
		t2.start();
	}	
}

解释:这个错误也很容易理解 因为此时str变量不是对象的成员变量 只是一个局部变量而局部变量当前代码块运行完毕后就会释放 起不了监听器的作用,但是==String str=“aa”;则可以 原因是这种创建方法的"aa"是在堆中不会随代码块释放 只有当程序运行结束由gc清除,但是String str=new String(“aa”);==就是栈中创建了一个对象会随代码块的结束释放。

转载请注明:文章转载自 www.mshxw.com
本文地址:https://www.mshxw.com/it/985567.html
我们一直用心在做
关于我们 文章归档 网站地图 联系我们

版权所有 (c)2021-2022 MSHXW.COM

ICP备案号:晋ICP备2021003244-6号