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

在多线程访问共享对象和数据时候大致可以分为两大类。

1：如果每个线程执行的代码相同，可以使用同一个runnable对象，这个runnable对象中有那个共享对象。如：买票系统。

public class MulteThreadlShareData {
    public static void main(String[] args) {
        ShareData shareData = new ShareData();
        new Thread(shareData).start();
        new Thread(shareData).start();
    }
    
    static class ShareData implements Runnable{
        int count = 100;
        @Override
        public void run() {
            while(count>0){
                decrease();
            }
        }
        public synchronized void decrease(){
            count--;
            System.out.println(Thread.currentThread().getName()+"this count: "+count);
        }
        
    }
}

2：如果每个线程执行的代码不相同，就要用不同的runnable对象了。这种方式又有两种来实现这些runnable对象之间的数据共享。

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

  public class MulteThreadlShareData2 {
      public static void main(String[] args) {
          final ShareData shareData = new ShareData();
          new Thread(new Decrease(shareData)).start();
          new Thread(new Increment(shareData)).start();
      }
      
      static class Decrease implements Runnable{
          private ShareData shareData;
          public Decrease(ShareData shareData){
              this.shareData=shareData;
          }
          @Override
          public void run() {
              shareData.decrease();
          }
          
      }
      static class Increment implements Runnable{
          private ShareData shareData;
          public Increment(ShareData shareData){
              this.shareData=shareData;
          }
          @Override
          public void run() {
              shareData.increment();
          }
          
      }
      
      static class ShareData{
          int count = 100;
          public synchronized void decrease(){
              count--;
              System.out.println(Thread.currentThread().getName()+"decrease this count: "+count);
          }
          public synchronized void increment(){
              count++;
              System.out.println(Thread.currentThread().getName()+"increment this count: "+count);
          }
      }
  }

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

  public class MulteThreadlShareData3 {
      static int count = 100;
      public static void main(String[] args) {
          new Thread(new Decrease()).start();
          new Thread(new Increment()).start();
          
      }
      public synchronized static void decrease(){
          count--;
          System.out.println(Thread.currentThread().getName()+"decrease this count: "+count);
      }
      public synchronized static void increment(){
          count++;
          System.out.println(Thread.currentThread().getName()+"increment this count: "+count);
      }
      static class Decrease implements Runnable{
          @Override
          public void run() {
              decrease();
          }
          
      }
      static class Increment implements Runnable{
          @Override
          public void run() {
              increment();
          }
          
      }
  }

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

  public class MulteThreadlShareData1 {
      public static void main(String[] args) {
          final ShareData shareData = new ShareData();
          new Thread(new Runnable() {
              @Override
              public void run() {
                  while(true){
                      shareData.decrease();
                  }    
              }
          }).start();
          new Thread(new Runnable() {
              @Override
              public void run() {
                  while(true){
                      shareData.increment();
                  }
                  
              }
          }).start();
      }
      
      static class ShareData{
          int count = 100;
          public synchronized void decrease(){
              count--;
              System.out.println(Thread.currentThread().getName()+"this count: "+count);
          }
          public synchronized void increment(){
              count++;
              System.out.println(Thread.currentThread().getName()+"this count: "+count);
          }
      }
  }

总之：要同步和互斥的几段代码最好放在几个独立的方法中，这些方法在放在同一个类中，这样容易实现他们之间的同步互斥和通信。