Java中实现两个线程交替运行的方法

实现两个线程交替运行有多种方法，以下是其中两种方法的详细讲解。

方法一：使用wait()和notify()方法

使用wait()和notify()方法可以实现两个线程之间的通信。wait()方法会让当前线程进入等待状态，直到其他线程调用notify()方法唤醒它。在这种情况下，可以使用一个共享的锁对象来控制线程的执行顺序。具体的实现步骤如下：

1.定义一个共享锁对象，并在两个线程实例化时进行传递。

Object lock = new Object();
Thread t1 = new Thread(new Runnable(){
    public void run(){
        // 线程1的执行代码
    }
}, "线程1");
Thread t2 = new Thread(new Runnable(){
    public void run(){
        // 线程2的执行代码
    }
}, "线程2");

2.在线程执行的代码中使用synchronized语句块来获得锁，并使用wait()和notify()方法进行线程间通信。

// 线程1的执行代码
synchronized(lock){
    for(int i = 0; i < 10; i++){
        System.out.println(Thread.currentThread().getName() + ": " + i);
        lock.notify();
        try{
            lock.wait();
        } catch(InterruptedException e){
            e.printStackTrace();
        }
    }
    lock.notify(); //记得加上这一句，否则另一个线程会一直等待下去，无法退出
}

// 线程2的执行代码
synchronized(lock){
    for(int i = 0; i < 10; i++){
        System.out.println(Thread.currentThread().getName() + ": " + i);
        lock.notify();
        try{
            lock.wait();
        } catch(InterruptedException e){
            e.printStackTrace();
        }
    }
    lock.notify(); //记得加上这一句，否则另一个线程会一直等待下去，无法退出
}

3.运行程序，可以看到两个线程交替输出数字。其中，一条线程执行完毕后，唤醒另一条线程来执行。如果没有lock.notify()方法的执行，线程2就会一直处于等待状态，程序无法正常退出。

以下是一个完整的示例代码：

public class AlternationDemo {
    public static void main(String[] args) {
        Object lock = new Object();
        Thread t1 = new Thread(new Runnable() {
            public void run() {
                synchronized(lock) {
                    for(int i = 0; i < 10; i++) {
                        System.out.println(Thread.currentThread().getName() + ": " + i);
                        lock.notify();
                        try {
                            lock.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                    lock.notify(); //记得加上这一句，否则另一个线程会一直等待下去，无法退出
                }
            }
        }, "线程1");

        Thread t2 = new Thread(new Runnable() {
            public void run() {
                synchronized(lock) {
                    for(int i = 0; i < 10; i++) {
                        System.out.println(Thread.currentThread().getName() + ": " + i);
                        lock.notify();
                        try {
                            lock.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                    lock.notify(); //记得加上这一句，否则另一个线程会一直等待下去，无法退出
                }
            }
        }, "线程2");

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

方法二：使用ReentrantLock和Condition对象

除了使用wait()和notify()方法之外，还可以使用ReentrantLock和Condition对象来实现线程间的通信。ReentrantLock是可重入锁，也就是说同一个线程在获得锁之后可以再次获取锁而不会被阻塞。Condition对象是一种与Lock相关的条件队列，可以用来实现线程间的通信。使用该方法实现线程交替执行的步骤如下：

1.定义一个共享的ReentrantLock对象，并在两个线程实例化时进行传递。

ReentrantLock lock = new ReentrantLock();
Condition condition = lock.newCondition();
Thread t1 = new Thread(new Runnable(){
    public void run(){
        // 线程1的执行代码
    }
}, "线程1");
Thread t2 = new Thread(new Runnable(){
    public void run(){
        // 线程2的执行代码
    }
}, "线程2");

2.在线程执行的代码中使用lock.lock()获取锁，并使用condition.await()和condition.signal()进行线程间通信。

// 线程1的执行代码
lock.lock();
try{
    for(int i = 0; i < 10; i++){
        System.out.println(Thread.currentThread().getName() + ": " + i);
        condition.signal();
        condition.await();
    }
    condition.signal(); //记得加上这一句，否则另一个线程会一直等待下去，无法退出
} catch(InterruptedException e){
    e.printStackTrace();
} finally{
    lock.unlock();
}

// 线程2的执行代码
lock.lock();
try{
    for(int i = 0; i < 10; i++){
        System.out.println(Thread.currentThread().getName() + ": " + i);
        condition.signal();
        condition.await();
    }
    condition.signal(); //记得加上这一句，否则另一个线程会一直等待下去，无法退出
} catch(InterruptedException e){
    e.printStackTrace();
} finally{
    lock.unlock();
}

3.运行程序，可以看到两个线程交替输出数字。其中，一条线程执行完毕后，唤醒另一条线程来执行。

以下是一个完整的示例代码：

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

public class AlternationDemo {
    public static void main(String[] args) {
        ReentrantLock lock = new ReentrantLock();
        Condition condition = lock.newCondition();
        Thread t1 = new Thread(new Runnable() {
            public void run() {
                lock.lock();
                try {
                    for(int i = 0; i < 10; i++) {
                        System.out.println(Thread.currentThread().getName() + ": " + i);
                        condition.signal();
                        condition.await();
                    }
                    condition.signal(); //记得加上这一句，否则另一个线程会一直等待下去，无法退出
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    lock.unlock();
                }
            }
        }, "线程1");

        Thread t2 = new Thread(new Runnable() {
            public void run() {
                lock.lock();
                try {
                    for(int i = 0; i < 10; i++) {
                        System.out.println(Thread.currentThread().getName() + ": " + i);
                        condition.signal();
                        condition.await();
                    }
                    condition.signal(); //记得加上这一句，否则另一个线程会一直等待下去，无法退出
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    lock.unlock();
                }
            }
        }, "线程2");

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