java如何實現多線程的順序執行

Posted on by

場景

編寫一個程序，啟動三個線程，三個線程的name分別是A，B，C；，每個線程將自己的ID值在屏幕上打印5遍，打印順序是ABCABC…

使用 synchronized 實現

public class MyService
{
    private int flag = 1;
    
    public synchronized void printA(){
        
        while (flag != 1)
        {
            try
            {
                this.wait();
            }
            catch (InterruptedException e)
            {
                e.printStackTrace();
            }
        }
        System.out.print(Thread.currentThread().getName());
        flag = 2;
        this.notifyAll();
    }
    public synchronized void printB(){
        while (flag != 2)
        {
            try
            {
                this.wait();
            }
            catch (InterruptedException e)
            {
                e.printStackTrace();
            }
        }
        System.out.print(Thread.currentThread().getName());
        flag = 3;
        this.notifyAll();
    }
    public synchronized void printC(){
        while (flag != 3)
        {
            try
            {
                this.wait();
            }
            catch (InterruptedException e)
            {
                e.printStackTrace();
            }
        }
        System.out.print(Thread.currentThread().getName());
        flag = 1;
        this.notifyAll();
    }
}

這裡的判斷條件中用的是 while 而不是 if , 這兩者之間有什麼區別呢？ 線程從 wait 狀態被喚醒,並且獲得鎖以後會繼續往下執行，比如 A 調用nofityAll() 喚醒 B，C，這時 B與C誰會先獲得鎖是不確定的。如果是C先獲得瞭鎖，那麼C就繼續往下執行打印，這與我們的期望的不符。所以這裡我們使用瞭一個 while，當C獲得鎖以後再去判斷一下flag，如果這時還不是它執行的時候，它就再次進入wait狀態。此時A與C都是wait狀態，獲得鎖的一定是B，從而實現我們期望的順序打印。

測試類

package testABC;

public class TestMain
{
    public static void main(String[] args)
    {
//編寫一個程序，啟動三個線程，三個線程的ID分別是A，B，C；，每個線程將自己的ID值在屏幕上打印5遍，打印順序是ABCABC...
//        MyService service = new MyService();
        MyService2 service = new MyService2();
        
        Thread A = new Thread(new Runnable()
        {
            @Override
            public void run()
            {
                for (int i = 0; i < 5; i++)
                {
                    service.printA();
                }
            }
        });
        A.setName("A");
        Thread B = new Thread(new Runnable()
        {
            @Override
            public void run()
            {
                for (int i = 0; i < 5; i++)
                {
                    service.printB();
                }
            }
        });
        B.setName("B");
        Thread C = new Thread(new Runnable()
        {
            @Override
            public void run()
            {
                for (int i = 0; i < 5; i++)
                {
                    service.printC();
                }
            }
        });
        C.setName("C");
        
        A.start();
        B.start();
        C.start();
    }
}

使用 Lock 實現

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class MyService2
{
    private int flag = 1;
    private Lock lock = new ReentrantLock();
    private Condition conditionA = lock.newCondition();
    private Condition conditionB = lock.newCondition();
    private Condition conditionC = lock.newCondition();

    public void printA()
    {
        try
        {
            lock.lock();
            if (flag != 1)
            {
                try
                {
                    conditionA.await();
                }
                catch (InterruptedException e)
                {
                    e.printStackTrace();
                }
            }
            System.out.print(Thread.currentThread().getName());
            flag = 2;
            conditionB.signal();
        }
        finally
        {
            lock.unlock();
        }

    }

    public void printB()
    {
        try
        {
            lock.lock();
            if (flag != 2)
            {
                try
                {
                    conditionB.await();
                }
                catch (InterruptedException e)
                {
                    e.printStackTrace();
                }
            }
            System.out.print(Thread.currentThread().getName());
            flag = 3;
            conditionC.signal();
        }
        finally
        {
            lock.unlock();
        }

    }

    public void printC()
    {
        try
        {
            lock.lock();
            if (flag != 3)
            {
                try
                {
                    conditionC.await();
                }
                catch (InterruptedException e)
                {
                    e.printStackTrace();
                }
            }
            System.out.print(Thread.currentThread().getName());
            flag = 1;
            conditionA.signal();
        }
        finally
        {
            lock.unlock();
        }
    }
}

當使用LOCK時可以不使用while因為condition可以喚醒指定的線程。同時註意必須先調用 conditionA.signal(); 再調用 lock.unlock(); ，否則會拋 java.lang.IllegalMonitorStateException 異常。因為在調用unlock之後，當前線程已不是此監視器對象condition的持有者。也就是說要在此線程持有鎖定對象時，才能使用此鎖定對象。

關於此異常的博文：關於java.lang.IllegalMonitorStateException

api中的解釋 

public class IllegalMonitorStateExceptionextends RuntimeException

拋出的異常表明某一線程已經試圖等待對象的監視器，或者試圖通知其他正在等待對象的監視器而本身沒有指定監視器的線程。

從以下版本開始：

JDK1.0

另請參見：
Object.notify(), Object.notifyAll(), Object.wait(), Object.wait(long), Object.wait(long, int), 序列化表格

也就是當前的線程不是此對象監視器的所有者。也就是要在當前線程鎖定對象，才能用鎖定的對象此行這些方法，需要用到synchronized ，鎖定什麼對象就用什麼對象來執行

notify(), notifyAll(),wait(), wait(long), wait(long, int)操作，否則就會報IllegalMonitorStateException異常。

例如 :

exapmle 1,鎖定方法所屬的實例對象: 

public synchronized void method（）{
    //然後就可以調用：this.notify()...
    //或者直接調用notify()...
}

exapmle 2,鎖定方法所屬的實例的Class: 

public Class Test{
 public static synchronized void method（）{
    //然後調用：Test.class.notify()...
 }
}

exapmle 3,鎖定其他對象: 

public Class Test{
public Object lock = new Object();
 public static void method（）{
    synchronized (lock) {
     //需要調用 lock.notify();
    } 
 }
}

到此這篇關於java如何實現多線程的順序執行的文章就介紹到這瞭,更多相關java 多線程順序執行內容請搜索WalkonNet以前的文章或繼續瀏覽下面的相關文章希望大傢以後多多支持WalkonNet！

推薦閱讀：