如何从线程向其他类传数据及在MainActivity中从线程t获取tdate

咱们先解决你提到的第二个具体问题：在MainActivity中从线程t获取tdate相关的数据。从你的代码片段来看，线程t里是每隔1秒获取当前时间戳并更新TextView，要把这个时间戳拿到MainActivity的其他地方用，可以这么做：

步骤1：在MainActivity中定义成员变量存储数据 #

首先在MainActivity类里声明一个线程安全的成员变量，用来保存线程中获取的时间戳：

// 用volatile保证多线程下的可见性
private volatile long currentTimestamp;

步骤2：在线程中更新这个成员变量 #

修改你原来的线程代码，在更新TextView的同时，把时间戳赋值给这个成员变量：

Thread t = new Thread() {
    @Override
    public void run() {
        try {
            while (!isInterrupted()) {
                Thread.sleep(1000);
                final long date = System.currentTimeMillis(); // 先拿到当前时间戳
                runOnUiThread(new Runnable() {
                    @Override
                    public void run() {
                        TextView tdate = (TextView) findViewById(R.id.date);
                        tdate.setText(String.valueOf(date)); // 更新UI
                        currentTimestamp = date; // 把时间戳同步到成员变量
                    }
                });
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
};

这样一来，MainActivity里的其他方法（比如registerUser()）就可以直接访问currentTimestamp变量，拿到线程t传递过来的时间数据了。

接下来解决第一个通用问题：如何从线程向另一个类传递数据？这里给你三种常用的方案：

方案1：使用回调接口（最通用的方式） #

定义一个回调接口，让接收数据的类实现这个接口，线程持有接口实例，当数据准备好时调用接口方法传递数据：

// 第一步：定义回调接口
public interface DataCallback {
    void onDataReceived(long data);
}

// 第二步：接收数据的类实现接口
public class DataReceiver implements DataCallback {
    @Override
    public void onDataReceived(long data) {
        // 在这里处理线程传递过来的数据
        System.out.println("收到线程传来的时间戳：" + data);
    }
}

// 第三步：线程中调用回调传递数据
// 在MainActivity中使用示例：
DataReceiver receiver = new DataReceiver();
Thread t = new Thread() {
    @Override
    public void run() {
        long date = System.currentTimeMillis();
        // 调用回调方法传递数据
        if (receiver != null) {
            receiver.onDataReceived(date);
        }
    }
};
t.start();

方案2：使用Android的Handler（Android环境专属） #

如果是Android开发，你可以用Handler来跨线程传递消息，接收数据的类持有Handler实例，线程通过sendMessage把数据发过去：

// 接收数据的类
public class AnotherClass {
    // 初始化Handler，绑定主线程Looper（如果需要更新UI的话）
    private Handler dataHandler = new Handler(Looper.getMainLooper()) {
        @Override
        public void handleMessage(Message msg) {
            super.handleMessage(msg);
            // 从消息中取出数据
            long timestamp = (long) msg.obj;
            // 处理数据
        }
    };

    public Handler getHandler() {
        return dataHandler;
    }
}

// 线程中发送数据
AnotherClass anotherClass = new AnotherClass();
Thread t = new Thread() {
    @Override
    public void run() {
        long date = System.currentTimeMillis();
        Message msg = Message.obtain();
        msg.obj = date; // 把数据放到消息里
        anotherClass.getHandler().sendMessage(msg);
    }
};
t.start();

方案3：使用共享变量 #

如果两个类都能访问同一个共享对象，线程更新这个对象里的变量，接收类读取即可。注意要保证线程安全：

// 定义一个共享数据类
public class SharedTimestamp {
    // volatile保证多线程下变量可见
    private volatile long timestamp;

    public long getTimestamp() {
        return timestamp;
    }

    public void setTimestamp(long timestamp) {
        this.timestamp = timestamp;
    }
}

// 线程中更新数据
SharedTimestamp sharedData = new SharedTimestamp();
Thread t = new Thread() {
    @Override
    public void run() {
        sharedData.setTimestamp(System.currentTimeMillis());
    }
};
t.start();

// 另一个类中读取数据
public class DataReader {
    private SharedTimestamp sharedData;

    public DataReader(SharedTimestamp sharedData) {
        this.sharedData = sharedData;
    }

    public void readData() {
        long data = sharedData.getTimestamp();
        // 处理数据
    }
}

内容的提问来源于stack exchange，提问作者kara