基础练习：两种多线程的对比使用例子（静态代理的理解）

第一种：顾客类作为影院类的代理，影院类为顾客类的属性
顾客类内部实现了影院类的方法，并加入了自己的方法。

public class HappyCinema {
    public static void main(String[] args) {
        Cinema c=new Cinema(20,"四毛影院");
        new Thread(new Customer(c,20),"顾客一").start();//定义Thread类作为顾客类线程的代理
        new Thread(new Customer(c,2),"顾客二").start();
    }
}

class Cinema{//定义一个影院类
    int available;//可用位置
    String name;

    public Cinema(int available, String name) {
        this.available = available;
        this.name = name;
    }

    public boolean bookTickets(int seats){//一个判断方法
        System.out.println("可用位置"+available);
       if(seats>available){return false;}
       else {available=available-seats;
       return  true;}
    }
}

class Customer implements Runnable{
    Cinema c;//定义一个影院类c作为顾客类的内部属性，表示顾客选择的影院
    int seats;//顾客购买的票数

    public Customer(Cinema c, int seats) {
        this.c = c;
        this.seats = seats;
    }

    @Override
    public void run() {
        synchronized (c){ boolean flag= c.bookTickets(seats);
         if(flag){
          System.out.println(Thread.currentThread().getName()+"出票成功"+"出票数目"+seats);
      }else System.out.println(Thread.currentThread().getName()+"出票失败"+"余票不足");
    }}
}

第二种：顾客类直接继承Thread类，作为航空公司类的代理
这样做的好处是在代理的时候可以加入自己的属性

public class HappyPlaneWeb {
    public static void main(String[] args) {
        PlaneWeb p=new PlaneWeb(20,"四毛航空");//定义一个飞机票网站
        new Passenger(p,"顾客1",20).start();//Passenger类直接作为PlaneWeb类线程代理，因为Passenger没有重写run方法，默认调用p的run方法
        new Passenger(p,"顾客2",2).start();
    }
}

class Passenger extends Thread{//继承Thread类，准备作为PlaneWeb的代理
    int seats;//乘客购票数，新增的属性！
    public Passenger(Runnable target, String name,int seats) {
        super(target,name);
        this.seats = seats;
    }
    //该类继承Thread类，没有重写run方法，run方法默认调用target.run()方法
}


class PlaneWeb implements Runnable{
    int availble;//可用的位置
    String name;

    public PlaneWeb(int availble, String name) {
        this.availble = availble;
        this.name = name;
    }

    @Override
    public synchronized void run() {
       Passenger p= (Passenger) Thread.currentThread();//小技巧：当前线程可以强转为Thread的子类，作用是得到当前线程Passenger类，则得到哪一个顾客在使用
        boolean flag=bookTickets(p.seats);
        if(flag){
            System.out.println(p.getName()+"预定成功"+"预定数目"+p.seats);
        }else  System.out.println(p.getName()+"预定失败"+"余票数目不足");
    }

    public boolean bookTickets(int seats){
        System.out.println("可预定位置数"+availble);
        if(availble>=seats){
            availble=availble-seats;
            return true;}
        else{return false;}
    }
}