使用非依赖属性实现同步

Love The Way You Lie 2022-08-09 09:51 131阅读 0赞

[使用非依赖属性实现同步][Link 1]

当使用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属性。  
　　运行这个范例，可以看到最终结果总是与每个电影院的剩余票数一致。

转自：[百度快照][Link 1]

[Link 1]: http://cache.baiducontent.com/c?m=9d78d513d9d431ac4f9de3690c66c0166f43f6102bd6a00209d0843e91735b30501794ac51220775d2d20d6216ae394b9a862101471421c78cb9fe5daeb18558249f5342671df65662d60edfcf5154c337e42cfeae69f0ccf325e0abc5a2ab4323c844040a9781f84d7013dd1e840347e7b19838022f17ad9a3572895860599d3441c6508fe6251e7496f7ad4b3db03da61106e6ab22c03d05b463b36f1a3337a35bc17f465632f74e57e8343a13e3ed4ae65a6e3020a13fb1aeb1b7fc39fdc8ad71c6f591e969d777e7b6f7e434073545fa52eef2e5e96e7345758897810bb753dea2bda74feb12dc155abf4a7658318834ca&p=84759a4780904ead34b2c8625a&newp=c96d8315d9c10ec30be296627f53d8304a02c70e3d98bc&user=baidu&fm=sc&query=%B1%BE%BD%DA%D6%D0%2C%CE%D2%C3%C7%BD%AB%CD%A8%B9%FD%B7%B6%C0%FD%D1%A7%CF%B0%CA%B5%CF%D6%B5%E7%D3%B0%D4%BA%CA%DB%C6%B1%B3%A1%BE%B0%B5%C4%B1%E0%B3%CC&qid=9397f52b0003d7e0&p1=3