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

1.如果每个线程执行的代码相同，可以使用同一个Runable对象，这个Runable对象中有那个共享数据，例如卖票系统就可以这样做。

 

package javaplay.test;

public class MulteThreadShareData {
	public static void main(String[] args) {
		ShareData shareData = new ShareData();
		new Thread(shareData).start();
		new Thread(shareData).start();
	}

	static class ShareData implements Runnable {
		int count = 100;

		@Override
		public void run() {
			while (count > 0) {
				decrease();
			}
		}

		public synchronized void decrease() {
			count--;
			System.out.println(Thread.currentThread().getName() + "this count: " + count);
		}

	}
}

这个示例是错误的，对共享变量的访问必须必须加锁！volatile只能保证可见性，不能保证原子性！
2.如果每个线程执行的代码不相同，这个时候需要用到不同的Runable对象，有如下两种方式实现多个Runable对象中的数据共享。

 

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

package javaplay.test;

public class MulteThreadShareData {
	public static void main(String[] args) {
		final ShareData shareData = new ShareData();
		new Thread(new Decrease(shareData)).start();
		new Thread(new Increment(shareData)).start();
	}

	static class Decrease implements Runnable {
		private ShareData shareData;

		public Decrease(ShareData shareData) {
			this.shareData = shareData;
		}

		@Override
		public void run() {
			shareData.decrease();
		}

	}

	static class Increment implements Runnable {
		private ShareData shareData;

		public Increment(ShareData shareData) {
			this.shareData = shareData;
		}

		@Override
		public void run() {
			shareData.increment();
		}

	}

	static class ShareData {
		int count = 100;

		public synchronized void decrease() {
			count--;
			System.out.println(Thread.currentThread().getName() + "decrease this count: " + count);
		}

		public synchronized void increment() {
			count++;
			System.out.println(Thread.currentThread().getName() + "increment this count: " + count);
		}
	}
}

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

package javaplay.test;

public class MulteThreadShareData {
	static int count = 100;

	public static void main(String[] args) {
		new Thread(new Decrease()).start();
		new Thread(new Increment()).start();

	}

	public synchronized static void decrease() {
		count--;
		System.out.println(Thread.currentThread().getName() + "decrease this count: " + count);
	}

	public synchronized static void increment() {
		count++;
		System.out.println(Thread.currentThread().getName() + "increment this count: " + count);
	}

	static class Decrease implements Runnable {
		@Override
		public void run() {
			decrease();
		}

	}

	static class Increment implements Runnable {
		@Override
		public void run() {
			increment();
		}

	}
}

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

package javaplay.test;

public class MulteThreadShareData {
	public static void main(String[] args) {
		final ShareData shareData = new ShareData();
		new Thread(new Runnable() {
			@Override
			public void run() {
				while (true) {
					shareData.decrease();
				}
			}
		}).start();
		new Thread(new Runnable() {
			@Override
			public void run() {
				while (true) {
					shareData.increment();
				}

			}
		}).start();
	}

	static class ShareData {
		int count = 100;

		public synchronized void decrease() {
			count--;
			System.out.println(Thread.currentThread().getName() + "this count: " + count);
		}

		public synchronized void increment() {
			count++;
			System.out.println(Thread.currentThread().getName() + "this count: " + count);
		}
	}
}

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