Java基础知识强化102：线程间共享数据

一、每个线程执行的代码相同：

若每个线程执行的代码相同，共享数据就比较方便。可以使用同一个Runnable对象，这个Runnable对象中就有那个共享数据。

 public class MultiThreadShareData
   {
          public static void main(String[] args)
          {
                 SaleTickets sale = new SaleTickets();
                 new Thread(sale).start();
                 new Thread(sale).start();
            }
   }
  class SaleTickets implements Runnable
  {
          public int allTicketCount = 20;
          public void run()
          {
               while (allTicketCount > 0)
               {
                      sale();
                }
           }
          public synchronized void sale()
          {
             System.out.println("剩下" + allTicketCount);
             allTicketCount--;
          }
  }        

 SaleTickets这个对象中就有需要共享的数据allTicketCount，两个线程使用同一个SaleTickets，就可以共享allTicketCount了。

二、每个线程执行的代码不相同：

方法：将需要共享的数据封装成一个对象，将该对象传给执行不同代码的Runnable对象。
方法：将这些执行不同代码的Runnable对象作为内部类。

看例子：有4个线程，其中有2个线程对每次对j +1，有2个线程对每次对j -1。加减操作无顺序。

（1）方法1：

 public class MultiThreadShareData3
 {
     public static void main(String[] args)
     {
         int j = 10;
         NumberInfo nInfo = new NumberInfo(j);
         for (int i = 0; i < 2; i++)
        {
            new Thread(new NumberInfoAdd("增线程", nInfo)).start();
            new Thread(new NumberInfoMinus("减线程", nInfo)).start();
          }
      }
 }

 class NumberInfo
 {
       private int number;
       public NumberInfo(int number)
      {
           this.number = number;
       }
       public int getNumber()
      {
           return number;
       }
       public void setNumber(int number)
      {
           this.number = number;
       }
       public void add()
      {
           System.out.println("数值：" + (++number));
       }
       public void minus()
      {
           System.out.println("数值：" + (--number));
       }
 }

 // 增操作
 class NumberInfoAdd implements Runnable
 {
       private String name;
       private NumberInfo nInfo;
       public NumberInfoAdd(String name, NumberInfo nInfo)
      {
           this.name = name;
           this.nInfo = nInfo;
       }
       public void run()
      {
           add();
       }
       public void add()
      {
           synchronized (nInfo)
           {
                System.out.print(name + "--");
                nInfo.add();
            }
        }
 }

 // 减操作
 class NumberInfoMinus implements Runnable
 {
        private String name;
        private NumberInfo nInfo;
        public NumberInfoMinus(String name, NumberInfo nInfo)
       {
            this.name = name;
            this.nInfo = nInfo;
        }
        public void run()
       {
            minus();
        }
        public void minus()
       {
            synchronized (nInfo)
           {
        　　   System.out.print(name + "--");
        　　   nInfo.minus();
     　　   }
        }
 }

（2）方法2：

 public class MultiThreadShareData4
 {
      int j = 10;
      public static void main(String[] args)
      {
           MultiThreadShareData4 m = new MultiThreadShareData4();
           for (int i = 0; i < 2; i++)
           {
                new Thread(m.new NumberInfoAdd()).start();
                new Thread(m.new NumberInfoMinus()).start();
            }
       }
      public synchronized void add()
      {
           System.out.println("增加后数值：" + (++j));
       }
      public synchronized void minus()
      {
           System.out.println("減少后数值：" + (--j));
       }

      // 增
     class NumberInfoAdd implements Runnable
     {
          public void run()
         {
             add();
         }
      }

      // 减
     class NumberInfoMinus implements Runnable
     {
          public void run()
         {
             minus();
         }
     }
 }    

执行结果可能是：

增线程--数值：11
增线程--数值：12
减线程--数值：11
减线程--数值：10

执行结果也可能是：
增线程--数值：11
减线程--数值：10
减线程--数值：9
增线程--数值：10

三、其实线程执行相同代码也可以按照这些方法来做，看一个方法1：

 public class MultiThreadShareData2
 {
      public static void main(String[] args)
      {
           TicketInfo tInfo = new TicketInfo(20);
           new Thread(new SaleTickets2("线程1", tInfo)).start();
           new Thread(new SaleTickets2("线程2", tInfo)).start();
       }
 }
 class TicketInfo
 {
      private int allTicketCount;
      public TicketInfo(int allTicketCount)
     {
           this.allTicketCount = allTicketCount;
      }
      public int getAllTicketCount()
     {
          return allTicketCount;
      }
      public void setAllTicketCount(int allTicketCount)
      {
          this.allTicketCount = allTicketCount;
       }
      public void sale()
      {
          System.out.println("剩余：" + allTicketCount--);
       }
 }
 class SaleTickets2 implements Runnable
 {
      private String name;
      private TicketInfo tInfo;
      public SaleTickets2(String name, TicketInfo tInfo)
      {
           this.name = name;
           this.tInfo = tInfo;
       }
      public void run()
      {
           while (tInfo.getAllTicketCount() > 0)
           {
                sale();
            }
      }
      public void sale()
      {
            synchronized (tInfo)
           {
                 System.out.print(name + "--");
                 tInfo.sale();
           }
      }
 }