[one_demo_17]使用传统方式实现线程间通信的例子

小鱼儿 2022-04-12 07:58 63阅读 0赞

题目： 子线程循环10次，接着到主线程循环10次；接着又回到子线程循环10次，接着又到主线程循环10次，如此循环50次。

使用Object的wait()和notify()方法实现。

Java代码

第一种，不使用面向对象的思想实现

/**
     * 练习线程间通信
     * 
     * @author Administrator
     *
     */
    public class ThreadCommunicationOld {
    	// 锁
    	private static String lock = "lock";
    
    	// 线程间通信的开关
    	private static boolean isSub = true;
    
    	public static void main(String[] args) {
    
    		// 子线程
    		new Thread(new Runnable() {
    			public void run() {
    				// 循环50次
    				for (int i = 0; i < 50; i++) {
    					// 加锁
    					synchronized (lock) {
    						// 如果不是子线程状态，就让子线程阻塞
    						if (!isSub) {
    							try {
    								lock.wait();
    							} catch (InterruptedException e) {
    								e.printStackTrace();
    							}
    						}
    						// 执行任务10次
    						for (int j = 0; j < 10; j++) {
    							System.out.println("sub thread sequence of " + j + ", loop of " + i);
    						}
    						// 执行完任务后，调整为非子线程状态
    						isSub = false;
    						// 唤醒主线程
    						lock.notify();
    					}
    				}
    			}
    		}).start();
    
    		// 主线程，执行50次
    		for (int i = 0; i < 50; i++) {
    			// 主线程加锁
    			synchronized (lock) {
    				// 判断是否为子线程状态，如果是子线程状态，就让主线程阻塞
    				if (isSub) {
    					try {
    						lock.wait();
    					} catch (InterruptedException e) {
    						e.printStackTrace();
    					}
    				}
    				// 执行任务10次
    				for (int j = 0; j < 10; j++) {
    					System.out.println("main thread sequence of " + j + ", loop of " + i);
    				}
    				// 调整为子线程状态
    				isSub = true;
    				// 唤醒子线程
    				lock.notify();
    			}
    		}
    	}
    
    }

第二种，使用面向对象的思想，将执行的业务放在一个业务类中，在这个业务类中，将执行的方法加上同步；另外，在判断线程状态时使用while取代if，防止出现假唤醒，也就是每次拿到锁后，都要判断状态。

/**
     * 练习线程间通信 题目： 子线程循环10次，接着到主线程循环100次；接着又回到子线程循环10次，接着又到主线程循环100次，如此循环50次
     * 
     * @author Administrator
     *
     */
    public class ThreadCommunicationOld2 {
    
    	public static void main(String[] args) {
    		// 创建业务对象
    		final Business business = new Business();
    		// 子线程
    		new Thread(new Runnable() {
    			public void run() {
    				// 循环50次
    				for (int i = 0; i < 50; i++) {
    					// 子线程业务
    					business.sub(i);
    				}
    			}
    		}).start();
    
    		// 主线程，执行50次
    		for (int i = 0; i < 50; i++) {
    			// 主线程业务
    			business.main(i);
    		}
    
    	}
    }
    
    // 将主线程或者子线程的业务交给业务类管理，更加的面向对象
    class Business {
    	// 线程状态标识
    	private boolean isSub = true;
    
    	// 主线程业务
    	public synchronized void main(int i) {
    		// 判断是否为子线程状态，如果是子线程状态，就让主线程阻塞
    		while (isSub) {
    			try {
    				this.wait();
    			} catch (InterruptedException e) {
    				e.printStackTrace();
    			}
    		}
    		// 执行任务10次
    		for (int j = 0; j < 10; j++) {
    			System.out.println("main thread sequence of " + j + ", loop of " + i);
    		}
    		// 调整为子线程状态
    		isSub = true;
    		// 唤醒子线程
    		this.notify();
    	}
    
    	// 子线程业务
    	public synchronized void sub(int i) {
    		// 如果不是子线程状态，就让子线程阻塞
    		while (!isSub) {
    			try {
    				this.wait();
    			} catch (InterruptedException e) {
    				e.printStackTrace();
    			}
    		}
    		// 执行任务10次
    		for (int j = 0; j < 10; j++) {
    			System.out.println("sub thread sequence of " + j + ", loop of " + i);
    		}
    		// 执行完任务后，调整为非子线程状态
    		isSub = false;
    		// 唤醒主线程
    		this.notify();
    	}
    }