Java如何实现多线程顺序执行

这篇文章主要介绍Java如何实现多线程顺序执行，文中介绍的非常详细，具有一定的参考价值，感兴趣的小伙伴们一定要看完！

场景

编写一个程序，启动三个线程，三个线程的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如何实现多线程顺序执行”这篇文章的所有内容，感谢各位的阅读！希望分享的内容对大家有帮助，更多相关知识，欢迎关注亿速云行业资讯频道！