卖1000张火车票用Runnable、继承Thred实现经典案例

描述：

1. 铁道部发布了一个售票任务，要求销售1000张票，要求有5个窗口来进行销售，请编写多线程程序来模拟这个效果

i. 窗口001正在销售第1000张票

ii. 窗口001正在销售第999张票

iii. 窗口002正在销售第998张票

iv. 。。。

v. 窗口05正在销售第1张票

vi. 票已经销售完毕

 

启动任务（Runnable）实现卖票操作

第一种方法：同步代码块

首先建立5个线程进行后续卖票操作

public class TaskTest {
	public static void main(String[] args) {
		Mythread1  mythread1 = new Mythread1();
		for(int i=1;i<=5;i++){
			new Thread(mythread1, "窗口00"+i).start();//循环创建五个线程
		}
	}
}

建立一个类去实现Runnable接口：

class Mythread1 implements Runnable{
	private int ticket=1000;
	//重写run方法，实现卖票操作
	@Override
	public void run() {
		//方式1：同步代码块
		while(true){
			synchronized (this) {//同步代码块，实现同一时间只有一个线程进行卖票操作
				try {
					Thread.sleep(1);//休眠一毫秒---复现问题和抢占资源效果
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
				if(ticket>0){
					System.out.println(Thread.currentThread().getName()+"正在销售第"+ticket+"张票");
					ticket--;
				}else{
					System.out.println(Thread.currentThread().getName()+"销售完毕~~");
					break;
				}
			}
		}
        }
}

第二种方法：同步方法

	//重写run方法
        public void run() {
    		while(true){
			try {
				Thread.sleep(1);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			if(!this.Save2()){//返回false则退出
				break;
			}
		}
	}
	//方式2：同步方法----1，同一个锁对象，2，锁的范围
	public synchronized boolean Safe(){
		if(ticket>0){
			System.out.println(Thread.currentThread().getName()+"正在销售第"+ticket+"张票");
			ticket--;
			return true;
		}else{
			System.out.println(Thread.currentThread().getName()+"票已经卖完~~");
			return false;
		}
	}

第三种方法：互斥对象锁

                //在类中利用多态的形式实现lock接口
                private Lock lock = new ReentrantLock();
                //3:互斥对象锁-----容易出现死锁
		//1：同一把锁--同一个lock 2:锁的范围
		//锁释放两次会崩溃,使用捕获Try保证安全性，提高可读性
		while(true){
			try{
				lock.lock();//加锁
				if(ticket>0){
					System.out.println(Thread.currentThread().getName()+"正在销售第"+ticket+"张票");
					ticket--;
				}else{
					System.out.println(Thread.currentThread().getName()+"票已经卖完~~");
					break;
				}	
			}finally{
				lock.unlock();//释放锁
			}
		}

以上三种方式，解决以下三个问题：

1：一个线程进去，每个线程都有可能去执行打印1000张，卖了5000张票

2：再卖完最后一张票时，已经由多个线程进入while循环，票已经卖完，但是线程还

在，在锁外等待，那么线程会继续往下走执行减减操作，出现票数为负

3：每个线程卖完票后都应该退出，

 

 

介绍完使用任务的方式实现售票，接下来介绍继承Thread的方式解决相同的问题

同样的，我们在主函数中，建立5个线程

        public static void main(String[] args) {
		for(int i=1;i<6;i++){
			new MyThread("窗口00"+i).start();
		}
	}

然后写Mythread类继承父类Thread，

第一种方法：同步代码块

                private static int ticket=1000;
                private static Object obj =new Object();//自主建立obj对象，
                //主函数中传入了字符串“窗口00”，那么建立构造方法去接收即可
	        public MyThread(String name) {
		    super(name);
	        }
                while(true){
			synchronized (obj) {
				try {
					Thread.sleep(1);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
				if(ticket>0){
					System.out.println(Thread.currentThread().getName()+"正在销售第"+ticket+"张票");
					ticket--;
				}else{
					System.out.println(Thread.currentThread().getName()+"销售完毕~~");
					break;
				}
			}
		}

剩下的两种方法与Runable大同小异，关键点在于，用static去修饰方法和成员变量，做到实现操作

那么两类实现的对比

Runnable  Vs   Thread

1：使用实现任务方式，则能确保多线程操作同一个任务·，也就是任务中的属性为同一个，this也是同一个；

2：使用继承Thread方式，没new一个新的对象都有一份新的成员属性，所以需要加上static修饰，确保同一个成员属性·