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

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

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

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

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

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

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

l极端且简单的方式，即在任意一个类中定义一个static的变量，这将被所有线程共享。

示例1：模式售票，执行的代码相同，runnable对象一样

package cn.com.thread;

/**
 * Description: <类功能描述>. <br>
 * <p>
 * <使用说明>
 * </p>
 * Makedate:2014-4-12 下午7:48:11
 * 
 * @author gaowenming
 * @version V1.0
 */
public class ShareDataTest {

	/**
	 * 描述 : <描述函数实现的功能>. <br>
	 * <p>
	 * <使用方法说明>
	 * </p>
	 * 
	 * @param args
	 */

	// 定义全局变量
	private static int ticketCount = 100;

	public static void main(String[] args) {
		TicketSell ts = new TicketSell(ticketCount);
		// 开启4个线程开始售票
		new Thread(ts).start();
		new Thread(ts).start();
		new Thread(ts).start();
		new Thread(ts).start();

	}

}

class TicketSell implements Runnable {
	private int count;

	public TicketSell(int count) {
		this.count = count;
	}

	@Override
	public void run() {
		while (true) {
			synchronized (this) {// synchronized和if条件的位置要注意了，如果if条件在外层，那么可能会出现多个线程在请求最后一张票，然后出现负数的我情况
				if (count > 0) {
					count--;
					System.out.println(Thread.currentThread().getName() + "剩余票：" + count);
				}
			}

		}
	}

}

示例2：生产者和消费者模型

package cn.com.thread;

/**
 * Description: <类功能描述>. <br>
 * <p>
 * <使用说明>
 * </p>
 * Makedate:2014-4-12 下午7:48:11
 * 
 * @author gaowenming
 * @version V1.0
 */
public class ShareDataTest1 {

	/**
	 * 描述 : <描述函数实现的功能>. <br>
	 * <p>
	 * <使用方法说明>
	 * </p>
	 * 
	 * @param args
	 */

	public static void main(String[] args) {
		Factory f = new Factory();
		Producer p = new Producer(f);
		Consumer c = new Consumer(f);
		new Thread(p).start();
		new Thread(c).start();

	}

}

class Producer implements Runnable {

	private Factory f;

	public Producer(Factory f) {
		this.f = f;
	}

	@Override
	public void run() {
		f.produce();
	}

}

class Consumer implements Runnable {
	private Factory f;

	public Consumer(Factory f) {
		this.f = f;
	}

	@Override
	public void run() {
		f.consume();
	}
}

// 提供一个工厂，把生产和消费的方法、剩余数量放在里面，达到数据的共享和方法的互斥
class Factory {

	private int count = 0;

	public synchronized void consume() {
		while (true) {
			if (count == 0) {
				try {
					System.out.println("消费完了，需要生产者生产。。。。。。。。。。。。。。。。。。");
					this.wait();
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			} else {
				count--;
				System.out.println("正在消费，还剩下 " + count);
				notifyAll();
			}
		}
	}

	public synchronized void produce() {
		while (true) {
			if (count > 0) {
				try {
					this.wait();
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			} else {
				count += 10; // 每次生产10个
				System.out.println("生产者正在生产,总共生产了  " + count);
				notifyAll();
			}

		}

	}

}