Java核心知识总结（十二）---数据共享与线程安全
Java核心知识总结（十二）---数据共享与线程安全
王利华 2012-5
一、案例分析：
我们有这样一个需求，需要实现，就是简单实现火车站售票程序。
火车站一般设有多个窗口同时售票，因此我们在这设计4个窗口。
同时，一列火车是有限的票位，因此方便程序运行，假定有100张票。
二、对线程的第二种创建方式说明
为什么要设计Runnable接口：
Java不支持多继承，而类需要这样的“多继承”时，接口出现了；同时接口可以看作是完全的纯虚类，因此类可以实现它，同时必须完全实现。
为了避免单继承的局限性，因此采用实现方式。
现实生活的需要，有些类没有继承关系，但是存在某种联系，因此接口出现。
三、程序实现
（1）初步尝试—--采用静态成员的共享性
public class SaileTicket
{
public static void main(String []args)
{
Ticket t1=new Ticket();
//_________________________________
//出现异常，线程多次被开启
t1.start();
t1.start();
t1.start();
t1.start();
//_________________________________
}
}
class Ticket extends Thread
{
private static int tick=100;
public void run()
{
while(true)
{
if(tick>0)
{
System.out.println(Thread.currentThread().getName()+"sale:"+tick--);
}
}
}
}
换种思路：采用第二种方式创建线程
public class SaileTickel
{
public static void main(String []args)
{
Ticket t=new Ticket();
Thread t1=new Thread(t);
Thread t2=new Thread(t);
Thread t3=new Thread(t);
Thread t4=new Thread(t);
t1.start();
t2.start();
t3.start();
t4.start();
}
}
class Ticket implements Runnable
{
private static int tick=100;
public void run()
{
while(true)
{
if(tick>0)
{
System.out.println(Thread.currentThread().getName()+"sale:"+tick--);
}
}
}
}
--------我们一般不采用static，因为生命周期太长，随着类的加载而加载，消亡而消亡。
因此，我们考虑到线程的安全问题。
Java对于多线程的安全问题，提供了专业化的解决方法，就是使用同步的方法。
同步的方法：同步代码块、同步函数
同步的修饰符：synchronized
我们会问：哪些需要同步呢？那就是我们需要共享的数据。
为了测试效果，我们采用了线程sleep的方法，并且抛出异常，但是run方法没有抛，因此我们不在run后throws。
同步代码
Class Ticket implements Runnable
{
Private static int tick=100;
Objiect obj=new Object();//我们任意的构造一个对象
Public void run()
{
While(true)
{
Synchronized(obj)
{
If(tick>0)
{
try{Thread.sleeep(10);}catch(Exception e){}
System.out.println(Thread.currentThread().getName()+”售票：”+tick--);
}
}
}
}
}
public class TicketDemo
{
public static void main(String []args)
{
Ticket t=new Ticket();
Thread t1=new Thread(t);
Thread t2=new Thread(t);
Thread t3=new Thread(t);
Thread t4=new Thread(t);
t1.start();
t2.start();
t3.start();
t4.start();
}
}
同步函数
同步函数：在同步的代码的最近函数前加synchronized修饰，但是run前不能加
Class Ticket implements Runnable
{
Private static int tick=100;
Public void run()
{
While(true)
{
tickSale();
}
}
Public synchronized void tickSale()
{
If(tick>0)
{
try{Thread.sleeep(10);}catch(Exception e){}
System.out.println(Thread.currentThread().getName()+”售票：”+tick--);
}
}
}
我们发现我们用的锁是：this。
那么，静态同步函数呢？
静态同步函数：Ticket.class
class Ticket implements Runnable
{
private static int tick=100;
boolean b=true;
public void run()
{
if(b)
{
while(true)
{
synchronized(Ticket.class) //锁是该字节码文件对象
{
if(tick>0)
{
try{Thread.sleep(10);}catch(Exception e){}
System.out.println(Thread.currentThread().getName()+"sale:"+tick--);
}
}
}
}
else
{
show();
}
}
public static synchronized void show()
{
if(tick>0)
{
try{Thread.sleep(10);}catch(Exception e){}
System.out.println(Thread.currentThread().getName()+"sale:"+tick--);
}
}
}
class TicketDemo
{
public static void main(String []args)
{
Ticket t=new Ticket();
Thread t1=new Thread(t);
Thread t2=new Thread(t);
t1.start();
try{Thread.sleep(10);}catch(Exception e){}
b=false();
t2.start();
}
}
