多个线程之间共享数据

第一种情况

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

public class MultipThreadShareData {
    public static void main(String[] args) {//买票系统
          ShareData1 data1 = new ShareData1();
          new Thread(data1).start();
          new Thread(data1).start();
    }


}

class ShareData1 implements Runnable{
    private int count = 100;
    @Override
    public void run() {
        while(true){
            if(count>=0) {
                System.out.println("订票线程:" + Thread.currentThread().getName() + "正在卖:" + (count--) + "张票");
            }
        }
    }
}

第二种情况

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

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

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

public class MultipThreadShareData {
    public static void main(String[] args) {
         ShareData1 data2 = new ShareData1();
         for(int i=0;i<2;i++) {
             new Thread(new MyRunnable1(data2)).start();
             new Thread(new MyRunnable2(data2)).start();
         }

    }


}

     class MyRunnable1 implements  Runnable{
           private ShareData1 data1;
          public MyRunnable1(ShareData1 data1){
                 this.data1=data1;
         }
         @Override
         public void run() {
             while(true) {
                 data1.decrement();
             }
         }
     }


        class MyRunnable2 implements  Runnable{
            private ShareData1 data1;
            public MyRunnable2(ShareData1 data1){
             this.data1=data1;
                 }
                @Override
                public void run() {
                    while(true) {
                        data1.increment();
                    }
              }
}
class ShareData1 {

    private int j =0;
    public synchronized void increment(){
        j++;
        System.out.println(Thread.currentThread().getName()+" increment:"+j);
    }

    public synchronized void decrement(){
        j--;
        System.out.println(Thread.currentThread().getName()+" decrement:"+j);
    }
}

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

public class MultipThreadShareData {

    public static void main(String[] args) {//买票系统
        final ShareData1 data1 = new ShareData1();
        new Thread(new Runnable() {
            @Override
            public void run() {
                while(true) {
                    data1.decrement();
                }
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                while(true) {
                    data1.increment();
                }
            }
        }).start();
    }


}
}

class ShareData1 {
    private int j = 0;
    public synchronized void increment(){
        j++;
        System.out.println(Thread.currentThread().getName()+" increment:"+j);
    }

    public synchronized void decrement(){
        j--;
        System.out.println(Thread.currentThread().getName()+" decrement:"+j);
    }
}

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

• 下面是上面例子参考答案上得代码,与第二种方法的第一种方式如出一辙;思路没有上面的清晰,有点乱

public class ThreadData {

     private int j=100;
    public static void main(String[] args) {

          ThreadData threadData=new ThreadData();
          inc data1 = threadData.new inc();
          dec data2 = threadData.new dec();

          for(int i=0;i<2;i++){
              Thread t1 = new Thread(data1);
              t1.start();
              Thread t2 = new Thread(data2);
              t2.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{
        @Override
        public void run() {
             for(int i=0;i<100;i++){
                         inc();
             }
        }
    }

    class dec implements  Runnable{
        @Override
        public void run() {
            for(int i=0;i<100;i++){
                   dec();
            }
        }
    }
}

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

• 一个外部类有两个内部类,这两个内部类如何共享数据

  • 都操作外部类的同一个成员
  • 内部类A可以访问外部类成员
  • 内部类B也可以访问外部类成员

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