使用非依赖属性实现同步

使用非依赖属性实现同步

       当使用synchronized关键字来保护代码块时，必须把对象引用作为传入参数。通常情况下，使用this关键字来引用执行方法所属的对象，也可以使用其他的对象对其进行引用。 一般来说，这些对象就是为这个目的而创建的。例如，在类中有两个非依赖属性，它们被 多个线程共享，你必须同步每一个变量的访问，但是同一时刻只允许一个线程访问一个属性变量，其他某个线程访问另一个属性变量。
　　在本节中，我们将通过范例学习实现电影院售票场景的编程。这个范例模拟了有两个屏幕和两个售票处的电影院，一个售票处卖出的一张票，只能用于其中一个电影院，不能同时用于两个电影院，因此每个电影院的剩余票数是独立的属性。

package com.packtpub.java7.concurrency.chapter2.recipe2.core;

import com.packtpub.java7.concurrency.chapter2.recipe2.task.Cinema;
import com.packtpub.java7.concurrency.chapter2.recipe2.task.TicketOffice1;
import com.packtpub.java7.concurrency.chapter2.recipe2.task.TicketOffice2;

/**
 * Core class of the example. Creates a cinema and two threads for
 * the ticket office. Run the threads to analyze the results obtained
 *
 */
public class Main {

	/**
	 * Main method of the example
	 * @param args
	 */
	public static void main(String[] args) {
		// Creates a Cinema
		Cinema cinema=new Cinema();
		
		// Creates a TicketOffice1 and a Thread to run it
		TicketOffice1 ticketOffice1=new TicketOffice1(cinema);
		Thread thread1=new Thread(ticketOffice1,"TicketOffice1");

		// Creates a TicketOffice2 and a Thread to run it
		TicketOffice2 ticketOffice2=new TicketOffice2(cinema);
		Thread thread2=new Thread(ticketOffice2,"TicketOffice2");
		
		// Starts the threads
		thread1.start();
		thread2.start();
		
		try {
			// Waits for the finalization of the threads
			thread1.join();
			thread2.join();
		} catch (InterruptedException e) {
			e.printStackTrace();
		}

		// Print the vacancies in the cinemas
		System.out.printf("Room 1 Vacancies: %d\n",cinema.getVacanciesCinema1());
		System.out.printf("Room 2 Vacancies: %d\n",cinema.getVacanciesCinema2());
	}

}

package com.packtpub.java7.concurrency.chapter2.recipe2.task;

public class Cinema {
	
	/**
	 * This two variables store the vacancies in two cinemas
	 */
	private long vacanciesCinema1;
	private long vacanciesCinema2;

	/**
	 * Two objects for the synchronization. ControlCinema1 synchronizes the
	 * access to the vacancesCinema1 attribute and controlCinema2 synchronizes
	 * the access to the vacanciesCinema2 attribute.
	 */
	private final Object controlCinema1, controlCinema2;
	
	/**
	 * Constructor of the class. Initializes the objects
	 */
	public Cinema(){
		controlCinema1=new Object();
		controlCinema2=new Object();
		vacanciesCinema1=20;
		vacanciesCinema2=20;
	}
	
	/**
	 * This method implements the operation of sell tickets for the cinema 1
	 * @param number number of tickets sold
	 * @return true if the tickets are sold, false if there is no vacancies
	 */
	public boolean sellTickets1 (int number) {
		synchronized (controlCinema1) {
			if (number<vacanciesCinema1) {
				vacanciesCinema1-=number;
				return true;
			} else {
				return false;
			}
		}
	}
	
	/**
	 * This method implements the operation of sell tickets for the cinema 2
	 * @param number number of tickets sold
	 * @return true if the tickets are sold, false if there is no vacancies
	 */
	public boolean sellTickets2 (int number){
		synchronized (controlCinema2) {
			if (number<vacanciesCinema2) {
				vacanciesCinema2-=number;
				return true;
			} else {
				return false;
			}
		}
	}
	
	/**
	 * This method implements the operation of return tickets for the cinema 1
	 * @param number number of the tickets returned
	 * @return true
	 */
	public boolean returnTickets1 (int number) {
		synchronized (controlCinema1) {
			vacanciesCinema1+=number;
			return true;
		}
	}

	/**
	 * This method implements the operation of return tickets for the cinema 1
	 * @param number number of the tickets returned
	 * @return true
	 */
	public boolean returnTickets2 (int number) {
		synchronized (controlCinema2) {
			vacanciesCinema2+=number;
			return true;
		}
	}

	/**
	 * Return the vacancies in the cinema 1
	 * @return the vacancies in the cinema 1
	 */
	public long getVacanciesCinema1() {
		return vacanciesCinema1;
	}

	/**
	 * Return the vacancies in the cinema 2
	 * @return the vacancies in the cinema 2
	 */
	public long getVacanciesCinema2() {
		return vacanciesCinema2;
	}

}

package com.packtpub.java7.concurrency.chapter2.recipe2.task;

/**
 * This class simulates a ticket office. It sell or return tickets
 * for the two cinemas
 *
 */
public class TicketOffice1 implements Runnable {

	/**
	 * The cinema 
	 */
	private Cinema cinema;
	
	/**
	 * Constructor of the class
	 * @param cinema the cinema
	 */
	public TicketOffice1 (Cinema cinema) {
		this.cinema=cinema;
	}
	
	/**
	 * Core method of this ticket office. Simulates selling and returning tickets
	 */
	@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);
		cinema.sellTickets2(2);
	}

}

package com.packtpub.java7.concurrency.chapter2.recipe2.task;

/**
 * This class simulates a ticket office. It sell or return tickets
 * for the two cinemas
 *
 */
public class TicketOffice2 implements Runnable {

	/**
	 * The cinema 
	 */
	private Cinema cinema;
	
	/**
	 * Constructor of the class
	 * @param cinema the cinema
	 */
	public TicketOffice2(Cinema cinema){
		this.cinema=cinema;
	}
	
	/**
	 * Core method of this ticket office. Simulates selling and returning tickets
	 */
	@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属性的访问，所以同一时间只有一个线程能够修改这个属性。但是，这个例子允许同时运行两个线 程：一个修改vacancesCinemal属性，另一个修改vacanciesCinema2属性。
　　运行这个范例，可以看到最终结果总是与每个电影院的剩余票数一致。

转自：百度快照