多线程06-多线程共享数据的方式(经验小结)

     1.案例分析-01

      通过代码实现火车票出售的例子

      在实现代码之前先对问题进行分析：火车票出售应该是在多个窗口进行的（即多个线程），以一个车的班次来说，该班次的火车票张数即为多个窗口共享的数据

即这份共享数据为出售特定班次的火车票，这个动作在多个窗口都是不变的，变更的只有火车票的剩余张数.代码实现如下：

package org.lkl.thead;

/**
 * 
 * Function : 多线程共享数据
 * 
 * @author : Liaokailin CreateDate : 2014-6-13 version : 1.0
 */
public class MultiThreadShareData {
    public static void main(String[] args) {
        SellTicket s = new SellTicket(); // 共享对象
        new Thread(s, "1").start();
        new Thread(s, "2").start();
        new Thread(s, "3").start();
        new Thread(s, "4").start();
        new Thread(s, "5").start();
    }

}

/**
 * 出售火车票  
 */
class SellTicket implements Runnable {
    private int ticket = 100;

    @Override
    public void run() {

        while (true) {
            synchronized (SellTicket.class) {
            if (ticket > 0) {
            
                    try {
                        Thread.sleep(30);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                    ticket-- ;
                    System.out.println("窗口" + Thread.currentThread().getName()
                            + "出售合肥到北京火车票剩余车票" + ticket);
                }else{
                    break ;
                }
            }
        }

    }
}

　　　通过上面的代码可以发现，多线程共享的数据是卖火车票，而这个动作在各个线程中都是不变的，因此可以做如下的小结：

   多线程中各个线程执行的代码相同，那么可以使用同一个Runnable对象来实现共享数据。

      2. 案例分析-02

         和上面问题乡对应的是 如果多个线程中执行的代码不同呢？ 该如何去处理数据之间的共享？

         例如： 

               设计4个线程，其中两个线程每次对j增加1，另外两个线程对j每次减少1 。

          通过问题可以发现，线程中执行的代码显示是不同的，一个是j++ 一个是j--，在前面我们说过 要同步互斥的代码或者算法应该分别放在独立的方法中，并且这些方法都放在同一个类中，这样子

比较容易实现他们之间的同步互斥和通信

          那么可以设计如下的业务类: 

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

     要实现多个线程的不同操作，可以将不同的操作防止在不同的Runnable中 然后将不同的Runnable对象传递给不同的线程

        

package org.lkl.thead;


/**
 *   设计4个线程，其中两个线程每次对j增加1，另外两个线程对j每次减少1 
 */
public class ShareDataFoo {
    public static void main(String[] args) {
        Business b = new Business() ;
        for(int i= 0 ;i<2;i++){
            new Thread(new OperatorFoo01(b)).start();
            new Thread(new OperatorFoo02(b)).start();
            
        }
        
    }

    
}
class OperatorFoo01 implements Runnable{
    private Business business;
    public OperatorFoo01(Business business){
        this.business = business ;
    }
    @Override
    public void run() {
        business.increment() ;
    }
}

class OperatorFoo02 implements Runnable{
    private Business business;
    public OperatorFoo02(Business business){
        this.business = business ;
    }
    @Override
    public void run() {
        business.decrement() ;
    }
}

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

       运行代码得到的结果： 

Thread-0,j=1
Thread-1,j=0
Thread-2,j=1
Thread-3,j=0

我们可以做个小结：

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

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

和通行 （上面我们的例子就是采用这样的方式）

      2.将这些Runnable对象作为某个类的内部类，共享数据作为这个外部类中的成员变量，每个线程对共享数据的操作也分配给外部类，以便对共享数据进行的各个操作的互斥和通信，作为内部类的各个

Runnable对象调用外部类的这些方法

      对于第二点同样以上面的例子得到如下代码：

package org.lkl.thead;


/**
 *   设计4个线程，其中两个线程每次对j增加1，另外两个线程对j每次减少1 
 */
public class ShareDataFoo2 {
    public static void main(String[] args) {
        ShareDataFoo2 foo = new ShareDataFoo2() ;
        
        for(int i= 0 ;i<2;i++){
            new Thread(foo.new OperAdd()).start();
            new Thread(foo.new OperSub()).start();
            
        }
        
    }
    
    private int j = 0 ;
    
    public synchronized  void increment(){
        j++ ;
        System.out.println(Thread.currentThread().getName()+",j="+j);
    }
    
    public synchronized void decrement(){
        j-- ;
        System.out.println(Thread.currentThread().getName()+",j="+j);
    }

     class OperAdd implements Runnable{
        @Override
        public void run() {
            increment() ;
        }
    }
    
     class OperSub implements Runnable{
        @Override
        public void run() {
            decrement() ;
        }
    }
    
    
}

      也可以对上面的两种方法进行组合：

　　　　　将共享数据封装到另外一个对象中，每个线程对共享数据的操作方法也分配到那个对象本身上来完成，该对象作为这个外部类中的成员变量或者方法中的局部变量，每个线程的Runnable对象

作为外部类中的成员内部类或局部内部类，如下面代码：

　　

package org.lkl.thead;


/**
 *   设计4个线程，其中两个线程每次对j增加1，另外两个线程对j每次减少1 
 */
public class ShareDataFoo3 {
    public static void main(String[] args) {
        ShareDataFoo3 foo = new ShareDataFoo3() ;
        for(int i= 0 ;i<2;i++){
            new Thread(foo.new OperatorFoo01()).start();
            new Thread(foo.new OperatorFoo02()).start();
            
        }
        
    }

    private Business2 business = new Business2() ;
    class OperatorFoo01 implements Runnable{
     
        @Override
        public void run() {
            business.increment() ;
        }
    }

    class OperatorFoo02 implements Runnable{
        @Override
        public void run() {
            business.decrement() ;
        }
    }
    
    
}


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