多线程学习（四）-线程范围内共享数据

一：线程范围内共享数据：

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

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

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

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

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

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

下面看着四种方式的实现：

1.如果线程执行的代码相同，多个线程共享同一个runnable对象时，将共享数据放在runnable对象

public class MultiThreadShare {

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

}

class ShareData implements Runnable {
    private int i = 100;

    @Override
    public void run() {

        dec();
    }

    public synchronized  void dec() {
        while (i > 0) {
            i--;
            System.out.println(i);
        }
    }

}

2.如果多个线程执行的代码不同，将共享数据作为外部类的final成员变量，将不同的runnable对象作为内部类主动取数据

public class MultiThreadShare {

    public static void main(String[] args) {

        final ShareData shareData = new ShareData();
        new Thread(new Runnable() {

            @Override
            public void run() {
                for (int i = 0; i < 100; i++) {
                    shareData.dec();
                }

            }
        }).start();
        new Thread(new Runnable() {

            @Override
            public void run() {
                for (int i = 0; i < 100; i++) {
                    shareData.inc();
                }

            }
        }).start();
    }

}

class ShareData {
    private int j = 100;

    public synchronized void dec() {

        j--;
        System.out.println("--" + j);

    }

    public synchronized void inc() {

        j++;
        System.out.println("++" + j);

    }

}

3.如果多个线程执行的代码不同，将共享数据封装到一个对象中，将这个对象逐一传递给各个runnable对象

public class MultiThreadShare {

    public static void main(String[] args) {
        ShareData data = new ShareData();
        new Thread(new MyRunable1(data)).start();
        new Thread(new MyRunable2(data)).start();
    }
}

class MyRunable1 implements Runnable {
    private ShareData data;

    public MyRunable1(ShareData data) {
        this.data = data;
    }

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            data.dec();
        }

    }

}

class MyRunable2 implements Runnable {
    private ShareData data;

    public MyRunable2(ShareData data) {
        this.data = data;
    }

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            data.inc();
        }

    }

}

class ShareData {
    private int j = 100;

    public synchronized void dec() {

        j--;
        System.out.println("dec.." + j);

    }

    public synchronized void inc() {

        j++;
        System.out.println("inc.." + j);

    }

}

4.将数据声明为static的方式

public class MultiThreadShare {
    private static ShareData data = new ShareData();

    public static void main(String[] args) {
        new Thread(new Runnable() {

            @Override
            public void run() {
                for (int i = 0; i < 100; i++) {
                    data.inc();
                }

            }
        }).start();
        new Thread(new Runnable() {

            @Override
            public void run() {
                for (int i = 0; i < 100; i++) {
                    data.dec();
                }

            }
        }).start();
    }
}

class ShareData {
    private int j = 100;

    public synchronized void dec() {

        j--;
        System.out.println("--" + j);

    }

    public synchronized void inc() {

        j++;
        System.out.println("++" + j);

    }

}

参考http://www.cnblogs.com/zhangshiwen/p/5042331.html