在已经运行的android线程上调用函数？ 写在侦听蓝牙的同一线程上？

Question

The following problem is about reading and writing on the same thread that is used for handling a bluetooth socket in android.

I don't understand how it is possible to call the write function on a thread that is already running. The code works perfectly, but I cannot understand why.

In the following code from the android dev website, thread seems to keep listening in an infinite loop. Furthermore the socket.getInputStream() function is a blocking call meaning that it waits until there is data to read before that line executes. I don't understand then how, when the ConnectedThread.write() function is called, that the function is called instantly. If the thread is already busy listening for incoming data, how can it also write() ? Shouldn't it complete the run() function before it can write() ? And the way the code is written it doesn't seem like the run() function will ever finish executing because it is in an infinite loop.

// Code
public class MyBluetoothService {
    private static final String TAG = "MY_APP_DEBUG_TAG";
    private Handler mHandler; // handler that gets info from Bluetooth service

    // Defines several constants used when transmitting messages between the
    // service and the UI.
    private interface MessageConstants {
        public static final int MESSAGE_READ = 0;
        public static final int MESSAGE_WRITE = 1;
        public static final int MESSAGE_TOAST = 2;

        // ... (Add other message types here as needed.)
    }

    private class ConnectedThread extends Thread {
        private final BluetoothSocket mmSocket;
        private final InputStream mmInStream;
        private final OutputStream mmOutStream;
        private byte[] mmBuffer; // mmBuffer store for the stream

        public ConnectedThread(BluetoothSocket socket) {
            mmSocket = socket;
            InputStream tmpIn = null;
            OutputStream tmpOut = null;

            // Get the input and output streams; using temp objects because
            // member streams are final.
            try {
                tmpIn = socket.getInputStream();
            } catch (IOException e) {
                Log.e(TAG, "Error occurred when creating input stream", e);
            }
            try {
                tmpOut = socket.getOutputStream();
            } catch (IOException e) {
                Log.e(TAG, "Error occurred when creating output stream", e);
            }

            mmInStream = tmpIn;
            mmOutStream = tmpOut;
        }

        public void run() {
            mmBuffer = new byte[1024];
            int numBytes; // bytes returned from read()

            // Keep listening to the InputStream until an exception occurs.
            while (true) {
                try {
                    // Read from the InputStream.
                    numBytes = mmInStream.read(mmBuffer);
                    // Send the obtained bytes to the UI activity.
                    Message readMsg = mHandler.obtainMessage(
                            MessageConstants.MESSAGE_READ, numBytes, -1,
                            mmBuffer);
                    readMsg.sendToTarget();
                } catch (IOException e) {
                    Log.d(TAG, "Input stream was disconnected", e);
                    break;
                }
            }
        }

        // Call this from the main activity to send data to the remote device.
        public void write(byte[] bytes) {
            try {
                mmOutStream.write(bytes);

                // Share the sent message with the UI activity.
                Message writtenMsg = mHandler.obtainMessage(
                        MessageConstants.MESSAGE_WRITE, -1, -1, mmBuffer);
                writtenMsg.sendToTarget();
            } catch (IOException e) {
                Log.e(TAG, "Error occurred when sending data", e);

                // Send a failure message back to the activity.
                Message writeErrorMsg =
                        mHandler.obtainMessage(MessageConstants.MESSAGE_TOAST);
                Bundle bundle = new Bundle();
                bundle.putString("toast",
                        "Couldn't send data to the other device");
                writeErrorMsg.setData(bundle);
                mHandler.sendMessage(writeErrorMsg);
            }
        }

        // Call this method from the main activity to shut down the connection.
        public void cancel() {
            try {
                mmSocket.close();
            } catch (IOException e) {
                Log.e(TAG, "Could not close the connect socket", e);
            }
        }
    }
}

The code works as expected, but I don't understand why.

Answer 1

There seems to be a little confusion around some concepts. I'll try to do some clarification.

the socket.getInputStream() function is a blocking call

It's just a getter, it doesn't block. socket.getInputStream().read() is the blocker one.

I don't understand then how, when the ConnectedThread.write() function is called, that the function is called instantly.

write() is probably called by another thread. In this case, think of ConnectedThread as a common object like any other.

EDIT

Here's a code example that illustrates the new thread running alongside the thread already present.

// At this point you have one thread (there may be more,
// but suppose it's only one).
// The thread is executing the code below.

ConnectedThread connectedThread = new ConnectedThread(socket);
connectedThread.start();

// Now you have two threads running simultaneously.
// The new thread is doing whatever the run() method defined in
// ConnectedThread,
// that is that infinite loop with read() calls.
// But this thread goes on.

connectedThread.write();

// The write() call above is executed in this thread,
// which has nothing to do with
// the run() defined in ConnectedThread.

Answer 2

I don't understand how it is possible to call the write function on a thread that is already running...

You aren't "calling it on a thread ." You are calling it on a Thread . A Thread is an object in your program with methods that your code can call in exactly the same way that it calls the methods of any other object. The Thread class has one very special instance method, t.start() which creates a new operating system thread , but otherwise, it's just like any other Java class.

The t.start() method creates a new thread . The new thread calls your Thread object's run() method, and then after run() returns or throws an exception, the new thread dies.

You haven't showed us the other code that calls write() , but it's probably just as @nandsito said: Some other thread in your code is calling that method on your Thread instance.