1、如果每个线程执行的代码相同，可以使用同一个Runnable对象，这个Runnable对象中有那个
共享数据，例如：卖票系统就可以这么做！
package com.thread.demo;
public class SellTicktThreadShareData {
public static void main(String[] args) {
Ticket ticket = new Ticket();
new Thread(ticket).start();
new Thread(ticket).start();
}
}
class Ticket implements Runnable{
private int count = 1000;
public void run()
{
while(true)
{
if(count <= 0)
{
break;
}
else
{
count--;
System.out.println(Thread.currentThread().getName()+"卖的票还剩："+count);
}
}
}
}
2、如果每个线程执行的代码不同，这时候需要用不同的Runnable对象，下面2种方式实现Runnable对象间的数据共享：
1）将共享数据封装在另外一个对象中，然后将这个对象逐一传递给各个Runnable对象。每个线程对共享数据的操作方法也分配到那个对象身上去完成，这样容易实现针对该数据进行各个操作的互斥和通信。
package com.thread.demo;
public class MutiThreadShareData {
public static void main(String[] args) {
ShareData data = new ShareData();
new Thread(new ShareThreadOne(data)).start();
new Thread(new ShareThreadTwo(data)).start();
}
}
class ShareThreadOne implements Runnable{
private ShareData data ;
public ShareThreadOne(ShareData data){
this.data = data;
}
public void run()
{
data.decement();
}
}
class ShareThreadTwo implements Runnable{
private ShareData data ;
public ShareThreadTwo(ShareData data){
this.data = data;
}
public void run()
{
data.incement();
}
}
class ShareData {
int j = 0;
public synchronized void incement()
{
j++;
System.out.println(j);
}
public synchronized void decement()
{
j--;
System.out.println(j);
}
}
2）将这些Runnable对象作为某一个类中的内部类，共享数据作为这个外部类中的成员变量，每个线程对共享数据的操作方法也分配给外部类，以便实现对共享数据进行的各个操作的互斥和通信，作为内部类的各个Runnable对象调用外部类的这些方法。
package com.thread.demo;
public class MutiThreadShareData2 {
private static ShareData2 data = new ShareData2();
public static void main(String[] args) {
new Thread(new Runnable(){
public void run()
{
data.decement();
}
}).start();
new Thread(new Runnable(){
public void run()
{
data.incement();
}
}).start();
}
}
class ShareData2 {
int j = 0;
public synchronized void incement()
{
j++;
System.out.println(j);
}
public synchronized void decement()
{
j--;
System.out.println(j);
}
}
另一*享数据模式：
将共享数据封装在另外一个对象中，每个线程对共享数据的操作方法也分配到那个对象身上去完成，对象作为这个外部类中的成员变量或方法中的局部变量，每个线程的Runnable对象作为外部类中的成员内部类或局部内部类。
package com.thread.demo;
public class ShareDataObject {
private static int i = 0;
public static void main(String[] args) {
ShareDataObject shareData = new ShareDataObject();
for(int i= 0;i<10;i++)
{
new Thread(shareData.new ShareDataThread1(),i+" 1 ").start();
new Thread(shareData.new ShareDataThread2(),i+" 2 ").start();
}
}
class ShareDataThread1 implements Runnable{
@Override
public synchronized void run() {
i++;
System.out.println(Thread.currentThread().getName()+"--"+i);
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
class ShareDataThread2 implements Runnable{
@Override
public synchronized void run() {
i--;
System.out.println(Thread.currentThread().getName()+"--"+i);
}
}
}