Thread synchronization - producers and consumers, tortoise and rabbit race, dual thread printing

This paper mainly introduces the classic case of thread synchronization and its code implementation , And explained four ways of thread synchronization , And its application in classic cases ！

1. There are four ways to implement the same object lock shared by multiple threads

Scheme 1 ：

• Create a thread task , To four thread objects （ There is only one thread task object , Member variable of object （ Object lock ） There is only one ）

---

Option two ：

• Use static Decorate the member variables that need to be shared （ This static variable （ Object lock ） All objects created by this class ）

  ---

---

Option three ：

• Create a utility class , It contains static member variables （ Use the class name . Variable name （ Object lock ） call ）

Dual thread printing is implemented in this way

---

Option four ：

• Using constructors （ Similar to interface callback ： Provide a parameterized constructor for thread tasks , When creating a thread task, pass , It can ensure that multiple thread tasks operate on the same incoming external object （ Object lock ））

Tortoise and the hare 、 Producers and consumers are realized in this way

2. Producers and consumers

---

• Use the synchronization method to realize thread synchronization , When creating a thread task , Using constructors （ Similar to interface callback ： Provide a parameterized constructor for thread tasks , When creating a thread task, pass , It can ensure that multiple thread tasks operate on the same incoming external object （ Object lock ））
• The code comments are very detailed
  

（1） factory （ Contains synchronization methods , It is also the following thread synchronization lock object ）

public class Factory {
    
	// The maximum number of warehouses 
	private final int maxNum=10;
	// Current quantity of warehouse 
	private int currentNum=0;
	
	// Factory production method 
	public synchronized void get() {
    
		
		// Time to produce goods （ Block for a while ）
		try {
    
			Thread.sleep(1000);
		} catch (InterruptedException e) {
    
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		
		// Get producer information 
		String name=Thread.currentThread().getName();
		// Warehouse is not full 
		if (currentNum<maxNum) {
    
			// goods +1
			currentNum++;
			// Output production information 
			System.out.println(name+" Produced a commodity , The current quantity of goods in the warehouse is ："+currentNum);
			// Wake up all consumers to sell , Continue to produce by yourself 
			this.notifyAll();
		}
		else {
    	//  The warehouse is full 
			System.out.println(name+" Stop production （ The warehouse is full ）");
			// Fall into indefinite sleep , Waiting for consumers to wake up 
			try {
    
				this.wait();	//  Thread goes to sleep , It will not occupy lock resources （ Lock object ）
			} catch (InterruptedException e) {
    
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
	}
	
	// Factory consumption method 
	public synchronized void put() {
    
		
		// Time to consume goods （ Block for a while ）
		try {
    
			Thread.sleep(1000);
		} catch (InterruptedException e) {
    
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		
		// Access to consumer information 
		String name=Thread.currentThread().getName();
		// Whether there are goods in the warehouse 
		if (currentNum>0) {
    
			currentNum--;
			// Output consumption information 
			System.out.println(name+" Sold a commodity , The current quantity of goods in the warehouse is ："+currentNum);
			// Wake up consumers to produce goods 
			this.notifyAll();
		}
		else {
    	//  The warehouse is empty 
			// Output information 
			System.out.println(name+" Stop selling （ The warehouse is empty ）");
			// Consumers go into indefinite sleep , Wait for the producer to wake up 
			try {
    
				this.wait();// Thread to sleep , It will not occupy lock resources 
			} catch (InterruptedException e) {
    
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
	}
}

(2) producer

public class ProductionRunnable implements Runnable{
    

	// Guarantee to be in the same factory （ The same lock object ）
	private Factory factory;
	
	// Constructors 
	public ProductionRunnable(Factory factory) {
    
		// TODO Auto-generated constructor stub
		this.factory=factory;	// Guarantee to be in the same factory （ The same lock object ）
	}
	
	@Override
	public void run() {
    
		// TODO Auto-generated method stub
		// It means always producing 
		while(true) {
    
			this.factory.get();
		}
	}

}

(3) consumer

public class SaleRunnable implements Runnable {
    
	// Ensure the same lock object （ The same factory ）
	private Factory factory;
	
	// Constructors 
	public SaleRunnable(Factory factory) {
    
		// TODO Auto-generated constructor stub
		this.factory=factory;
	}

	@Override
	public void run() {
    
		// TODO Auto-generated method stub
		// Indicates that this thread has been selling 
		while(true) {
    
			this.factory.put();
		}
		
	}
}

(4) Test environment

public class Test {
    

	public static void main(String[] args) {
    
		// TODO Auto-generated method stub
		// Create a factory （ only one , Ensure the same lock ）
		Factory factory=new Factory();

		// Create workers 
		Thread thread01=new Thread(new SaleRunnable(factory)," Xiaofang ");
		Thread thread02=new Thread(new ProductionRunnable(factory)," Lao Li ");
		Thread thread03=new Thread(new ProductionRunnable(factory)," Xiao Zhang ");
		
		// Start thread , Workers work 
		thread01.start();
		thread02.start();
		thread03.start();		
	}
}

3. Tortoise and the hare

---

（1） Running （ Contains synchronization methods , It is also the following thread synchronization lock object ）

public class Race {
    
	
	// Rabbits run 
	public synchronized void rabbitRun() {
    
		
		// Get thread name 
		String name = Thread.currentThread().getName();
		
		for(int i=1;i<=100;i++) {
    
			// Consume 10ms
			try {
    
				this.wait(10);
			} catch (InterruptedException e) {
    
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			// Print the results 
			if (i==81) {
    
				// The rabbit went to sleep 
				try {
    
					System.out.println(name+" fell asleep ！");
					this.wait();
				} catch (InterruptedException e) {
    
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
				System.out.println(name+" Wake up ");
			}
			
			System.out.println(name+" ran ："+i+" rice ");
			
		}
		System.out.println(name+" After running ！");
	}
	
	// The tortoise runs 
	public synchronized void tortoiseRun() {
    
		// Get thread name 
		String name = Thread.currentThread().getName();
		
		for(int i=1;i<=100;i++) {
    
			// Consume 10ms
			try {
    
				this.wait(100);
			} catch (InterruptedException e) {
    
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			System.out.println(name+" ran ："+i+" rice ");
		}
		
		// To the end , Wake up the rabbit 
		System.out.println(name+" After running ！");
		this.notifyAll();// Wake up the rabbit 
	}
}

（2） Rabbit thread task

public class RabbitRunnable implements Runnable {
    
	// Definition Race Variable 
	private Race race;
	
	// Constructor receives lock object 
	public RabbitRunnable(Race race) {
    
		this.race=race;
	}

	// Call the synchronization method , The object that calls the synchronization method when locking the object 
	@Override
	public void run() {
    
		// TODO Auto-generated method stub
		this.race.rabbitRun();
	}
}

（3） Turtle thread task

public class TortoiseRunnable implements Runnable {
    
	// Definition Race object 
	private Race race;
	
	// Receive lock object 
	public TortoiseRunnable(Race race) {
    
		this.race=race;
	}

	// Start running 
	@Override
	public void run() {
    
		// TODO Auto-generated method stub
		this.race.tortoiseRun();
	}
}

（4） Test environment

public class Test {
    

	public static void main(String[] args) {
    
		// TODO Auto-generated method stub
		// Create a run 
		Race race=new Race();
		
		// Create task object 
		RabbitRunnable runnable01=new RabbitRunnable(race);
		TortoiseRunnable runnable02=new TortoiseRunnable(race);
		
		// Create thread 
		Thread thread01=new Thread(runnable01, " The rabbit ");
		Thread thread02=new Thread(runnable02, " Tortoise ");
		
		// Start thread 
		thread01.start();
		thread02.start();
		
	}

}

4. Dual thread printing

---

Mission ： Print a12b45c56…( Create two threads to print letters and numbers respectively )
The core idea ： Create a utility class , It contains a static final Decorated objects act as locks , Then realize the continuous printing of letters and numbers

(1) Create a static lock object

public class Lock {
    
	// Declare a lock object 
	public static final Object LOCK=new Object();
	
}

(2) Letter printing thread task

public class CharRunnable implements Runnable {
    

	@Override
	public void run() {
    
		// TODO Auto-generated method stub
		synchronized (Lock.LOCK) {
    
			for(int i=97;i<=122;i++) {
    
				// Wake up the digital process 
				Lock.LOCK.notifyAll();
				// Print character 
				System.out.println((char)i);
				// Go to sleep 
				try {
    
					Lock.LOCK.wait();	// The thread currently using this lock enters sleep 
				} catch (InterruptedException e) {
    
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
			// After the last letter is printed , Wake up the digital thread 
			Lock.LOCK.notifyAll();
		}
	}
	
}

(3) Digital print thread task

public class NumRunnable implements Runnable {
    

	@Override
	public void run() {
    
		// TODO Auto-generated method stub
		synchronized (Lock.LOCK) {
    
			for(int i=1;i<=52;i++) {
    
				// Wake up the letter printing thread 
				Lock.LOCK.notifyAll();
				// Print digit 
				System.out.println(i++);
				System.out.println(i);
				// Digital printing goes into sleep 
				try {
    
					Lock.LOCK.wait();
				} catch (InterruptedException e) {
    
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
			
		}
	}

}

(4) Test environment

public class Test {
    
	
	public static void main(String[] args) {
    
		// TODO Auto-generated method stub
		Thread thread01=new Thread(new CharRunnable());
		Thread thread02=new Thread(new NumRunnable());
		
		thread01.start();
		thread02.start();
	}

}