Thread的第五天学习

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

package com.thread.demo;

public class SellTicktThreadShareData {
    
    public static void main(String[] args) {
        Ticket ticket = new Ticket();
        new Thread(ticket).start();
        new Thread(ticket).start();
    }
}

class Ticket implements Runnable{
    private int count = 1000;
    
    public void run()
    {
        while(true)
        {
            if(count <= 0)
            {
                break;
            }
            else
            {
                count--;
                System.out.println(Thread.currentThread().getName()+"卖的票还剩："+count);
            }
        }
    }
}

2、如果每个线程执行的代码不同，这时候需要用不同的Runnable对象，下面2种方式实现Runnable对象间的数据共享：
1）将共享数据封装在另外一个对象中，然后将这个对象逐一传递给各个Runnable对象。每个线程对共享数据的操作方法也分配到那个对象身上去完成，这样容易实现针对该数据进行各个操作的互斥和通信。

package com.thread.demo;

public class MutiThreadShareData {
    
    public static void main(String[] args) {
        ShareData data = new ShareData();
        new Thread(new ShareThreadOne(data)).start();
        new Thread(new ShareThreadTwo(data)).start();
    }

}

class ShareThreadOne implements Runnable{
    private ShareData data ;
    
    public ShareThreadOne(ShareData data){
        this.data = data;
    }
    
    public void run()
    {
        data.decement();
    }
}

class ShareThreadTwo implements Runnable{
    private ShareData data ;
    public ShareThreadTwo(ShareData data){
        this.data = data;
    }
    
    public void run()
    {
        data.incement();
    }
}


class ShareData {
    int j = 0;
    
    public synchronized void incement()
    {
        j++;
        System.out.println(j);
        
    }
    
    public synchronized void decement()
    {
        j--;
        System.out.println(j);
        
    }

}

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

package com.thread.demo;

public class MutiThreadShareData2 {
    
    private static ShareData2 data = new ShareData2();
    
    public static void main(String[] args) {
        
        new Thread(new Runnable(){
            
            public void run()
            {
                data.decement();
            }
            
        }).start();
        new Thread(new Runnable(){
            
            public void run()
            {
                data.incement();
            }
            
        }).start();
    }

}

class ShareData2 {
    int j = 0;
    
    public synchronized void incement()
    {
        j++;
        System.out.println(j);
        
    }
    
    public synchronized void decement()
    {
        j--;
        System.out.println(j);
        
    }

}

另一中共享数据模式：
　　将共享数据封装在另外一个对象中，每个线程对共享数据的操作方法也分配到那个对象身上去完成，对象作为这个外部类中的成员变量或方法中的局部变量，每个线程的Runnable对象作为外部类中的成员内部类或局部内部类。

package com.thread.demo;

public class ShareDataObject {
    private static int i = 0;
    
    public static void main(String[] args) {
        ShareDataObject shareData = new ShareDataObject();
        for(int i= 0;i<10;i++)
        {
            new Thread(shareData.new ShareDataThread1(),i+"  1 ").start();
            new Thread(shareData.new ShareDataThread2(),i+"  2 ").start();
        }
        
    }
    
    class ShareDataThread1 implements Runnable{

        @Override
        public synchronized void run() {
            
            i++;
            System.out.println(Thread.currentThread().getName()+"--"+i);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            
        }
        
    }
    
    class ShareDataThread2 implements Runnable{

        @Override
        public synchronized void run() {
            i--;
            System.out.println(Thread.currentThread().getName()+"--"+i);
        }
        
    }

}