java线程如何协作

在Java中，线程之间的协作主要依赖于线程间的通信、同步控制、线程调度策略以及线程的状态和优先级。其中，线程间的通信是通过wAIt()、notify()和notifyAll()等方法实现的；同步控制主要依赖于synchronized关键字和Lock锁；线程调度策略则是由操作系统决定，但Java提供了设置线程优先级的方法；线程的状态和优先级可以通过Thread类的相关方法进行控制。

当多个线程需要共享同一资源时，就需要进行同步控制，避免出现数据一致性问题。在Java中，我们可以通过synchronized关键字或Lock锁来实现同步控制。synchronized关键字可以用于方法或代码块，当一个线程进入synchronized修饰的方法或代码块时，其他线程就无法访问这段代码，直到该线程退出synchronized修饰的方法或代码块。而Lock锁提供了更灵活的线程同步模型，可以在任何地方释放锁，而不像synchronized关键字那样，只能在方法或代码块结束时释放锁。

在多线程环境下，线程的调度策略是由操作系统决定的，但Java提供了设置线程优先级的方法。线程的优先级可以通过Thread类的setPriority()方法进行设置，该方法接受一个介于1（Thread.MIN_PRIORITY）到10（Thread.MAX_PRIORITY）之间的整数。高优先级的线程会优先获得CPU的执行权，但这并不意味着低优先级的线程就无法获得CPU的执行权，只是获得的机会较少。

线程的状态和优先级也是影响线程协作的重要因素。线程的状态可以通过Thread类的getState()方法获取，包括新建（NEW）、就绪（RUNNABLE）、阻塞（BLOCKED）、等待（WAITING）、超时等待（TIMED_WAITING）和终止（TERMINATED）六种状态。线程的优先级可以通过Thread类的getPriority()方法获取，也可以通过setPriority()方法进行设置。

下面，我会详细地介绍这四种线程协作的方式，并给出一些实际的使用示例。

一、线程间的通信

线程间的通信是实现线程协作的基础。在Java中，我们可以通过Object类的wait()、notify()和notifyAll()方法来实现线程间的通信。

wait()方法：该方法会让当前线程进入等待状态，并释放持有的所有对象锁。当其他线程调用该对象的notify()方法或notifyAll()方法时，该线程会被唤醒并重新尝试获取对象锁。如果调用wait()方法的线程不持有对象锁，就会抛出IllegalMonitorStateException异常。
notify()方法：该方法会随机唤醒一个在此对象监视器上等待的线程。如果没有线程在等待，调用此方法不会有任何效果。
notifyAll()方法：该方法会唤醒所有在此对象监视器上等待的线程。

这三个方法都必须在同步代码块或同步方法中调用，否则会抛出IllegalMonitorStateException异常。下面是一个使用wait()和notify()方法实现两个线程间通信的示例：

public class ThreadCommunicationExample {
    private static Object lock = new Object();
    public static void main(String[] args) {
        Thread thread1 = new Thread(() -> {
            synchronized (lock) {
                try {
                    System.out.println("Thread 1: Waiting for lock");
                    lock.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("Thread 1: Acquired lock and executing");
            }
        });
        Thread thread2 = new Thread(() -> {
            synchronized (lock) {
                System.out.println("Thread 2: Acquired lock and executing");
                lock.notify();
            }
        });
        thread1.start();
        thread2.start();
    }
}

在这个示例中，Thread 1首先获取到lock对象的锁，然后调用lock对象的wait()方法释放锁并进入等待状态。当Thread 2获取到lock对象的锁并调用lock对象的notify()方法后，Thread 1被唤醒并重新尝试获取锁。

二、同步控制

在多线程环境下，当多个线程需要共享同一资源时，就需要进行同步控制，避免出现数据一致性问题。在Java中，我们可以通过synchronized关键字或Lock锁来实现同步控制。

synchronized关键字：synchronized关键字可以用于方法或代码块。当一个线程进入synchronized修饰的方法或代码块时，其他线程就无法访问这段代码，直到该线程退出synchronized修饰的方法或代码块。
Lock锁：Java提供的Lock锁提供了更灵活的线程同步模型。我们可以在任何地方释放锁，而不像synchronized关键字那样，只能在方法或代码块结束时释放锁。

下面是一个使用synchronized关键字和Lock锁实现线程同步的示例：

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class ThreadSynchronizationExample {
    private static int counter = 0;
    private static Lock lock = new ReentrantLock();
    public static void main(String[] args) throws InterruptedException {
        Thread thread1 = new Thread(() -> incrementCounter());
        Thread thread2 = new Thread(() -> incrementCounter());
        thread1.start();
        thread2.start();
        thread1.join();
        thread2.join();
        System.out.println("Counter = " + counter);
    }
    private static void incrementCounter() {
        lock.lock();
        try {
            for (int i = 0; i < 100000; i++) {
                counter++;
            }
        } finally {
            lock.unlock();
        }
    }
}

在这个示例中，我们使用Lock锁来保护counter变量。当一个线程获取到lock对象的锁并执行incrementCounter()方法时，其他线程就无法执行incrementCounter()方法，直到该线程释放锁。

三、线程调度策略

在多线程环境下，线程的调度策略是由操作系统决定的，但Java提供了设置线程优先级的方法。线程的优先级可以通过Thread类的setPriority()方法进行设置，该方法接受一个介于1（Thread.MIN_PRIORITY）到10（Thread.MAX_PRIORITY）之间的整数。

高优先级的线程会优先获得CPU的执行权，但这并不意味着低优先级的线程就无法获得CPU的执行权，只是获得的机会较少。下面是一个设置线程优先级的示例：

public class ThreadPriorityExample {
    public static void main(String[] args) {
        Thread thread1 = new Thread(() -> {
            for (int i = 0; i < 1000000; i++) {
                System.out.println("Thread 1: " + i);
            }
        });
        Thread thread2 = new Thread(() -> {
            for (int i = 0; i < 1000000; i++) {
                System.out.println("Thread 2: " + i);
            }
        });
        thread1.setPriority(Thread.MIN_PRIORITY);
        thread2.setPriority(Thread.MAX_PRIORITY);
        thread1.start();
        thread2.start();
    }
}

在这个示例中，我们设置了thread1的优先级为最低，thread2的优先级为最高。在执行时，你会发现thread2的输出比thread1的输出要多，这是因为thread2的优先级更高，所以获得CPU执行权的机会更多。

四、线程的状态和优先级

线程的状态和优先级也是影响线程协作的重要因素。线程的状态可以通过Thread类的getState()方法获取，包括新建（NEW）、就绪（RUNNABLE）、阻塞（BLOCKED）、等待（WAITING）、超时等待（TIMED_WAITING）和终止（TERMINATED）六种状态。

线程的优先级可以通过Thread类的getPriority()方法获取，也可以通过setPriority()方法进行设置。线程的优先级是一个介于1（Thread.MIN_PRIORITY）到10（Thread.MAX_PRIORITY）之间的整数，高优先级的线程会优先获得CPU的执行权。

下面是一个获取线程状态和优先级的示例：

public class ThreadStateAndPriorityExample {
    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(() -> {
            for (int i = 0; i < 1000000; i++) {
                System.out.println("Thread: " + i);
            }
        });
        System.out.println("Thread state: " + thread.getState());
        System.out.println("Thread priority: " + thread.getPriority());
        thread.start();
        Thread.sleep(1000);
        System.out.println("Thread state: " + thread.getState());
        System.out.println("Thread priority: " + thread.getPriority());
    }
}