leetcode中怎么利用多线程打印零与奇偶数

这期内容当中小编将会给大家带来有关leetcode中怎么利用多线程打印零与奇偶数，文章内容丰富且以专业的角度为大家分析和叙述，阅读完这篇文章希望大家可以有所收获。

为秦皇岛等地区用户提供了全套网页设计制作服务，及秦皇岛网站建设行业解决方案。主营业务为成都做网站、网站制作、秦皇岛网站设计，以传统方式定制建设网站，并提供域名空间备案等一条龙服务，秉承以专业、用心的态度为用户提供真诚的服务。我们深信只要达到每一位用户的要求，就会得到认可，从而选择与我们长期合作。这样，我们也可以走得更远！

假设有这么一个类：
class ZeroEvenOdd {
public ZeroEvenOdd(int n) { ... } // 构造函数
public void zero(printNumber) { ... } // 仅打印出 0
public void even(printNumber) { ... } // 仅打印出偶数
public void odd(printNumber) { ... } // 仅打印出奇数
}
相同的一个 ZeroEvenOdd 类实例将会传递给三个不同的线程：
线程 A 将调用 zero()，它只输出 0 。
线程 B 将调用 even()，它只输出偶数。
线程 C 将调用 odd()，它只输出奇数。
每个线程都有一个 printNumber 方法来输出一个整数。请修改给出的代码以输出整数序列 010203040506... ，其中序列的长度必须为 2n。

示例 1：
输入：n = 2
输出："0102"
说明：三条线程异步执行，其中一个调用 zero()，另一个线程调用 even()，最后一个线程调用odd()。正确的输出为 "0102"。
示例 2：
输入：n = 5
输出："0102030405"

实现方案1——传统方式

package com.lau.multithread.printoddeven;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.function.Consumer;

/** 
 * 
 * 打印零与奇偶数——实现方案——传统方式
	假设有这么一个类：
	
	class ZeroEvenOdd {
	  public ZeroEvenOdd(int n) { ... }      // 构造函数
	  public void zero(printNumber) { ... }  // 仅打印出 0
	  public void even(printNumber) { ... }  // 仅打印出 偶数
	  public void odd(printNumber) { ... }   // 仅打印出 奇数
	}
	相同的一个 ZeroEvenOdd 类实例将会传递给三个不同的线程：
	
	线程 A 将调用 zero()，它只输出 0 。
	线程 B 将调用 even()，它只输出偶数。
	线程 C 将调用 odd()，它只输出奇数。
	每个线程都有一个 printNumber 方法来输出一个整数。请修改给出的代码以输出整数序列 010203040506... ，其中序列的长度必须为 2n。
	
	 
	
	示例 1：
	
	输入：n = 2
	输出："0102"
	说明：三条线程异步执行，其中一个调用 zero()，另一个线程调用 even()，最后一个线程调用odd()。正确的输出为 "0102"。
	示例 2：
	
	输入：n = 5
	输出："0102030405"
 * 
 * 
*/
class ZeroEvenOdd {
	  private volatile int flag = 0;
	
	  private volatile int n;
	  
	  private AtomicInteger i;
	
	  //构造函数
	  public ZeroEvenOdd(int n) {
		  this.n = n;
		  this.i = new AtomicInteger(1);
	  }      
	  
	  //仅打印出 0
	  public void zero(Runnable printNumber) {
		  for(int k = 0; k < n; k++) {
			synchronized (this) {
				try {
					while(0 != this.flag) {
						this.wait();
					}
					
					printNumber.run();
					
					flag = 1;
				} 
				catch (InterruptedException e) {
					e.printStackTrace();
				}
				finally {
					this.notifyAll();
				}
			}
		 }
	  } 
	  
	  //仅打印出 偶数
	  public void even(Consumer printNumber) {
		  for(int k = 0; k < n; k++) {
				synchronized (this) {
					try {
						while(1 != this.flag) {
							this.wait();
						}
						
						if(this.i.get() % 2 == 0) {
							printNumber.accept(this.i.get());
							this.i.incrementAndGet();
							flag = 0;
						}
						else {
							flag = 2;
						}
						
						this.notifyAll();
					} 
					catch (InterruptedException e) {
						e.printStackTrace();
					}
				}
		  }
	  }

	  //仅打印出 奇数
	  public void odd(Consumer printNumber) {
		  for(int k = 0; k < n; k++) {
				synchronized (this) {
					try {
						while(2 != this.flag) {
							this.wait();
						}
						
						printNumber.accept(this.i.get());
						
						this.i.incrementAndGet();
						
						flag = 0;
						
						this.notifyAll();
					} 
					catch (InterruptedException e) {
						e.printStackTrace();
					}
				}
		 }
	}
}



public class PrintOddEvenDemo {

	public static void main(String[] args) {
		ExecutorService threadPool = Executors.newFixedThreadPool(3);
		
		ZeroEvenOdd zeroEvenOdd = new ZeroEvenOdd(9);
		
		threadPool.submit(() -> zeroEvenOdd.zero(() -> System.out.print("0")));
		threadPool.submit(() -> zeroEvenOdd.even(t -> System.out.print(String.valueOf(t))));
		threadPool.submit(() -> zeroEvenOdd.odd(t -> System.out.print(String.valueOf(t))));
		
		threadPool.shutdown();
	}

}

实现方案2——锁方式

package com.lau.multithread.printoddeven;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
import java.util.function.Consumer;

/** 
 * 
 * 打印零与奇偶数——实现方案——锁方式
	假设有这么一个类：
	
	class ZeroEvenOdd {
	  public ZeroEvenOdd(int n) { ... }      // 构造函数
	  public void zero(printNumber) { ... }  // 仅打印出 0
	  public void even(printNumber) { ... }  // 仅打印出 偶数
	  public void odd(printNumber) { ... }   // 仅打印出 奇数
	}
	相同的一个 ZeroEvenOdd 类实例将会传递给三个不同的线程：
	
	线程 A 将调用 zero()，它只输出 0 。
	线程 B 将调用 even()，它只输出偶数。
	线程 C 将调用 odd()，它只输出奇数。
	每个线程都有一个 printNumber 方法来输出一个整数。请修改给出的代码以输出整数序列 010203040506... ，其中序列的长度必须为 2n。
	
	 
	
	示例 1：
	
	输入：n = 2
	输出："0102"
	说明：三条线程异步执行，其中一个调用 zero()，另一个线程调用 even()，最后一个线程调用odd()。正确的输出为 "0102"。
	示例 2：
	
	输入：n = 5
	输出："0102030405"
 * 
 * 
*/
class ZeroEvenOdd2 {
	  private final Lock lock = new ReentrantLock();
	  
	  final Condition zeroCd = lock.newCondition();
	  final Condition evenCd = lock.newCondition();
	  final Condition oddCd = lock.newCondition();
	
	  private volatile int flag = 0;
	
	  private volatile int n;
	  
	  private AtomicInteger i;
	
	  //构造函数
	  public ZeroEvenOdd2(int n) {
		  this.n = n;
		  this.i = new AtomicInteger(1);
	  }      
	  
	  //仅打印出 0
	  public void zero(Runnable printNumber) {
		  for(int k = 0; k < n; k++) {
				try {
					lock.lock();
					
					while(0 != this.flag) {
						zeroCd.await();
					}
					
					printNumber.run();
					
					flag = 1;
					
					evenCd.signal();
				} 
				catch (InterruptedException e) {
					e.printStackTrace();
				}
				finally {
					lock.unlock();
				}
			}
	  } 
	  
	  //仅打印出 偶数
	  public void even(Consumer printNumber) {
		  for(int k = 0; k < n; k++) {
				try {
					lock.lock();
					
					while(1 != this.flag) {
						evenCd.await();
					}
					
					if(this.i.get() % 2 == 0) {
						printNumber.accept(this.i.get());
						this.i.incrementAndGet();
						flag = 0;
						zeroCd.signal();
					}
					else {
						flag = 2;
						oddCd.signal();
					}
				} 
				catch (InterruptedException e) {
					e.printStackTrace();
				}
				finally {
					lock.unlock();
				}
			}
	  }

	  //仅打印出 奇数
	  public void odd(Consumer printNumber) {
		  for(int k = 0; k < n; k++) {
				try {
					lock.lock();
					
					while(2 != this.flag) {
						oddCd.await();
					}
					
					printNumber.accept(this.i.get());
					
					this.i.incrementAndGet();
					
					flag = 0;
					
					zeroCd.signal();
				} 
				catch (InterruptedException e) {
					e.printStackTrace();
				}
				finally {
					lock.unlock();
				}
			}
	}
}



public class PrintOddEvenDemo2 {

	public static void main(String[] args) {
		ExecutorService threadPool = Executors.newFixedThreadPool(3);
		
		ZeroEvenOdd2 zeroEvenOdd = new ZeroEvenOdd2(5);
		
		threadPool.submit(() -> zeroEvenOdd.zero(() -> System.out.print("0")));
		threadPool.submit(() -> zeroEvenOdd.even(t -> System.out.print(String.valueOf(t))));
		threadPool.submit(() -> zeroEvenOdd.odd(t -> System.out.print(String.valueOf(t))));
		
		threadPool.shutdown();
	}

}

实现方案3——信号量

package com.lau.multithread.printoddeven;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Semaphore;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
import java.util.function.Consumer;

/** 
 * 
 * 打印零与奇偶数——实现方案——信号量
	假设有这么一个类：
	
	class ZeroEvenOdd {
	  public ZeroEvenOdd(int n) { ... }      // 构造函数
	  public void zero(printNumber) { ... }  // 仅打印出 0
	  public void even(printNumber) { ... }  // 仅打印出 偶数
	  public void odd(printNumber) { ... }   // 仅打印出 奇数
	}
	相同的一个 ZeroEvenOdd 类实例将会传递给三个不同的线程：
	
	线程 A 将调用 zero()，它只输出 0 。
	线程 B 将调用 even()，它只输出偶数。
	线程 C 将调用 odd()，它只输出奇数。
	每个线程都有一个 printNumber 方法来输出一个整数。请修改给出的代码以输出整数序列 010203040506... ，其中序列的长度必须为 2n。
	
	 
	
	示例 1：
	
	输入：n = 2
	输出："0102"
	说明：三条线程异步执行，其中一个调用 zero()，另一个线程调用 even()，最后一个线程调用odd()。正确的输出为 "0102"。
	示例 2：
	
	输入：n = 5
	输出："0102030405"
 * 
 * 
*/
class ZeroEvenOdd3 {
	  private final Semaphore zeroSp = new Semaphore(1);
	  private final Semaphore evenSp = new Semaphore(0);
	  private final Semaphore oddSp = new Semaphore(0);
	  
	  private volatile int n;
	  
	  private AtomicInteger i;
	
	  //构造函数
	  public ZeroEvenOdd3(int n) {
		  this.n = n;
		  this.i = new AtomicInteger(1);
	  }      
	  
	  //仅打印出 0
	  public void zero(Runnable printNumber) {
		  for(int k = 0; k < n; k++) {
				try {
					zeroSp.acquire();
					
					printNumber.run();
				} 
				catch (InterruptedException e) {
					e.printStackTrace();
				}
				finally {
					evenSp.release();
				}
		  }
	  } 
	  
	  //仅打印出 偶数
	  public void even(Consumer printNumber) {
		  for(int k = 0; k < n; k++) {
				try {
					evenSp.acquire();
					
					if(this.i.get() % 2 == 0) {
						printNumber.accept(this.i.get());
						this.i.incrementAndGet();
						zeroSp.release();
					}
					else {
						oddSp.release();
					}
				} 
				catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
	  }

	  //仅打印出 奇数
	  public void odd(Consumer printNumber) {
		  for(int k = 0; k < n; k++) {
				try {
					oddSp.acquire();
					
					printNumber.accept(this.i.get());
					
					this.i.incrementAndGet();
					
				} 
				catch (InterruptedException e) {
					e.printStackTrace();
				}
				finally {
					zeroSp.release();
				}
			}
	}
}



public class PrintOddEvenDemo3 {

	public static void main(String[] args) {
		ExecutorService threadPool = Executors.newFixedThreadPool(3);
		
		ZeroEvenOdd3 zeroEvenOdd = new ZeroEvenOdd3(10);
		
		threadPool.submit(() -> zeroEvenOdd.zero(() -> System.out.print("0")));
		threadPool.submit(() -> zeroEvenOdd.even(t -> System.out.print(String.valueOf(t))));
		threadPool.submit(() -> zeroEvenOdd.odd(t -> System.out.print(String.valueOf(t))));
		
		threadPool.shutdown();
	}

}

输出：

010203040506070809

上述就是小编为大家分享的leetcode中怎么利用多线程打印零与奇偶数了，如果刚好有类似的疑惑，不妨参照上述分析进行理解。如果想知道更多相关知识，欢迎关注创新互联行业资讯频道。

标题名称：leetcode中怎么利用多线程打印零与奇偶数
当前链接：http://cxhlcq.com/article/jespii.html

leetcode中怎么利用多线程打印零与奇偶数

实现方案1——传统方式

实现方案2——锁方式

实现方案3——信号量

其他资讯

网站制作

企业服务

网站建设

服务器托管