Java线程之间的共享与协作详解

本文主要介绍Java线程之间的共享与协作，包括线程之间共享数据的方法、线程之间如何协作（如线程同步和线程通信），以及一些示例说明。

线程之间共享数据的方法

在Java中，线程之间共享数据的方法有以下几种：

公共静态变量

公共静态变量是一个非常简单的方式来实现线程之间的共享数据，例如以下代码：

public class SharedDataExample {
    public static int sharedData = 0;
}

public class MyThread implements Runnable {
    @Override
    public void run() {
        SharedDataExample.sharedData++;
        // ...
    }
}

线程局部变量

线程局部变量是一种只被一个线程访问的变量，并不共享给其他线程。每个线程都拥有一个自己的本地存储，存储着自己的线程局部变量值，例如以下代码：

public class MyThread implements Runnable {
    private ThreadLocal<Integer> threadLocal = new ThreadLocal<>();

    @Override
    public void run() {
        threadLocal.set((int)(Math.random() * 1000));
        // ...
    }
}

Java 线程间公共对象

Java中的线程间公共对象（Shared Objects）是一种通过Java中的synchronized关键字进行同步的对象，例如一个锁：

public class SharedDataExample {
    private int data = 0;
    private final Object lock = new Object();

    public void addData(int value) {
        synchronized (lock) {
            data += value;
        }
    }

    // ...
}

线程之间的协作

线程同步

在多线程编程中，线程同步（Synchronization）是一种协作机制，可确保每个线程在访问共享数据时具有独占权或排他性，而不会与其他线程发生冲突。Java中的线程同步是通过synchronized关键字实现的，例如以下代码：

public class SharedDataExample {
    private int data = 0;

    public synchronized void addData(int value) {
        data += value;
    }

    // ...
}

线程通信

线程通信（Inter-thread Communication）是一种协作机制，可确保在多个线程之间传递消息。Java中的线程通信主要有两种方式：wait() 和 notify()，即等待线程和通知线程。以下是一个示例：

public class SharedDataExample {
    private int data = 0;

    public synchronized void addData(int value) {
        data += value;
        notify();
    }

    public synchronized void waitForMoreData() throws InterruptedException {
        while (data < 1000) {
            wait();
        }
    }
}

示例说明

以下是两个具体的示例，说明Java中线程之间的共享与协作：

示例一：线程池

线程池是一个允许开发人员更好地控制多线程执行的机制。线程池通过复用线程对象，避免了创建线程的开销，而同一时刻只有一定数量的线程在执行任务。Java中的线程池使用Executor框架实现，以下是一个示例：

ExecutorService executorService = Executors.newFixedThreadPool(2);
executorService.submit(new Runnable() {
    @Override
    public void run() {
        // ...
    }
});
executorService.submit(new Runnable() {
    @Override
    public void run() {
        // ...
    }
});
executorService.shutdown();

示例二：生产者和消费者

生产者和消费者是一个常见的多线程问题，其中一个或多个生产者生成数据，一个或多个消费者则消费这些数据。Java中经典的解决方案是使用wait() 和 notify() 方法实现线程间通信。以下是一个示例：

public class ProducerConsumerExample {
    private List<Integer> dataList = new ArrayList<>();
    private final int MAX_SIZE = 5;

    public synchronized void produce() throws InterruptedException {
        while (true) {
            while (dataList.size() >= MAX_SIZE) {
                wait();
            }
            int value = (int)(Math.random() * 1000);
            dataList.add(value);
            System.out.println("Producer produced: " + value);
            notify();
            Thread.sleep((int)(Math.random() * 1000));
        }
    }

    public synchronized void consume() throws InterruptedException {
        while (true) {
            while (dataList.isEmpty()) {
                wait();
            }
            int value = dataList.remove(dataList.size() - 1);
            System.out.println("Consumer consumed: " + value);
            notify();
            Thread.sleep((int)(Math.random() * 1000));
        }
    }
}

以上就是Java线程之间的共享与协作详解，希望对您有所帮助。

阅读剩余 70%