多个线程间共享数据的几种方式

男娘i 2022-06-04 09:57 267阅读 0赞

**第一种情况**

> 如果每个线程执行的代码相同,可以使用同一个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变量,这将被所有线程共享

[转载地址][Link 1]

[Link 1]: http://blog.csdn.net/qq_33248299/article/details/78715540