Java 多线程卖票

在实际应用中，我们经常用到多线程，如车站的售票系统，车站的各个售票口相当于各个线程。当我们做这个系统的时候可能会想到两种方式来实现，继承Thread类或实现Runnable接口，现在看一下这两种方式实现的两种结果。

继承Thread类:

class MyThread extends Thread {

    private int ticket = 5;
    private String name;

    public MyThread(String name) {
        this.name = name;
    }

    public void run() {
     //for监控每个窗口卖票的张数，必须有，不然只买1张就结束
        for (int i = 0; i < 500; i++) {
            if (this.ticket > 0) {
                System.out.println(this.name + "第"+i+"次卖票---->" + (this.ticket--));
            }
        }
    }
}

public class TicketsThread {

    public static void main(String[] args) {
        //创建三个线程，模拟三个窗口卖票
        MyThread mt1 = new MyThread("一号窗口");
        MyThread mt2 = new MyThread("二号窗口");
        MyThread mt3 = new MyThread("三号窗口");


        //启动这三个线程，即窗口，开始卖票
        mt1.start();
        mt2.start();
        mt3.start();
    }

}

运行结果：

继承Thread类的，我们相当于拿出三件事即三个卖票5张的任务分别分给三个窗口，他们各做各的事各卖各的票各完成各的任务，因为MyThread继承Thread类，所以在new MyThread的时候在创建三个对象的同时创建了三个线程；

实现Runable方法

class MyThread1 implements Runnable{
    private int ticket =10;
    private String name;
    public void run(){
        for(int i =0;i<500;i++){
            if(this.ticket>0){                  
 System.out.println(Thread.currentThread().getName()+"第"+i+"次"+"卖票---->"+(this.ticket--));
            }
        }
    }
}
public class TicketsRunable {


    public static void main(String[] args) {
        // TODO Auto-generated method stub
        //设计三个线程
        MyThread1 mt = new MyThread1();
        Thread t1 = new Thread(mt,"一号窗口");
        Thread t2 = new Thread(mt,"二号窗口");
        Thread t3 = new Thread(mt,"三号窗口");
//         MyThread1 mt2 = new MyThread1();
//         MyThread1 mt3 = new MyThread1();
        t1.start();
        t2.start();
        t3.start();
    }

}

运行结果

实现Runnable的， 相当于是拿出一个卖票10张得任务给三个人去共同完成，new MyThread1相当于创建一个任务，然后实例化三个Thread，创建三个线程即安排三个窗口去执行。

线程安全

上面的两种方式是实现多线程的基本方式，但是在运行的时候有的时候发现同一张票会卖2次，线程不安全，数据未同步。

synchronized

  public void run() {
        while (this.ticket > 0) {
            synchronized (this) {
                System.out.println(Thread.currentThread().getName() + "第" + "次" + "卖票---->" + (this.ticket--));
            }
        }
    }

多次跑会出现这种情况，还是线程不安全，思考一下，如果2 3窗口在还有1张被锁住，等待完资源，此时数据已经脏了。
this.ticket这部操作，将ticket从主内存读取到工作内存，2号 3号同时读取了2个副本，因此可能出现不安全情况。

class MyThread1 implements Runnable {
    private int ticket = 20;
    private String name;

    public void run() {
        while (true) {
            synchronized (this) {
                if (this.ticket > 0) {
                    System.out.println(Thread.currentThread().getName() + "第" + "次" + "卖票---->" + (this.ticket--));
                }
            }
        }
    }
}

线程安全，数据正常。
1. 获得同步锁；
2. 清空工作内存；
3. 从主内存拷贝对象副本到工作内存；this.ticket到工作内存
4. 执行代码(计算或者输出等)；
5. 刷新主内存数据；
6. 释放同步锁。
所以使用synchronized ，锁的位置很重要！！！

volatile

class MyThread1 implements Runnable{
    private volatile int ticket =20;
    private String name;
    public  void run(){
       while (this.ticket>0){      
                               System.out.println(Thread.currentThread().getName()+"第"+"次"+"卖票---->"+(this.ticket--));
        }
    }
}

线程安全，数据正常。volatile
1. 将变量i从主内存拷贝到工作内存；
2. 改变i的值；
3. 刷新主内存数据；
4. 将变量j从主内存拷贝到工作内存；
5. 改变j的值；
6. 刷新主内存数据；

参考：
http://mars914.iteye.com/blog/1508429
http://blog.csdn.net/mccand1234/article/details/52130271