Java实现父子线程共享数据的几种方法_Java

父子线程之间共享数据主要有以下几种方式：

1. 共享变量

父线程和子线程可以通过共享变量来交换数据。这些变量需要在父线程中定义并传递给子线程，以确保子线程可以访问这些变量。需要注意的是，共享变量在多线程环境中可能需要同步，以避免数据竞争和不一致性。

public class sharedvariableexample {
    private static int shareddata = 0;

    public static void main(string[] args) {
        thread parentthread = new thread(() -> {
            // 修改共享数据
            shareddata = 10;
            system.out.println("parent thread set shareddata to " + shareddata);

            thread childthread = new thread(() -> {
                // 访问共享数据
                system.out.println("child thread sees shareddata as " + shareddata);
            });

            childthread.start();
        });

        parentthread.start();
    }
}

2. 使用 threadlocal

threadlocal 允许每个线程拥有其独立的局部变量副本。虽然 threadlocal 本身不直接用于父子线程的数据共享，但它可以确保每个线程有自己的数据副本而不会被其他线程干扰。为了实现父子线程间的数据共享，可以在父线程中设置数据，并在子线程中获取这些数据。

public class threadlocalexample {
    private static threadlocal<integer> threadlocaldata = threadlocal.withinitial(() -> 0);

    public static void main(string[] args) {
        threadlocaldata.set(10);

        thread childthread = new thread(() -> {
            integer data = threadlocaldata.get();
            system.out.println("child thread sees threadlocaldata as " + data);
        });

        childthread.start();
    }
}

3. 使用同步机制

当多个线程需要安全地访问共享数据时，可以使用同步机制，如 synchronized 关键字或显式的锁（例如 reentrantlock）。这样可以确保在任何时间只有一个线程可以访问共享数据，从而避免数据竞争和不一致性问题。

public class synchronizedexample {
    private static int shareddata = 0;

    public static void main(string[] args) {
        object lock = new object();

        thread parentthread = new thread(() -> {
            synchronized (lock) {
                shareddata = 10;
                system.out.println("parent thread set shareddata to " + shareddata);

                thread childthread = new thread(() -> {
                    synchronized (lock) {
                        system.out.println("child thread sees shareddata as " + shareddata);
                    }
                });

                childthread.start();
            }
        });

        parentthread.start();
    }
}

4. 使用线程安全的数据结构

java 提供了一些线程安全的数据结构，如 concurrenthashmap、copyonwritearraylist 等。这些数据结构可以用于在多个线程之间共享数据，并自动处理同步问题。

import java.util.concurrent.concurrenthashmap;

public class concurrenthashmapexample {
    private static concurrenthashmap<string, integer> map = new concurrenthashmap<>();

    public static void main(string[] args) {
        map.put("sharedkey", 10);

        thread parentthread = new thread(() -> {
            system.out.println("parent thread set map value to " + map.get("sharedkey"));

            thread childthread = new thread(() -> {
                system.out.println("child thread sees map value as " + map.get("sharedkey"));
            });

            childthread.start();
        });

        parentthread.start();
    }
}

5. 使用 executorservice

如果父线程和子线程是通过 executorservice 来管理的，可以通过 callable 和 future 对象来传递数据。callable 可以返回结果，父线程可以通过 future 获取子线程的计算结果。

import java.util.concurrent.callable;
import java.util.concurrent.executionexception;
import java.util.concurrent.executorservice;
import java.util.concurrent.executors;
import java.util.concurrent.future;

public class executorserviceexample {
    public static void main(string[] args) throws interruptedexception, executionexception {
        executorservice executor = executors.newfixedthreadpool(2);

        future<integer> future = executor.submit(() -> {
            return 10; // 子线程返回数据
        });

        integer result = future.get(); // 获取子线程返回的数据
        system.out.println("main thread received result: " + result);

        executor.shutdown();
    }
}