java多个线程访问共享对象和数据的方式

一、如果每个线程执行的代码相同，可以使用同一个Runnable对象，这个Runnable对象中有那个共享数据，例如，买票系统就可以这么做：

import java.time.Year;
import java.util.concurrent.SynchronousQueue;

import org.omg.CORBA.PRIVATE_MEMBER;

public class ThreadDemo2 {
	 
	public static void main(String[] args) {
		ShareData data1 = new ShareData();
		new Thread(data1).start();
		new Thread(data1).start();
	}
}
 
//定义共享数据类，谁拥有数据，就提供操作该数据的方法
class ShareData implements Runnable{
    //总票数
	private  int count=100;
	public void run() {
		while (true) {
			count--;	
		} 
	}
	

}

 二、如果每个线程执行的代码不同，这时候需要用不同的Runnable对象，有如下两种方式来实现这些Runnable对象之间的数据共享： 

1.将共享数据传递给Runnable实现类：将共享数据封装在另外一个对象中，然后将这个对象通过Runnable接口实现类的构造方法逐一传递给各个Runnable对象。每个线程对共享数据的操作方法也分配到那个对象身上去完成，这样容易实现针对该数据进行的各个操作的互斥和通信。

import java.time.Year;
import java.util.concurrent.SynchronousQueue;

import org.omg.CORBA.PRIVATE_MEMBER;

public class ThreadDemo2 {
	 
	public static void main(String[] args) {
		ShareData data1 = new ShareData();
	     new Thread(new MyRunnable(data1)).start();
	     new Thread(new MyRunnable(data1)).start();	
	}
}
 
class MyRunnable implements Runnable{

	private ShareData Data;
	
	public  MyRunnable(ShareData Data) {
		this.Data=Data;
	}
	@Override
	public void run() {
		Data.decrement();
	}
		
}

class MyRunnable2 implements Runnable{
	private ShareData Data;	
	public  MyRunnable2(ShareData Data) {
		this.Data=Data;
	}
	@Override
	public void run() {
		Data.increment();
	}	
}
//定义共享数据类，谁拥有数据，就提供操作该数据的方法
class ShareData {	
	private int j=0;
	public synchronized void increment(){
		j++;		
	}
	public synchronized void decrement(){
		j--;		
	}
}

2.让Runnable实现类去访问共享数据：将这些Runnable对象作为某一个类中的内部类，共享数据作为这个外部类中的成员变量，每个线程对共享数据的操作方法也分配给外部类，以便实现对共享数据进行的各个操作的互斥和通信，作为内部类的各个Runnable对象调用外部类的这些方法。也可以将成员变量作为局部变量加上final。

import java.time.Year;
import java.util.concurrent.SynchronousQueue;

import org.omg.CORBA.PRIVATE_MEMBER;

public class ThreadDemo2 {
	private static ShareData shareData = new ShareData();
	public static void main(String[] args) {
		// final ShareData shareData = new ShareData();
		new Thread(new Runnable() {
			@Override
			public void run() {
				shareData.decrement();
			}
		}).start();
		new Thread(new Runnable() {
			@Override
			public void run() {
				shareData.increment();
			}
		}).start();
	}
}
// 定义共享数据类，谁拥有数据，就提供操作该数据的方法
class ShareData {
	private int j = 0;
	public synchronized void increment() {
		j++;
	}
	public synchronized void decrement() {
		j--;
	}
}

3.上面两种方式的组合：将共享数据封装在另外一个对象中，每个线程对共享数据的操作方法也分配到那个对象身上去完成，对象作为这个外部类中的成员变量或方法中的局部变量，每个线程的Runnable对象作为外部类中的成员内部类或局部内部类。
           总之，要同步互斥的几段代码最好是分别放在几个独立的方法中，这些方法再放在同一个类中，这样比较容易实现它们之间的同步互斥和通信
           示例：

设计4个线程，其中两个线程每次对j增加1，另外两个线程对j每次减少1。写出程序。

 

public class ThreadTest1 
{ 
	private int j; 
	public static void main(String args[]){ 
		ThreadTest1 tt=new ThreadTest1(); 
		Inc inc=tt.new Inc(); 
		Dec dec=tt.new Dec(); 
		for(int i=0;i<2;i++){ 
			Thread t=new Thread(inc); 
			t.start(); 
			t=new Thread(dec); 
			t.start(); 
		} 
	} 
	
	private synchronized void inc(){ 
		j++; 
		System.out.println(Thread.currentThread().getName()+"-inc:"+j); 
	} 
	private synchronized void dec(){ 
		j--; 
		System.out.println(Thread.currentThread().getName()+"-dec:"+j); 
	} 
 
	class Inc implements Runnable{ 
		public void run(){ 
			for(int i=0;i<100;i++){ 
				inc(); 
			} 
		} 
	} 
	class Dec implements Runnable{ 
		public void run(){ 
			for(int i=0;i<100;i++){ 
				dec(); 
			} 
		} 
	} 
} 

总结：

    其实多线程间的共享数据最主要的还是互斥，多个线程共享一个变量，针对变量的操作实现原子性即可。

    要同步和互斥的几段代码最好放在几个独立的方法中，这些方法在放在同一个类中，这样容易实现他们之间的同步互斥和通信