线程同步基础之使用非依赖属性实现同步

当使用synchronized关键字来保护代码块时，必须把对象引用作为传入参数。通常情况下，使用this关键字来引用执行方法所属的对象，也可以使用其他的对象对其进行引用。一般来说，这些对象就是为这个目的而创建的。例如，在类中有两个非依赖属性，它们被多个线程共享，你必须同步每一个变量的访问，但是同一时刻只允许一个线程访问一个属性变量，其他某个线程访问另一个属性变量。

这里我们演示电影院售票场景。这个范例模拟了有两个屏幕和两个售票处的电影院。一个集票处卖出的一张票，只能用于其中一个屏幕，不能同时用于两个屏幕，因此每个电影院的剩余票数是独立的属性。

示例：

package concurrency;

public class Main9 {
    public static void main(String[] args) {
        Cinema cinema = new Cinema();
        TicketOffice1 ticketOffice1 = new TicketOffice1(cinema);
        Thread thread1 = new Thread(ticketOffice1,"TicketOffice1");
        TicketOffice2 ticketOffice2 = new TicketOffice2(cinema);
        Thread thread2 = new Thread(ticketOffice2,"TicketOffice2");
        thread1.start();
        thread2.start();
        try {
            //等待这两个线程结束！！
            thread1.join();
            thread1.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.printf("Room 1 Vacancies:  %d\n", cinema.getVacanciesCinema1());
        System.out.printf("Room 2 Vacancies:  %d\n", cinema.getVacanciesCinerna2());
    }
}

//电影院类
class Cinema{
    private long vacanciesCinema1;
    private long vacanciesCinema2;
    private final Object controlCinema1,controlCinema2;
    public Cinema(){
        controlCinema1 = new Object();
        controlCinema2 = new Object();
        vacanciesCinema1 = 20;
        vacanciesCinema2 = 20;
    }
    public boolean sellTickets1(int number) {
        synchronized (controlCinema1) {
            if(number < vacanciesCinema1){
                vacanciesCinema1 -= number;
                return true;
            }else{
                return false;
            }
        }
    }
    public boolean sellTickets2(int number) {
        synchronized (controlCinema2) {
            if(number < vacanciesCinema2){
                vacanciesCinema2 -= number;
                return true;
            }else{
                return false;
            }
        }
    }
    public boolean returnTickets1(int number){
        synchronized (controlCinema1) {
            vacanciesCinema1 += number;
            return true;
        }
    }
    public boolean returnTickets2(int number){
        synchronized (controlCinema2) {
            vacanciesCinema2 += number;
            return true;
        }
    }
    public long getVacanciesCinema1(){
        return vacanciesCinema1;
    }
    public long getVacanciesCinerna2(){
        return vacanciesCinema2;
    }
}

//售票处1
class TicketOffice1 implements Runnable{
    private Cinema cinema;
    public TicketOffice1(Cinema cinema) {
        this.cinema = cinema;
    }
    //模拟对电影院的操作
    @Override
    public void run() {
        cinema.sellTickets1(3);
        cinema.sellTickets1(2);
        cinema.sellTickets2(2);
        cinema.returnTickets1(3);
        cinema.sellTickets1(5);
        cinema.sellTickets2(2);
        cinema.sellTickets2(2);
    }
}

//售票处2
class TicketOffice2 implements Runnable{
    private Cinema cinema;
    public TicketOffice2(Cinema cinema) {
        this.cinema = cinema;
    }
    //模拟对电影院操作
    @Override
    public void run() {
        cinema.sellTickets2(2);
        cinema.sellTickets2(4);
        cinema.sellTickets1(2);
        cinema.sellTickets1(1);
        cinema.returnTickets2(2);
        cinema.sellTickets1(3);
        cinema.sellTickets2(2);
        cinema.sellTickets1(2);
    }
}

用synchronized关键字保护代码块时，我们使用对象作为它的传入参数。JVM保证同一时间只有一个线程能够访问这个对象保护的代码保护块（注意：我们一直谈论的是对象，不是类）。

备注：这个例子使用了一个对象来控制对vacanciesCinema1属性的访问，所以同一时间只有一个线程能够修改这个属性； 使用了另一个对象来控制vacanciesCinema2属性的访问，所以同一时间只有一个线程能够修改这个属性。但是，这个例子允许同时运行两个线程：一个修改vacancesCinema1属性，另一个修改vacanciesCinema2属性。