JAVA多線程(三)

線程同步
1、什麼是線程同步
　　概念上的東西在這裏就不過多介紹了，線程同步，也叫做線程間通信，就是多個線程共同協作完成一件事情。

　　爲了完成一件事情，可能需要分很多的部分或步驟，每個部分由一個或一類線程來負責，而各個部分的處理又有先後順序，這就對相互協作的線程有了一定的約束，也就是進程同步。

2、Java中如何實現線程同步
　　在Java中，線程的同步涉及到synchronized和三個方法wait()、notify()和notifyAll()。

　　synchronized在上篇中已經講過了，這裏就不再重複了。

　　wait()方法與Thread類的sleep()和yield()方法類似，都是讓當線程睡眠，或者說是暫停執行；與之不同的是wait()方法會釋放掉當前對象的鎖，也因爲此wait()方法必須在synchronized塊裏才能被調用。

　　notify()和notifyAll()方法用於喚醒之前調用wait()方法睡眠的線程，與wait()方法一樣，notify()和notifyAll()也必須在synchronized塊裏才能被調用。

　　注意wait()、notify()和notifyAll()三個方法都是Object類的，而不是Thread類的。因爲這三個方法都涉及的鎖的操作，而鎖的操作適用於所有的對象。

3、線程同步事例
　　下面的這例子，假設有一個籃子，最多可以裝5個蘋果，producer線程不斷地往裏面放蘋果，consumer線程不斷的吃蘋果。

public class Basket
{
    private int numOfPlace = 5;
    private int numOfApple = 0;

    public synchronized void addApple() throws InterruptedException
    {
        while (numOfPlace <= 0)
            wait();

        Thread.sleep(100);

        numOfPlace--;
        numOfApple++;

        System.out.println("Producing... [" + (numOfApple) + "] apple left.");

        notify();
    }


    public synchronized void eatApple() throws InterruptedException
    {
        while (numOfApple <= 0)
            wait();

        numOfPlace++;
        numOfApple--;

        Thread.sleep(100);

        System.out.println("Eating... [" + (numOfApple) + "] apple left.");

        notify();
    }


    public static void main(String[] args) throws InterruptedException
    {
        Basket box = new Basket();
        ExecutorService exec = Executors.newCachedThreadPool();
        exec.execute(new Producer(box));
        exec.execute(new Consumer(box));
        TimeUnit.SECONDS.sleep(3);
        exec.shutdownNow();
    }
}

class Producer implements Runnable
{
    private Basket box;

    public Producer(Basket box)
    {
        this.box = box;
    }

    @Override
    public void run()
    {
        while (true)
        {
            try
            {
                box.addApple();
                Thread.yield();
            }
            catch (InterruptedException e)
            {
                e.printStackTrace();
                return;
            }
        }
    }

}

class Consumer implements Runnable
{
    private Basket box;

    public Consumer(Basket box)
    {
        this.box = box;
    }

    @Override
    public void run()
    {
        while (true)
        {
            try
            {
                box.eatApple();
                Thread.yield();
            }
            catch (InterruptedException e)
            {
                e.printStackTrace();
                return;
            }
        }
    }

}

　　Basket.addApple()方法中，首先檢查籃子還有沒有空間可以裝入新蘋果，如果沒有，那麼producer線程就調用Basket對象的wait()方法，等侍並釋放Basket對象的鎖；接着consumer線程就有機會取得Basket對象的鎖並進入eatApple()方法，當consumer方法成功吃掉一個蘋果後，籃子就有空間裝入新的蘋果了，這時eatApple()方法中調用Basket對象的notifyAll()方法通知producer線程；這時prodocer線程又會重新獲得Basket對象的鎖，並再次檢查是否有空間裝入新的蘋果，成功裝入一個蘋果後，也會調用Basket對象的notifyAll()方法通知consumber線程。

　　上面這個例子中producer和consumer線程就是通過wait()和notify()方法來通信，實現共同協作的。

4、使用Lock和Condition實現線程同步
　　Java1.5提供了Lock和Condition接口，也可以實現線程同步，下面使用了Lock和Condition的方式重寫了上面的例子：

public class Basket
{
    Lock lock = new ReentrantLock();
    Condition condition = lock.newCondition();
    
    private int numOfPlace = 5;
    private int numOfApple = 0;

    public void addApple() throws InterruptedException
    {
        try
        {
            lock.lock();
            
            while (numOfPlace <= 0)
                condition.await();

            Thread.sleep(100);

            numOfPlace--;
            numOfApple++;

            System.out.println("Producing... [" + (numOfApple) + "] apple left.");

            condition.signalAll();
        }
        finally
        {
            lock.unlock();
        }
    }


    public void eatApple() throws InterruptedException
    {
        try
        {
            lock.lock();
            
            while (numOfApple <= 0)
                condition.await();

            numOfPlace++;
            numOfApple--;

            Thread.sleep(100);

            System.out.println("Eating... [" + (numOfApple) + "] apple left.");

            condition.signalAll();
        }
        finally
        {
            lock.unlock();
        }
        
    }

    public static void main(String[] args) throws InterruptedException
    {
        Basket box = new Basket();
        ExecutorService exec = Executors.newCachedThreadPool();
        exec.execute(new Producer(box));
        exec.execute(new Consumer(box));
        TimeUnit.SECONDS.sleep(3);
        exec.shutdownNow();
    }
}

class Producer implements Runnable
{
    private Basket box;

    public Producer(Basket box)
    {
        this.box = box;
    }

    @Override
    public void run()
    {
        while (true)
        {
            try
            {
                box.addApple();
                Thread.yield();
            }
            catch (InterruptedException e)
            {
                e.printStackTrace();
                return;
            }
        }
    }

}

class Consumer implements Runnable
{
    private Basket box;

    public Consumer(Basket box)
    {
        this.box = box;
    }

    @Override
    public void run()
    {
        while (true)
        {
            try
            {
                box.eatApple();
                Thread.yield();
            }
            catch (InterruptedException e)
            {
                e.printStackTrace();
                return;
            }
        }
    }

}

　　新的方法提供了更好的靈活性，但也增加了出錯的可能性，如果沒有特殊的需求，還是採用原來的方式來得實在。