关于java:java如何控制线程按照顺序执行

1、应用Thread.join()办法

能够在一个线程中调用另一个线程的join()办法，使得该线程期待另一个线程执行实现后再继续执行。能够通过在须要期待的线程前面调用join()办法的形式来控制线程的执行程序。

Thread t1 = new Thread(new Runnable() {
    public void run() {
        // 执行一些工作
    }
});

Thread t2 = new Thread(new Runnable() {
    public void run() {
        // 期待t1线程执行实现
        try {
            t1.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        // 继续执行一些工作
    }
});

t1.start();
t2.start();

在这个例子中，t2线程在执行之前会期待t1线程执行实现，这样就能够保障t1先执行。

2、应用Lock和Condition

能够应用Lock和Condition来控制线程的执行程序。Lock能够创立多个Condition对象，每个Condition对象能够管制一个线程的执行程序。应用Condition的await()办法能够使线程期待，应用signal()办法能够唤醒期待的线程。

class ShareResourceLock{
    // 线程执行的条件 1：线程1执行 2：线程2执行 3：线程3执行
    int number =1;
    // 锁
    Lock lock = new ReentrantLock();
    // 从锁中取得3个条件变量
    Condition condition1 = lock.newCondition();
    Condition condition2 = lock.newCondition();
    Condition condition3 = lock.newCondition();

    // 第一个线程run之后执行的办法
    public void f1(){
        lock.lock();
        try {
            // 如果条件值不为1 就挂起期待
            while(number!=1){
                System.out.println(Thread.currentThread().getName() + " await...");
                condition1.await();
            }
            // 成心阻塞100毫秒，看看其余的线程会不会不再排队
            int i= new Random().nextInt(2000);
            Integer sleepTime = 1000 + i;
            Thread.sleep(sleepTime);
            System.out.println(Thread.currentThread().getName() + " execute " + sleepTime);
            System.out.println("------1--------");
            // 线程1 执行结束 把变量设置为2
            number = 2;
            // 唤醒第2个条件变量
            condition2.signal();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            // 不论抛没抛出异样都要解锁，避免线程死锁
            lock.unlock();
        }
    }

    public void f2(){
        lock.lock();
        try {
            while(number!=2){
                System.out.println(Thread.currentThread().getName() + " await...");
                condition2.await();
            }
            int i= new Random().nextInt(2000);
            Integer sleepTime = 1000 + i;
            Thread.sleep(sleepTime);
            System.out.println(Thread.currentThread().getName() + " execute " + sleepTime);
            System.out.println("------2--------");
            number = 3;
            condition3.signal();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public void f3(){
        lock.lock();
        try {
            while(number!=3){
                System.out.println(Thread.currentThread().getName() + " await...");
                condition3.await();
            }
            int i= new Random().nextInt(2000);
            Integer sleepTime = 1000 + i;
            Thread.sleep(sleepTime);
            System.out.println(Thread.currentThread().getName() + " execute " + sleepTime);
            System.out.println("------3--------");
            number = 1;
            condition1.signal();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
}


public class ThreadOrderExecute {

    public static void main(String[] args) throws InterruptedException {
        ShareResourceLock shareDataLock = new ShareResourceLock();
        Thread t1 = new Thread(()->shareDataLock.f1(),"aa");
        Thread t2 = new Thread(()->shareDataLock.f2(),"bb");
        Thread t3 = new Thread(()->shareDataLock.f3(),"cc");

        t1.start();
        t2.start();
        t3.start();

        t1.join();
        t2.join();
        t3.join();
    }
}

在这个例子中，t1线程执行实现后会唤醒t2线程，t2线程执行实现后会唤醒t3线程，这样就能够保障线程的执行程序。留神，await()和signal()办法必须在lock.lock()和lock.unlock()之间调用，否则会抛出IllegalMonitorStateException异样。

这些办法都能够实现线程依照特定程序执行的成果，具体抉择哪种办法取决于具体的状况和需要。