黑马程序员-关于生产者消费者和火车票出售的线程问题

/*
    以车站售票为例说明资源共享问题，两个售票窗口同时
    出售一次列车的车票，车票就是共享资源，两个窗口就
    是两个线程。
    对象锁控制共享数据
        同步对象，同步方法，都可以实现对象锁
    
*/
//模拟售票功能的线程类
public class WinThread extends Thread{                    //继承Thread的线程类
    Tickets tk=null;                                    //记录售票数量
    int n=0;
    public WinThread(Tickets tickets,String name){        //构造方法
        super(name);
        this.tk=tickets;
    }
    public void run(){
        while(true){
            if(tk.getAmount()>0){
                tk.saleone();
                n=n+1;                                    //记录售票数量
                System.out.println(getName()+":"+n);
                try {
                    Thread.sleep(50);
                } catch (InterruptedException e) {
                    // TODO: handle exception
                }
            }else{
                System.out.println(getName()+":已无票");
                break;
            }
        }
    }
}
//票对象的类
public class Tickets {
    private int amount=100;                    //车票总数100，共享资源
    public synchronized int getAmount(){    
        return amount;
    }
    public synchronized void saleone(){        //买票方法
        amount=amount-1;
    }
}
//售票系统
public class TicketTS {
    public static void main(String args []){
        Tickets tick=new Tickets();
        Thread t1=new WinThread(tick, "1号售票员");
        Thread t2=new WinThread(tick, "2号售票员");
        t1.start();
        t2.start();
    }
}
/*
    生产者-消费者
    很多时候，不仅要防止共享资源的冲突问题，还是保证线程的同步
    需求：    有一个生产者producer，一个消费者consumer。生产者产生
    0~9的整数，将他存储在盒子BOX中。同时要求生产者产生一个数字，
    消费者消费一个数字，对于共享的box，涉及到线程同步问题。
    银行的存取款类似
*/
public class Box {
    private int data;
    private boolean available=false;    //表示数据的是否可用（产生数据）
    public synchronized void put(int value){
        while(available==true){            //结果为true时，说明已产生了数据，所以进入等待
            try {
                wait();                    //线程进入等待状态
            } catch (InterruptedException e) {}
        }
        //当跳出循环时，available为false,box无数据
        data=value;                        //产生数据
        available=true;                    //修改状态
        notifyAll();                    //唤醒其他线程
    }
    public synchronized int get(){
        while(available==false){    //当available为false,box无数据
            try {
                wait();
            } catch (InterruptedException e) {}
        }
        //跳出循环后，进行取出数据操作
        available=false;
        notifyAll();
        return data;    //    取出BOX里面的数据    
    }
}
public class Consumer extends Thread{
    private Box b;                //被共享的对象
    public Consumer(Box c){
        b=c;
    }
    public void run(){
        int value=0;
        for (int i = 0; i < 10;i++) {
            value=b.get();                    //从共享资源b取出资源
            System.out.println("Consumer "+"got:"+value);
        }
    }
}
public class PCT {
    public static void main(String args []){
        Box c=new Box();
        Producer p1=new Producer(c);
        Consumer c1=new Consumer(c);
        p1.start();
        c1.start();
    }
}
public class Producer extends Thread{
    private Box b;         
4000
0;      //被共享的对象
    public Producer(Box c){
        b=c;
    }
    public void run(){
        for (int i = 0; i < 10; i++) {
            b.put(i);
            System.out.println("Producer "+"put:"+i);
            try {
                sleep((int)(Math.random()*100));
            } catch (InterruptedException e) {
                // TODO: handle exception
            }
        }
    }
}