多个线程之间共享数据的方式探讨

时间 2019-11-12

标签多个线程之间共享数据方式探讨繁體版

原文原文链接

1、概述

一、若是每一个线程执行的代码相同，可使用同一个Runnable对象，这个Runnable对象中有那个共享数据，例如，买票系统就能够这么作。java

/** 
* @Title: TicketSoldThreadTest.java 
* @Package com.lh.threadtest.t7 
* @Description: TODO
* @author Liu 
* @date 2018年1月17日 上午9:58:08 
* @version V1.0 
*/
package com.lh.threadtest.t7;

/** 
* @ClassName: TicketSoldThreadTest 
* @Description: 多个线程之间共享数据的方式探讨
* 
* 若是每一个线程执行的代码相同，可使用同一个Runnable对象，这个Runnable对象中有那个共享数据。
* 例如，买票系统就能够这么作
* 
* @author Liu
* @date 2018年1月17日 上午9:58:08 
*  
*/
public class TicketSoldThreadTest {

	/***
	* @Title: main 
	* @Description: TODO
	* @param @param args
	* @return void
	* @throws 
	*/
	public static void main(String[] args) {
		TicketSoldBusiness ticketSoldBusiness = new TicketSoldBusiness();
		for(int i = 0; i < 2; i++){
			new Thread(ticketSoldBusiness).start();
		}
		
	}

}

class TicketSoldBusiness implements Runnable{
	private int count = 10;
	
	private void dec(){
		count--;
		System.out.println(Thread.currentThread().getName() + " count: " + count);
	}

	/* (非 Javadoc) 
	* <p>Title: run</p> 
	* <p>Description: </p>  
	* @see java.lang.Runnable#run() 
	*/
	@Override
	public void run() {
		while(count > 0){
			dec();
		}
	}
	
}

二、若是每一个线程执行的代码不一样，这时候须要用不一样的Runnable对象，有以下两种方式来实现这些Runnable对象之间的数据共享：ide

① 将共享数据封装在另一个对象中，而后将这个对象逐一传递给各个Runnable对象。每一个线程对共享数据的操做方法也分配到那个对象身上去完成，这样容易实现针对该数据进行的各个操做的互斥和通讯。this

/** 
* @Title: MultiThreadShareData.java 
* @Package com.lh.threadtest.t7 
* @Description: TODO
* @author Liu 
* @date 2018年1月16日 下午9:45:37 
* @version V1.0 
*/
package com.lh.threadtest.t7;

/** 
* @ClassName: MultiThreadShareData 
* @Description: 多个线程之间共享数据的方式探讨
* 
* 题目：
* 	设计4个线程，其中两个线程每次对j增长1，另外两个线程对j每次都减小1，写出程序。
* 
* @author Liu
* @date 2018年1月16日 下午9:45:37 
*  
*/
public class MultiThreadShareData2 {
	
	/***
	* @Title: main 
	* @Description: TODO
	* @param @param args
	* @return void
	* @throws 
	*/
	public static void main(String[] args) {
		Business business = new Business();
		
		for(int i = 0; i< 2; i++){
			new Thread(new Inc(business)).start();
			new Thread(new Dec(business)).start();
		}
	}
}

class Inc implements Runnable{
	private Business business;

	public Inc(Business business){
		this.business = business;
	}

	/* (非 Javadoc) 
	* <p>Title: run</p> 
	* <p>Description: </p>  
	* @see java.lang.Runnable#run() 
	*/
	@Override
	public void run() {
		for(int i = 0; i< 5; i++){
			this.business.inc();
		}
	}
	
}

class Dec implements Runnable{
	private Business business;
	
	public Dec(Business business){
		this.business = business;
	}
	
	/* (非 Javadoc) 
	 * <p>Title: run</p> 
	 * <p>Description: </p>  
	 * @see java.lang.Runnable#run() 
	 */
	@Override
	public void run() {
		for(int i = 0; i< 5; i++){
			this.business.dec();
		}
	}
	
}

class Business{
	private int j = 0;
	
	public synchronized void inc(){
		j++;
		System.out.println(Thread.currentThread().getName() + "中 j = " + j);
	}
	
	public synchronized void dec(){
		j--;
		System.out.println(Thread.currentThread().getName() + "中 j = " + j);
	}
}

② 将这些Runnable对象做为某一个类中的内部类，共享数据做为这个外部类中的成员变量，每一个线程对共享数据的操做方法也分配给外部类，以便实现对共享数据进行的各个操做的互斥和通讯，做为内部类的各个Runnable对象调用外部类的这些方法。spa

/** 
* @Title: MultiThreadShareData.java 
* @Package com.lh.threadtest.t7 
* @Description: TODO
* @author Liu 
* @date 2018年1月16日 下午9:45:37 
* @version V1.0 
*/
package com.lh.threadtest.t7;

/** 
* @ClassName: MultiThreadShareData 
* @Description: 多个线程之间共享数据的方式探讨
* 
* 题目：
* 	设计4个线程，其中两个线程每次对j增长1，另外两个线程对j每次都减小1，写出程序。
* 
* @author Liu
* @date 2018年1月16日 下午9:45:37 
*  
*/
public class MultiThreadShareData {
	private int j = 0;
	
	public synchronized void inc(){
		j++;
		System.out.println(Thread.currentThread().getName() + "中 j = " + j);
	}
	
	public synchronized void dec(){
		j--;
		System.out.println(Thread.currentThread().getName() + "中 j = " + j);
	}
	
	/***
	* @Title: main 
	* @Description: TODO
	* @param @param args
	* @return void
	* @throws 
	*/
	public static void main(String[] args) {
		MultiThreadShareData multiThreadShareData = new MultiThreadShareData();
		for(int i = 0; i< 2; i++){
			new Thread(multiThreadShareData.new IncBusiness()).start();
			new Thread(multiThreadShareData.new DecBusiness()).start();
		}
	}
	
	class IncBusiness implements Runnable{

		/* (非 Javadoc) 
		* <p>Title: run</p> 
		* <p>Description: </p>  
		* @see java.lang.Runnable#run() 
		*/
		@Override
		public void run() {
			for(int i = 0; i< 5; i++){
				inc();
			}
		}
		
	}
	
	class DecBusiness implements Runnable{
		
		/* (非 Javadoc) 
		 * <p>Title: run</p> 
		 * <p>Description: </p>  
		 * @see java.lang.Runnable#run() 
		 */
		@Override
		public void run() {
			for(int i = 0; i< 5; i++){
				dec();
			}
		}
		
	}

}

③ 上面两种方式的组合：将共享数据封装在另一个对象中，每一个线程对共享数据的操做方法也分配到那个对象身上去完成，对象做为这个外部类中的成员变量或方法中的局部变量，每一个线程的Runnable对象做为外部类中的成员内部类或局部内部类。线程

④ 总之，要同步互斥的几段代码最好是分别放在几个独立的方法中，这些方法再放在同一个类中，这样比较容易实现它们之间的同步互斥和通讯。设计

/** 
* @Title: MultiThreadShareData.java 
* @Package com.lh.threadtest.t7 
* @Description: TODO
* @author Liu 
* @date 2018年1月16日 下午9:45:37 
* @version V1.0 
*/
package com.lh.threadtest.t7;

/** 
* @ClassName: MultiThreadShareData 
* @Description: 多个线程之间共享数据的方式探讨
* 
* 题目：
* 	设计4个线程，其中两个线程每次对j增长1，另外两个线程对j每次都减小1，写出程序。
* 
* @author Liu
* @date 2018年1月16日 下午9:45:37 
*  
*/
public class MultiThreadShareData3 {
	
	/***
	* @Title: main 
	* @Description: TODO
	* @param @param args
	* @return void
	* @throws 
	*/
	public static void main(String[] args) {
		BusinessHandler business = new BusinessHandler();
		
		for(int i = 0; i< 2; i++){
			new Thread(new Runnable() {
				
				@Override
				public void run() {
					business.inc();
				}
			}).start();
			new Thread(new Runnable() {
				
				@Override
				public void run() {
					business.dec();
				}
			}).start();
		}
	}
}

class BusinessHandler{
	private int j = 0;
	
	public synchronized void inc(){
		j++;
		System.out.println(Thread.currentThread().getName() + "中 j = " + j);
	}
	
	public synchronized void dec(){
		j--;
		System.out.println(Thread.currentThread().getName() + "中 j = " + j);
	}
}

三、极端且简单的方式，即在任意一个类中定义一个static的变量，这将被全部线程共享。code