多線程的安全問題

1、多線程安全問題分析

　　多線程安全問題原因是在cpu執行多線程時，在執行的過程中可能隨時切換到其他的線程上執行。

　　

　　在以上紅色選中的三個部分，線程都有可能進行切換。只要cpu在這個三個地中的任何地方切換了，都可能導致錯誤數據出現，線程的不安全因素就有了。

 

　　造成錯誤數據的原因是多個線程可能出現同時訪問num的情況。而任何一個線程在訪問num的過程中都可以切換到其他的線程上。而其他線程一旦把num的數據改變了，再切換回來時，錯誤數據就有了。

2、多線程安全問題解決

　　要解決上述的線程安全問題，錯誤數據問題。在一個線程進入到if中之后，當cpu切換到其他線程上時，不讓其他的線程進入if語句，那么就算線程繼續執行當前其他的線程，也無法進入到if中，這樣就不會造成錯誤數據的出現。

 

　　Java中給我們提供是同步代碼塊技術來解決這個線程的安全問題：

　　格式：

synchronized(任意的對象（鎖） )
{
    寫要被同步的代碼
}

同步代碼塊就可以認為成衛生間的門和鎖。

　　多線程安全問題，是由於多個線程在訪問共享的數據（共享的資源），並且操作共享數據的語句不止一條。那么這樣在多條操作共享數據的之間線程就可能發生切換。只要切換就有安全問題，那么我們就可以把同步加在這些操作共享數據的代碼上。

　　

ThreadDemo.java源代碼

//書寫售票的示例
class Demo implements Runnable{
    //定義變量記錄剩余的票數
    int num = 100;
    
    //創建一個對象，用作同步中的鎖對象
    Object obj = new Object();

    //實現run方法
    public void run()    {    
        
        //實現售票的過程
        while( true )        {
            //   t1  t2  t3
            //判斷當前有沒有線程正在if中操作num，如果有當前線程就在這里臨時等待
            //這種思想稱為線程的同步
            //當票數小等於0的時候，就不再售票了
            //使用同步代碼塊把線程要執行的任務代碼可以同步起來
            synchronized( obj )  //t1   在進入同步之前線程要先獲取鎖
            /*
                當某個線程執行到synchronized關鍵字之后，這時JVM會判斷當前
                同步上的這個對象有沒有已經被其他線程獲取走了，如果這時沒有其他
                線程獲取這個對象，這時就會把當前同步上的這個對象交給當前正要進入
                同步的這個線程。
            */
            {
                if( num > 0 )
                {
                    //t0
                    try{Thread.sleep(2);}catch( InterruptedException e ){}
                    System.out.println(Thread.currentThread().getName()+"....."+num);
                    num--;
                }
            }//線程執行完同步之后，那么這時當前這個線程就會把鎖釋放掉
        }
    }
}
class ThreadDemo {
    public static void main(String[] args)     {
        //創建線程任務
        Demo d = new Demo();
        //創建線程對象
        Thread t = new Thread( d );
        Thread t2 = new Thread(d);
        Thread t3 = new Thread(d);
        Thread t4 = new Thread(d);
        //開啟線程
        t.start();
        t2.start();
        t3.start();
        t4.start();
    }
}

 

3、多線程安全問題細節

　3.1、同步的好處和弊端

　　好處：可以保證多線程操作共享數據時的安全問題

　　弊端：降低了程序的執行效率。

　3.2、同步的前提

　　要同步，必須有多個線程，多線程在操作共享的數據，同時操作共享數據的語句不止一條。

　3.3、加入了同步安全依然存在

　　首先查看同步代碼塊的位置是否加在了需要被同步的代碼上。如果同步代碼的位置沒有錯誤，這時就再看同步代碼塊上使用的鎖對象是否是同一個。多個線程是否在共享同一把鎖。

4、同步鎖的問題

　4.1、同步是否可以加在run方法上

　　方法上是可以加同步的，但是不建議把同步加在run方法，如果把同步加在了run方法上，導致任何一個線程在調用start方法開啟之后，JVM去調用run方法的時候，首先都要先獲取同步的鎖對象，只有獲取到了同步的鎖對象之后，才能去執行run方法。而我們在run中書寫的被多線程操作的代碼，永遠只會有一個線程在里面執行。只有這個線程把這個run執行完，出去之后，把鎖釋放了，其他某個線程才能進入到這個run執行。

　4.2、同步方法上的鎖

　　同步代碼塊使用的鎖是任意對象（由使用者自己來手動的指定）。

　　非靜態的方法上加的同步使用的鎖是當前對象（當前調用這個方法的那個對象）。

　　靜態方法上使用的鎖是當前的class文件（當前這個方法所屬的class文件）。

 

　　演示同步代碼塊的鎖、同步方法的鎖 、靜態同步方法的鎖源代碼：

class Demo implements Runnable
{
    static int num = 100;
    boolean flag = true;

    Object obj = new Object();

    public void run()
    {
        if( flag )  //使用判斷進行線程執行任務的代碼切換
        {        
            while(true)
            {    //thread-0
                synchronized( Demo.class )
                {
                    if( num > 0 )
                    {    
                        System.out.println(Thread.currentThread().getName()+"......"+num);        
                        num--;
                    }
                }
            }
        }
        else
        {
            while(true)
            {
                //thread-1
                show();
            }
        }
    }
    /*
        show方法中的所有代碼全部是需要被同步的代碼。這時就可以把這個同步加載show方法
        在方法上加同步的格式:直接在方法上書寫同步關鍵字即可


        非靜態的方法在執行的時候需要被對象調用。
        這個show方法是被當前的Demo對象調用的，這時在show方法上加的同步使用的鎖就是當前的
        那個Demo對象。就是this


        靜態方法上使用的鎖不是this，靜態方法執行時不需要對象。而靜態方法是被類名直接調用。
        靜態方法上使用的鎖是當前的class文件
    */
    public  static synchronized  void show()
    {
        if( num > 0 )
        {
            System.out.println(Thread.currentThread().getName()+"================="+num);    
            num--;
        }
    }
}

class ThreadDemo3 
{
    public static void main(String[] args) 
    {
        //創建任務
        Demo d = new Demo();

        //創建線程
        Thread t = new Thread(d);
        Thread t2 = new Thread(d);

        t.start();
        //程序是從主線程開始運行，在運行時，雖然開啟了thread-0線程，
        //但是cpu可能不會立刻切換到thread-0線程上。
        //為了保證thread-0一定能夠進入到if中執行，thread-1進入else執行
        //讓主線程在開啟thread-0線程之后，讓主線程休眠
        try{Thread.sleep(1);}catch(InterruptedException e){}
        //把標記改為false，讓下一個線程進入的else中執行
        d.flag = false;
        t2.start();
    }
}

　　售票的例子使用Runnable接口實現並加同步：

//書寫售票的示例
class Demo implements Runnable{
    //定義變量記錄剩余的票數
    int num = 100;
    
    //創建一個對象，用作同步中的鎖對象
    Object obj = new Object();

    //實現run方法
    public void run()    {    
        
        //實現售票的過程
        while( true )        {
            //   t1  t2  t3
            //判斷當前有沒有線程正在if中操作num，如果有當前線程就在這里臨時等待
            //這種思想稱為線程的同步
            //當票數小等於0的時候，就不再售票了
            //使用同步代碼塊把線程要執行的任務代碼可以同步起來
            synchronized( obj )  //t1   在進入同步之前線程要先獲取鎖
            /*
                當某個線程執行到synchronized關鍵字之后，這時JVM會判斷當前
                同步上的這個對象有沒有已經被其他線程獲取走了，如果這時沒有其他
                線程獲取這個對象，這時就會把當前同步上的這個對象交給當前正要進入
                同步的這個線程。
            */
            {
                if( num > 0 )
                {
                    //t0
                    try{Thread.sleep(2);}catch( InterruptedException e ){}
                    System.out.println(Thread.currentThread().getName()+"....."+num);
                    num--;
                }
            }//線程執行完同步之后，那么這時當前這個線程就會把鎖釋放掉

            
        }
    }
}
class ThreadDemo {
    public static void main(String[] args)     {
        //創建線程任務
        Demo d = new Demo();
        //創建線程對象
        Thread t = new Thread( d );
        Thread t2 = new Thread(d);
        Thread t3 = new Thread(d);
        Thread t4 = new Thread(d);
        //開啟線程
        t.start();
        t2.start();
        t3.start();
        t4.start();
    }
}

　　售票的例子使用Thread實現並加同步：

class Ticket extends Thread
{
    static int num = 10000;
    static Object obj = new Object();
    public void run()
    {
        while( num > 0 )
        {
            synchronized(obj)
            {
                if( num > 0 )
                {
                    System.out.println(Thread.currentThread().getName()+"..."+num);
                    
                    num--;
                }
            }
        }
            
    }

}
class  ThreadDemo2
{
    public static void main(String[] args) 
    {
        Ticket t = new Ticket();
        Ticket t2 = new Ticket();
        Ticket t3 = new Ticket();
        Ticket t4 = new Ticket();

        t.start();
        t2.start();
        t3.start();
        t4.start();
    }
}

5、單例懶漢式線程並發問題

　　單例設計模式：保證當前程序中的這個類對象唯一。

　　單例設計模式代碼書寫步驟：

　　1、私有本類的構造方法

　　2、創建本類對象

　　3、對外提供訪問本類對象的方法

 

　　常用的模版代碼：

//餓漢式
class Single
{
　　private Single(){}

　　private static final Single s = new Single();

　　public static Single getInstance()
　　{
　　　　return s;
　　}

}


//懶漢式
class Single
{
　　private Single(){}

　　private static Single s = null;

　　public static Single getInstance()
　　{
　　　　if( s == null )
　　　　{
　　　　　　s = new Single();
　　　　}
　　　　return s;
　　}
}

　　懶漢式的多線程並發訪問的安全問題：

//書寫單例類
class Single
{
    private static Object obj = new Object();
    //私有構造方法
    private Single()
    {
    }
    //定義成員變量記錄當前本類的對象
    private static  Single s = null;

    //對外提供方法訪問本類的對象
    public static Single getInstance()
    {
        /*
            這里有安全問題，當多個線程進來之后，在執行判斷和創建對象之間可能出現
            cpu在線程之間的切換，一旦cpu切換了線程，就會導致每個線程都創建
            一個當前單例類的對象，這樣就會導致當前的單例類不再保證對象唯一了
        */
        //t1  
        if( s == null )// 這里加判斷的目的是保證后續來的線程不用在進入同步代碼塊中，這個可以提高后續程序效率
        {
            synchronized( obj )
            {
                //先判斷有沒有對象
                if( s == null )   //判斷最后線程進入同步之后到底有沒有對象，只有在沒有對象的情況下才能創建對象
                { 
                    s = new Single();
                }
            }
            //t0
        }
        //返回對象
        return s; 
    }
}
//多線程並發訪問單例類獲取對象
class Demo implements Runnable
{
    public void run()
    {
        Single s = Single.getInstance();
        System.out.println("s="+s);
    }
}
class SingleThreadDemo 
{
    public static void main(String[] args) 
    {
        //創建線程的任務
        Demo d = new Demo();

        //創建線程對象
        Thread t = new Thread(d);
        Thread t2 = new Thread(d);

        t.start();
        t2.start();
    }
}

6、死鎖示例

　　死鎖：

　　　　在多線程執行任務的時候，可能出現需要獲取到多把鎖才能去完成某個任務。

　　　　Thread-0  、Thread-1

　　　　它們要完成線程的任務，而它們都需要獲取不同的鎖才能完成。

　　　　Thread-0  需要先獲取A鎖  再獲取B才能去完成任務

　　　　而Thread-1線程需要先獲取B鎖，在獲取A鎖才能完成任務。

 

　　　　這時Thread-0 獲取到了A的時候，CPU切換到Thread-1上，這時Thread-1就獲取到了B鎖。

　　　　這時就出現了2個線程要執行任務都需要獲取對方線程上的那個鎖。

　　

　　死鎖示例源代碼：

//死鎖程序演示
class Demo implements Runnable
{
    int num = 100;
    //定義一個鎖
    Object obj = new Object();
    
    //定義標記，讓兩個線程去不同的代碼塊中實現售票
    boolean flag = true;

    public void run()
    {
        if( flag )
        {
            while( true )
            {
                synchronized( obj )
                {
                    show();
                }
            }
        }
        else
        {
            while(true)
            {
                show();
            }
        }
    }
    public synchronized void show()
    {

        synchronized( obj )
        {
            if( num > 0 )
            {
                System.out.println(Thread.currentThread().getName()+"............"+num );
                num--;
            }
        }
    }
}
class DeadLockDemo 
{
    public static void main(String[] args) 
    {
        Demo d = new Demo();

        Thread t = new Thread(d);
        Thread t2 = new Thread(d);

        t.start();
        try{Thread.sleep(1);}catch(Exception e){}
        d.flag = false;
        t2.start();

    }
}

　　面試的死鎖程序源代碼：

//死鎖程序書寫
class Demo implements Runnable
{
    private Object objA = new Object();
    private Object objB = new Object();
    //標記實現線程可以切換
    boolean flag = true;
    //實現run方法
    public void run()
    {
        //通過判斷flag標記目標是讓不同的線程在if和else中執行
        if( flag )
        {
            while(true)
            {
                synchronized( objA )
                {
                    System.out.println(Thread.currentThread().getName()+"....objA");
                    //t0
                    synchronized( objB )
                    {
                        System.out.println(Thread.currentThread().getName()+"....objB");
                    }
                }
            }
        }
        else
        {
            while(true)
            {
                synchronized( objB )
                {
                    System.out.println(Thread.currentThread().getName()+"....objB");
                    //t1
                    synchronized( objA )
                    {
                        System.out.println(Thread.currentThread().getName()+"....objA");
                    }
                }
            }
        }
    }
}

class DeadLock 
{
    public static void main(String[] args) 
    {
        Demo d = new Demo();

        Thread t = new Thread(d);
        Thread t2 = new Thread(d);

        t.start();
        try{Thread.sleep(1);}catch(Exception e){}
        d.flag = false;
        t2.start();
    }
}

7、生產者消費者

　生產者和消費者程序：

　　生產者主要負責生產商品，消費者主要負責消費商品。假如生產者把生產者的商品要存放的容器中，而消費者要從容器中取出商品進行消費。

　　當生產者正在生產的時候，消費者不能來消費。或者是消費者正在消費的時候生產者不要來生產。

　　當生產者把容器存放滿了，這時生產者就不能在繼續給容器中存放商品，消費者如果把容器中的商品消費完了，消費者就不能在繼續消費。

 

　分析生產者線程和消費者線程：

　　生產者線程主要負責給容器中存放商品，而消費者線程主要負責從容器中取出商品進行消費。生產者線程和消費者線程它們的線程任務不一樣。

　　由於生產者和消費者線程任務不同，就無法寫同一個run方法中，就需要書寫兩個run方法來封裝生產者的現場那個任務和封裝消費者的線程任務，

　　那么就需要定義2個類。這個2個類分別負責生產者和消費者線程任務。

 

　分析容器：

　　消費者線程任務對象一旦創建就必須明確自己消費的是那個容器中的商品，而生產者線程任務對象一創建，就必須明確自己生產的商品存放到哪個容器中。

　　這時我們可以單獨定義一個類，這個類專門負責封裝容器。並且這個類需要對外提供給容器中存放商品的功能，和從容器中取出商品的功能。

 

　　單生產單消費代碼簡單實現：

/*
    生產者和消費者
    為了程序簡單化，先研究單生產和單消費。
*/

//一個用來封裝容器的類
class Resource
{
    //這里定義一個容器，主要負責用來存放商品和取出商品
    //定義了一個數組容器，這個容器中只能存放一個商品
    private Object[] objs = new Object[1];

    private Object obj = new Object();
    
    //對外提供給容器中存放商品的方法
    public void put( Object obj )   
    {
        objs[0] = obj;
        try{Thread.sleep(1);}catch( InterruptedException e ){}
        System.out.println(Thread.currentThread().getName()+"..存入的商品是..."+objs[0]);
    }
    //對外提供給容器中取出商品的方法
    public void get()   
    {
        System.out.println(Thread.currentThread().getName()+"----取出的商品是--------"+objs[0]);

        objs[0] = null; 
    }
}

//一個類用來描述生產者線程的任務
class Producer implements Runnable
{
    //定義一個成員變量記錄當前傳遞進來的資源對象
    private Resource r;
    //在一創建生產者任務對象的時候，就必須明確當前的商品要存放到那個容器資源中
    Producer( Resource r )
    {
        this.r = r;
    }
    //實現run方法，在run方法中完成生產線程的存放商品的動作
    public void run()
    {
        //定義變量記錄當前生產的商品編號
        int num = 1;
        //生產者線程一旦進入run方法之后就不斷的來生產
        while( true )
        {
            r.put( "面包"+num );
            num++;
        }
    }
}

//一個類用來描述消費者線程的任務
class Consumer implements Runnable
{
    private Resource r;
    Consumer( Resource r )
    {
        this.r = r;
    }
    //run方法中封裝的消費者消費商品的任務代碼
    public void run()
    {
        while( true )
        {
            r.get();
        }
    }
}

class ThreadDemo4 
{
    public static void main(String[] args) 
    {
        //創建生產者或者消費者要操作的資源對象
        Resource r = new Resource();

        //創建生產者任務對象
        Producer pro = new Producer( r );
        //創建消費者任務對象
        Consumer con = new Consumer( r );


        //創建線程對象
        Thread t = new Thread( pro );
        Thread t2 = new Thread( con );

        t.start();
        t2.start();

    }
}

　　單生產單消費 中的同步實現：

/*
    加入同步解決的是在存入的時候不能消費
    在消費的時候不能存入。
*/

//一個用來封裝容器的類
class Resource
{
    //這里定義一個容器，主要負責用來存放商品和取出商品
    //定義了一個數組容器，這個容器中只能存放一個商品
    private Object[] objs = new Object[1];

    private Object obj = new Object();
    
    //對外提供給容器中存放商品的方法
    public void put( Object obj )   
    {
        //加入同步目的是保證生產者在生產的時候，消費者不能消費
        synchronized( obj )
        {
            objs[0] = obj;
        
            System.out.println(Thread.currentThread().getName()+"..存入的商品是..."+objs[0]);
        }
    }
    //對外提供給容器中取出商品的方法
    public void get()   
    {
        //加入同步目的是在消費者消費的時候生產者不要來生產
        synchronized( obj )
        {
            System.out.println(Thread.currentThread().getName()+"----取出的商品是--------"+objs[0]);

            objs[0] = null; 
        }
    }
}

//一個類用來描述生產者線程的任務
class Producer implements Runnable
{
    //定義一個成員變量記錄當前傳遞進來的資源對象
    private Resource r;
    //在一創建生產者任務對象的時候，就必須明確當前的商品要存放到那個容器資源中
    Producer( Resource r )
    {
        this.r = r;
    }
    //實現run方法，在run方法中完成生產線程的存放商品的動作
    public void run()
    {
        //定義變量記錄當前生產的商品編號
        int num = 1;
        //生產者線程一旦進入run方法之后就不斷的來生產
        while( true )
        {
            r.put( "面包"+num );
            num++;
        }
    }
}

//一個類用來描述消費者線程的任務
class Consumer implements Runnable
{
    private Resource r;
    Consumer( Resource r )
    {
        this.r = r;
    }
    //run方法中封裝的消費者消費商品的任務代碼
    public void run()
    {
        while( true )
        {
            r.get();
        }
    }
}

class ThreadDemo5 
{
    public static void main(String[] args) 
    {
        //創建生產者或者消費者要操作的資源對象
        Resource r = new Resource();

        //創建生產者任務對象
        Producer pro = new Producer( r );
        //創建消費者任務對象
        Consumer con = new Consumer( r );


        //創建線程對象
        Thread t = new Thread( pro );
        Thread t2 = new Thread( con );

        t.start();
        t2.start();

    }
}

　　單生產單消費 中的等待喚醒機制：

/*
    解決問題：
        由於程序中給的容易僅僅只能存放一個商品，
        當生產者正好把商品存放到容器中之后，這時cpu依然在執行生產者線程，很多有可能出現繼續執行生產者往
        容器中存放商品的現象。這時一旦生產者第二次或者多次存放商品前面已經存放進去的商品就沒有被消費
        而被后續的商品給覆蓋了。

        當消費者正好把容器中的商品消費完了，cpu還在執行消費者線程時，就可能發生消費者再次來消費，
        但是容器中並沒有商品，這時就會出現消費null

    解決思路：
        在生產者生產商品的時候，首先不應該立刻給容器中就存放商品，而應該先判斷當前容器中
        有沒有商品，如果有就不能存放，應該等待消費者來消費這個商品，當消費者消費完這個商品之后
        生產者就可以來把商品存放到容器中。

        消費者來消費商品的時候，也不能直接去消費，也需要判斷當前的容器中有沒有商品，如果有
        才能消費，如果沒有就需要等待。等待生產者給容器中存放商品。


    在解決生產者和消費者問題的時候，我們需要線程進行等待。如何讓線程等待呢？
        在查閱api的時候在Thread類中沒有找到等待的方法，而在Object類中找到等待的方法。
        在Java中我們要讓那個線程等待，這個線程必須位於同步代碼塊中，只要線程位於同步中
        那么這個線程肯定會持有當前同步的鎖對象。
        我們如果要讓某個線程從執行狀態改變為等待的狀態，這時需要使用當前同步上的鎖對象，
        這時這個鎖對象就知道當前是那個線程持有自己。這時這個鎖對象就有能力讓線程處於等待狀態。
        一個鎖可以監視多個線程。就可以使用這個鎖讓當前線程等待。
        鎖讓線程等待，那么這個等待的方法應該屬於鎖的。而在同步代碼塊中，鎖又是任意的。
        任何一個對象都可以作為鎖，那么任何一個對象都應該具備讓線程處於等待的功能。
        任何對象都具備的功能，就需要抽取到Object類中。


*/

//一個用來封裝容器的類
class Resource
{
    //這里定義一個容器，主要負責用來存放商品和取出商品
    //定義了一個數組容器，這個容器中只能存放一個商品
    private Object[] objs = new Object[1];

    private Object obj_lock = new Object();
    
    //對外提供給容器中存放商品的方法
    public void put( Object obj )   
    {
        //加入同步目的是保證生產者在生產的時候，消費者不能消費
        synchronized( obj_lock )
        {
            //判斷當前容器中是否有商品
            if( objs[0] != null )
            {
                //讓生產者線程等待
                try{obj_lock.wait();}catch(InterruptedException e){}  
            }
            objs[0] = obj;
        
            System.out.println(Thread.currentThread().getName()+"..存入的商品是..."+objs[0]);

            //生產者在生產完商品之后，要通知消費來消費

            obj_lock.notify();

        }
    }

    //對外提供給容器中取出商品的方法
    public void get()    
    {
        //加入同步目的是在消費者消費的時候生產者不要來生產
        synchronized( obj_lock )
        {
            //判斷當前是否有商品，如果沒有消費者線程要等待
            if( objs[0] == null )
            {
                //讓消費者線程等待
                try{obj_lock.wait();}catch(InterruptedException e){}  
            }
            System.out.println(Thread.currentThread().getName()+"----取出的商品是--------"+objs[0]);

            objs[0] = null; 

            //消費者在消費完商品之后，要通知生產來生產

            obj_lock.notify();
        }
    }
}

//一個類用來描述生產者線程的任務
class Producer implements Runnable
{
    //定義一個成員變量記錄當前傳遞進來的資源對象
    private Resource r;
    //在一創建生產者任務對象的時候，就必須明確當前的商品要存放到那個容器資源中
    Producer( Resource r )
    {
        this.r = r;
    }
    //實現run方法，在run方法中完成生產線程的存放商品的動作
    public void run()
    {
        //定義變量記錄當前生產的商品編號
        int num = 1;
        //生產者線程一旦進入run方法之后就不斷的來生產
        while( true )
        {
            r.put( "面包"+num );
            num++;
        }
    }
}

//一個類用來描述消費者線程的任務
class Consumer implements Runnable
{
    private Resource r;
    Consumer( Resource r )
    {
        this.r = r;
    }
    //run方法中封裝的消費者消費商品的任務代碼
    public void run()
    {
        while( true )
        {
            r.get();
        }
    }
}

class ThreadDemo6 
{
    public static void main(String[] args) 
    {
        //創建生產者或者消費者要操作的資源對象
        Resource r = new Resource();

        //創建生產者任務對象
        Producer pro = new Producer( r );
        //創建消費者任務對象
        Consumer con = new Consumer( r );


        //創建線程對象
        Thread t = new Thread( pro );
        Thread t2 = new Thread( con );

        t.start();
        t2.start();

    }
}

　　多生產多消費 中的等待喚醒機制  需要把if改成while 需要把notify改為notifyAll：

/*
    程序修改成多個生產者和多個消費之后，有出現了商品的覆蓋現象，
    或者消費者不斷的消費null現象
    導致這個原因的問題，是生產者在喚醒的時候把另外的生產者喚醒了，而被喚醒的
    生產者沒有去判斷還有沒有商品，直接就開始生產了。這樣就會出現商品的覆蓋。

    消費者消費null的原因是在消費者喚醒其他的消費者，被喚醒的消費者也不去判斷有沒有
    商品，就直接開始消費

    解決方案：
        在喚醒之后，重新去判斷有沒有商品即可。
        這時只需要把判斷有沒有商品的if結構改為while這樣就可以在每次喚醒之后，繼續進行
        while的條件進行判斷

    把if改為while之后死鎖了，原因是生產者喚醒時喚醒了生產者或者消費者消費時喚醒了消費者。
    這時就在喚醒之后，又回到while中判斷，當前被喚醒的繼續等待。就會出現死鎖現象。
    解決方案：在喚醒的時候，不僅喚醒本方，也需要喚醒對象。我們這時可以使用notifyAll方法喚醒當前
    鎖對象上等待的所有線程。

*/

//一個用來封裝容器的類
class Resource
{
    //這里定義一個容器，主要負責用來存放商品和取出商品
    //定義了一個數組容器，這個容器中只能存放一個商品
    private Object[] objs = new Object[1];

    private Object obj_lock = new Object();

    int num = 1;
    
    //對外提供給容器中存放商品的方法
    public void put( Object obj )  
    {
        //加入同步目的是保證生產者在生產的時候，消費者不能消費
        synchronized( obj_lock )
        {
            //判斷當前容器中是否有商品
            while( objs[0] != null )
            {
                //讓生產者線程等待
                try{obj_lock.wait();}catch(InterruptedException e){}  //  t1     //t0    
            }

            objs[0] = obj+""+num;  
            num++;
        
            System.out.println(Thread.currentThread().getName()+"..存入的商品是..."+objs[0]);

            //生產者在生產完商品之后，要通知消費來消費
            obj_lock.notifyAll();  

        }
    }
     

    //對外提供給容器中取出商品的方法
    public void get()  
    {
        //加入同步目的是在消費者消費的時候生產者不要來生產
        synchronized( obj_lock )  
        {
            //判斷當前是否有商品，如果沒有消費者線程要等待
            while( objs[0] == null )
            {
                //讓消費者線程等待
                try{obj_lock.wait();}catch(InterruptedException e){}     // t3 
            }
            System.out.println(Thread.currentThread().getName()+"----取出的商品是--------"+objs[0]);
            
            objs[0] = null; 

            //消費者在消費完商品之后，要通知生產來生產

            obj_lock.notifyAll();    //t2
        }
    }
}

//一個類用來描述生產者線程的任務
class Producer implements Runnable
{
    //定義一個成員變量記錄當前傳遞進來的資源對象
    private Resource r;
    //在一創建生產者任務對象的時候，就必須明確當前的商品要存放到那個容器資源中
    Producer( Resource r )
    {
        this.r = r;
    }
    //實現run方法，在run方法中完成生產線程的存放商品的動作
    public void run()
    {
        //生產者線程一旦進入run方法之后就不斷的來生產
        while( true )
        {
            r.put( "面包" );
        }
    }
}

//一個類用來描述消費者線程的任務
class Consumer implements Runnable
{
    private Resource r;
    Consumer( Resource r )
    {
        this.r = r;
    }
    //run方法中封裝的消費者消費商品的任務代碼
    public void run()
    {
        while( true )
        {
            r.get();
        }
    }
}

class ThreadDemo7 
{
    public static void main(String[] args) 
    {
        //創建生產者或者消費者要操作的資源對象
        Resource r = new Resource();

        //創建生產者任務對象
        Producer pro = new Producer( r );
        //創建消費者任務對象
        Consumer con = new Consumer( r );


        //創建線程對象
        Thread t = new Thread( pro );
        Thread t2 = new Thread( pro );

        Thread t3 = new Thread( con );
        Thread t4 = new Thread( con );

        t.start();
        t2.start();
        t3.start();
        t4.start();

    }
}

8、JDK5對鎖的升級

　　在學習生產者和消費者的時候在使用等待和喚醒機制的時候，發生了本方喚醒本方的。這樣導致程序的效率降低。

　　在jdk5中對等待喚醒以及鎖的機制進行了升級。

　　鎖的升級：

　　　　在jdk5之前同步中獲取鎖和釋放鎖都是隱式的。把隱式的鎖變成了顯示由程序員自己手動的獲取和釋放。

 

　　jdk5對鎖的描述：采用的接口來描述。在java.util.concurrent.locks包下有接口Lock它是專門放負責描述鎖這個事物。

　　Lock鎖代替了同步代碼塊。在多線程中能夠使用同步代碼塊的地方都可以使用Lock接口來代替。

　　當我們使用Lock接口代替同步代碼塊的時候，就需要程序員手動的來獲取鎖和釋放鎖，如果在程序中出現了獲取鎖之后，沒有釋放鎖，導致其他程序無法進入這個同步語句中。需要使用try-finally語句在finally中書寫釋放鎖的代碼。

　　在Lock接口中lock方法和unLock方法分別是獲取鎖和釋放鎖。

//使用JDK5的鎖完成售票的例子
import java.util.concurrent.locks.*;
class Ticket implements Runnable
{
    int num = 100;

    //創建鎖對象
    Lock loc = new ReentrantLock();  //多態了

    public void run()
    {
        while( true )
        {
                //獲取鎖
                loc.lock();
                try
                {
                    if( num > 0 )
                    {
                        System.out.println(Thread.currentThread().getName()+"............."+num);
                        num--;
                    }
                }
                finally
                {
                    //釋放鎖
                    loc.unlock();
                }
        }
    }
}

class LockDemo 
{
    public static void main(String[] args) 
    {
        //創建線程任務
        Ticket t = new  Ticket();

        //創建線程對象
        Thread tt = new  Thread(t);
        Thread tt2 = new  Thread(t);
        Thread tt3 = new  Thread(t);
        Thread tt4 = new  Thread(t);

        //開啟線程
        tt.start();
        tt2.start();
        tt3.start();
        tt4.start();
    }
}

9、JDK5對監視器方法的升級

　　JDK5對同步的鎖進行了升級，同時還對等待喚醒機制也進行了升級。

　　在JDK5之前等待喚醒機制的方法和當前鎖綁定在一起。在編寫生產者和消費者任務的時候，由於消費者和生產者使用的同一個鎖，那么就會導致使用當前這個鎖來喚醒在這個鎖上等待的線程的時，就可能發生生產者喚醒生產者或者消費者喚醒消費者。

　　到了JDK5之后，鎖被Lock接口來描述，等待喚醒的方法也被重新封裝成一個類。專門使用一個類負責等待喚醒。JDK5中使用Condtion接口來專門負責描述等待喚醒機制。Condition代替了jdk5之前的Object類中的wait、notify、notifyAll方法。await方法代替了Object中wait方法、signal代替的notify、signalAll代替notifyAll方法。

 　　當我們需要使用等待喚醒的時候，就需要獲取到Condition對象，然后把這個Condition對象和Lock接口綁定在一起即可。這樣就可以使用一個Lock下面綁定多個Condition。在Lock接口有個方法newCondition這個方法就可以讓一個Condtion對象和Lock接口對象綁定在一起了。

10、使用JDK完成生產者消費者案例

//使用Lock代替同步，使用Condition接口代替等待和喚醒
import java.util.concurrent.locks.*;
class Resource
{
    Object[] objs = new Object[1];
    //記錄存入的商品編號
    int num = 1;

    //獲取Lock鎖對象
    Lock loc = new ReentrantLock();
    //定義生產者的等待喚醒對象（監視器對象  Condition）
    Condition pro_con = loc.newCondition();
    //定義消費者者的等待喚醒對象（監視器對象  Condition）
    Condition con_con = loc.newCondition();
    
    public void put( Object obj )
    {
        //獲取鎖
        loc.lock();
        try
        {
            //判斷有沒有商品
            if( objs[0] !=null )
            {
                //讓生產者等待
                try{pro_con.await();}catch(Exception e){}
            }
            objs[0] = obj +"" + num;
            num++;
            System.out.println(Thread.currentThread().getName()+"........"+objs[0]);
            //喚醒消費者
            con_con.signal();
            
        }
        finally
        {
            loc.unlock();
        }
        
    }
    public void get()
    {
        //獲取鎖
        loc.lock();
        try
        {
            //判斷有沒有商品
            if( objs[0] == null )
            {
                //讓消費者等待
                try{con_con.await();}catch(Exception e){}
            }

            System.out.println(Thread.currentThread().getName()+"================="+objs[0]);
            objs[0]=null;
            //喚醒生產者
            pro_con.signal();
        }
        finally
        {
            loc.unlock();
        }
    }

}
class Producer implements Runnable
{
    private Resource r;
    public Producer( Resource r )
    {    
        this.r = r;
    }
    public void run()
    {
        while( true )
        {
            r.put("方便面");
        }
    }
}

class  Consumer implements Runnable
{
    private Resource r;
    public Consumer( Resource r )
    {    
        this.r = r;
    }
    public void run()
    {
        while( true )
        {
            r.get();
        }
    }
}


class LockConditionTest 
{
    public static void main(String[] args) 
    {
        Resource r = new Resource();

        Producer pro = new Producer(r);
        Consumer con = new Consumer(r);

        Thread t  = new Thread(pro);
        Thread t2  = new Thread(pro);
        Thread t3 = new Thread(con);
        Thread t4 = new Thread(con);

        t.start();
        t2.start();
        t3.start();
        t4.start();
    }
}