java如何设置多线程执行顺序

如何设置Java多线程执行顺序：使用线程优先级、线程同步、线程等待通知机制

在Java中，设置多线程执行顺序的主要方法包括设置线程优先级、使用线程同步（如synchronized关键字）、利用线程的等待通知机制（如wait()、notify()）。其中，线程同步是一种常用且有效的方法，通过控制共享资源的访问来确保线程按预期的顺序执行。

一、设置线程优先级

Java中的线程有优先级属性，通过设置不同的优先级，可以影响线程的执行顺序。优先级是一个整数值，范围从1到10，默认优先级为5。线程优先级越高，获取CPU时间片的概率越大。使用Thread.setPriority(int newPriority)方法可以设置线程的优先级。

public class PriorityDemo {
    public static void main(String[] args) {
        Thread highPriorityThread = new Thread(() -> {
            System.out.println("High priority thread executing.");
        });
        Thread lowPriorityThread = new Thread(() -> {
            System.out.println("Low priority thread executing.");
        });
        highPriorityThread.setPriority(Thread.MAX_PRIORITY);
        lowPriorityThread.setPriority(Thread.MIN_PRIORITY);
        highPriorityThread.start();
        lowPriorityThread.start();
    }
}

在上述示例中，highPriorityThread线程被设置为最高优先级，lowPriorityThread被设置为最低优先级，但需要注意，优先级只是一个建议，不能保证高优先级线程一定会先执行。

二、使用线程同步

线程同步是控制多线程执行顺序的有效手段。通过使用synchronized关键字，可以确保某些代码块或方法在同一时间只能被一个线程执行，从而避免线程干扰和数据不一致的问题。

1、synchronized代码块

synchronized代码块可以用来控制对共享资源的访问。以下是一个使用synchronized代码块的示例：

class Counter {
    private int count = 0;
    public void increment() {
        synchronized (this) {
            count++;
            System.out.println("Count after increment: " + count);
        }
    }
}
public class SyncDemo {
    public static void main(String[] args) {
        Counter counter = new Counter();
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 5; i++) {
                counter.increment();
            }
        });
        Thread t2 = new Thread(() -> {
            for (int i = 0; i < 5; i++) {
                counter.increment();
            }
        });
        t1.start();
        t2.start();
    }
}

在这个例子中，increment()方法内部的synchronized代码块确保了每次只有一个线程能够执行该代码块，从而保证了线程安全和执行顺序。

2、synchronized方法

synchronized方法是另一种控制线程同步的方式。以下是一个使用synchronized方法的示例：

class Counter {
    private int count = 0;
    public synchronized void increment() {
        count++;
        System.out.println("Count after increment: " + count);
    }
}
public class SyncDemo {
    public static void main(String[] args) {
        Counter counter = new Counter();
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 5; i++) {
                counter.increment();
            }
        });
        Thread t2 = new Thread(() -> {
            for (int i = 0; i < 5; i++) {
                counter.increment();
            }
        });
        t1.start();
        t2.start();
    }
}

与synchronized代码块类似，synchronized方法也确保了同一时间只有一个线程能够执行该方法。

三、利用线程的等待通知机制

Java提供了线程的等待通知机制（wait、notify、notifyAll），可以用于在线程间协调执行顺序。

1、wait()和notify()

wait()方法让当前线程进入等待状态，直到其他线程调用notify()方法或notifyAll()方法来唤醒它。以下是一个简单的示例：

class SharedResource {
    private boolean isAvailable = false;
    public synchronized void produce() throws InterruptedException {
        while (isAvailable) {
            wait();
        }
        System.out.println("Produced item.");
        isAvailable = true;
        notify();
    }
    public synchronized void consume() throws InterruptedException {
        while (!isAvailable) {
            wait();
        }
        System.out.println("Consumed item.");
        isAvailable = false;
        notify();
    }
}
public class WaitNotifyDemo {
    public static void main(String[] args) {
        SharedResource resource = new SharedResource();
        Thread producer = new Thread(() -> {
            try {
                for (int i = 0; i < 5; i++) {
                    resource.produce();
                }
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        });
        Thread consumer = new Thread(() -> {
            try {
                for (int i = 0; i < 5; i++) {
                    resource.consume();
                }
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        });
        producer.start();
        consumer.start();
    }
}

在这个示例中，produce()方法生成一个项目，而consume()方法消费一个项目。通过wait()和notify()方法，确保了生产者线程和消费者线程按顺序执行。

2、notifyAll()

notifyAll()方法唤醒所有等待的线程，而不仅仅是一个。在某些情况下，使用notifyAll()可能更合适。以下是一个示例：

class SharedResource {
    private boolean isAvailable = false;
    public synchronized void produce() throws InterruptedException {
        while (isAvailable) {
            wait();
        }
        System.out.println("Produced item.");
        isAvailable = true;
        notifyAll();
    }
    public synchronized void consume() throws InterruptedException {
        while (!isAvailable) {
            wait();
        }
        System.out.println("Consumed item.");
        isAvailable = false;
        notifyAll();
    }
}
public class WaitNotifyAllDemo {
    public static void main(String[] args) {
        SharedResource resource = new SharedResource();
        Thread producer = new Thread(() -> {
            try {
                for (int i = 0; i < 5; i++) {
                    resource.produce();
                }
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        });
        Thread consumer1 = new Thread(() -> {
            try {
                for (int i = 0; i < 5; i++) {
                    resource.consume();
                }
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        });
        Thread consumer2 = new Thread(() -> {
            try {
                for (int i = 0; i < 5; i++) {
                    resource.consume();
                }
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        });
        producer.start();
        consumer1.start();
        consumer2.start();
    }
}

在这个示例中，notifyAll()方法确保所有等待线程都被唤醒，从而避免潜在的死锁情况。

四、使用显式锁（ReentrantLock）

除了synchronized关键字，Java还提供了显式锁机制，如ReentrantLock，它提供了更多的控制和功能。

import java.util.concurrent.locks.ReentrantLock;
class Counter {
    private int count = 0;
    private final ReentrantLock lock = new ReentrantLock();
    public void increment() {
        lock.lock();
        try {
            count++;
            System.out.println("Count after increment: " + count);
        } finally {
            lock.unlock();
        }
    }
}
public class LockDemo {
    public static void main(String[] args) {
        Counter counter = new Counter();
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 5; i++) {
                counter.increment();
            }
        });
        Thread t2 = new Thread(() -> {
            for (int i = 0; i < 5; i++) {
                counter.increment();
            }
        });
        t1.start();
        t2.start();
    }
}

在这个示例中，通过显式锁ReentrantLock，我们可以更加灵活地控制线程的执行顺序和锁的释放顺序。

五、使用CountDownLatch

CountDownLatch是一个同步辅助类，允许一个或多个线程等待，直到在其他线程中执行的一组操作完成。

import java.util.concurrent.CountDownLatch;
public class CountDownLatchDemo {
    public static void main(String[] args) throws InterruptedException {
        CountDownLatch latch = new CountDownLatch(1);
        Thread t1 = new Thread(() -> {
            try {
                System.out.println("Thread 1 waiting for latch.");
                latch.await();
                System.out.println("Thread 1 proceeding.");
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        });
        Thread t2 = new Thread(() -> {
            System.out.println("Thread 2 doing some work.");
            latch.countDown();
            System.out.println("Thread 2 released latch.");
        });
        t1.start();
        t2.start();
        t1.join();
        t2.join();
    }
}

在这个示例中，Thread 1将等待CountDownLatch到达零，而Thread 2将减少计数，从而释放Thread 1。

六、使用CyclicBarrier

CyclicBarrier是一种同步机制，它允许一组线程互相等待，直到所有线程到达一个共同的屏障点。

import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;
public class CyclicBarrierDemo {
    public static void main(String[] args) {
        int numThreads = 3;
        CyclicBarrier barrier = new CyclicBarrier(numThreads, () -> {
            System.out.println("All threads reached the barrier. Proceeding...");
        });
        for (int i = 0; i < numThreads; i++) {
            new Thread(new Task(barrier)).start();
        }
    }
}
class Task implements Runnable {
    private final CyclicBarrier barrier;
    public Task(CyclicBarrier barrier) {
        this.barrier = barrier;
    }
    @Override
    public void run() {
        try {
            System.out.println(Thread.currentThread().getName() + " waiting at barrier.");
            barrier.await();
            System.out.println(Thread.currentThread().getName() + " proceeding.");
        } catch (InterruptedException | BrokenBarrierException e) {
            Thread.currentThread().interrupt();
        }
    }
}

在这个示例中，三个线程必须都到达屏障点，然后才能继续执行，从而确保了它们按照预期的顺序执行。

七、总结

在Java中设置多线程执行顺序的方法有很多，包括设置线程优先级、使用线程同步、利用线程的等待通知机制、显式锁、CountDownLatch、CyclicBarrier等。每种方法都有其适用场景和优缺点。选择合适的方法可以有效地控制多线程执行顺序，从而提高程序的稳定性和效率。在实际应用中，开发者应根据具体需求和情况，灵活运用这些方法来实现多线程的顺序控制。