偶尔从套接字读取数据而不关闭它

时间:2013-11-11 22:56:01

标签: java android sockets stream

信息

我正在尝试找到一种方法,以设定的间隔从传入的套接字流中读取数据块,但忽略其余数据而不关闭读取之间的连接。我想知道是否有人有任何建议?

我问的原因是我已经获得了一个网络连接的模数转换器(ADC),我想编写一个简单的示波器应用程序。

基本上,一旦我连接到ADC并发送一些初始化命令,它就需要几分钟来稳定,此时它开始在字节流中丢弃测量值。

我想每隔几秒钟读取1MB的数据并丢弃其余的数据,如果我不丢弃其余部分,ADC将缓冲512kB的读数,然后暂停,这样任何后续读取都将是旧数据。如果我关闭读取ADC之间的连接,则需要一段时间才能再次发送数据。

问题

我写了一个简单的Python脚本作为测试,在这里我使用了一个连续运行的线程,它将字节读取到未使用的缓冲区,如果设置了一个标志,这似乎工作正常。

当我在Android上尝试这个时,我遇到了问题,因为似乎只有部分数据被丢弃,如果更新间隔太长,ADC仍会暂停。

我在哪里弄错了?我的第一个猜测是同步,因为我不确定它是否按预期工作(参见ThreadBucket类)。我不得不承认花了很多时间玩这个,尝试不同的同步排列,缓冲区大小,BufferedInputStream和NIO,但没有运气。

对此的任何输入都将不胜感激,我不确定使用这样的线程是否是正确的Java方式。

代码

Reader类设置线程,连接到ADC,根据请求读取数据,并在两者之间激活位桶线程(为了清楚起见,我省略了初始化和关闭)。

class Reader {

    private static final int READ_SIZE = 1024 * 1024;

    private String mServer;
    private int mPort;
    private Socket mSocket;
    private InputStream mIn;
    private ThreadBucket mThreadBucket;
    private byte[] mData = new byte[1];
    private final byte[] mBuffer = new byte[READ_SIZE];

    Reader(String server, int port) {
        mServer = server;
        mPort = port;
    }

    void setup() throws IOException {

        mSocket = new Socket(mServer, mPort);
        mIn = mSocket.getInputStream();
        mThreadBucket = new ThreadBucket(mIn);
        mThreadBucket.start();

        // Omitted: Send a few init commands a look at the response

        // Start discarding data
        mThreadBucket.bucket(true);
    }

    private int readRaw(int samples) throws IOException {

        int current = 0;

        // Probably fixed size but may change
        if (mData.length != samples)
            mData = new byte[samples];

        // Stop discarding data
        mThreadBucket.bucket(false);
        // Read in number of samples to mData
        while (current < samples) {
            int len = mIn.read(mBuffer);
            if (current > samples)
                current = samples;
            if (current + len > samples)
                len = samples - current;
            System.arraycopy(mBuffer, 0, mData, current, len);
            current += mBuffer.length;
        }
        // Discard data again until the next read
        mThreadBucket.bucket(true);

        return current;
    }
}

如果ThreadBucket为真,则mBucket类会继续运行数据到位桶。

同步意味着阻止任何一个线程读取数据而另一个是。

public class ThreadBucket extends Thread {

    private static final int BUFFER_SIZE = 1024;

    private final InputStream mIn;
    private Boolean mBucket = false;
    private boolean mCancel = false;

    public ThreadBucket(final InputStream in) throws IOException {

        mIn = in;
    }

    @Override
    public void run() {

        while (!mCancel && !Thread.currentThread().isInterrupted()) {
            synchronized (this) {
                if (mBucket)
                    try {
                        mIn.skip(BUFFER_SIZE);
                    } catch (final IOException e) {
                        break;
                    }
                }
            }
        }

    public synchronized void bucket(final boolean on) {

        mBucket = on;
    }

    public void cancel() {

        mCancel = true;
    }
}

谢谢。

1 个答案:

答案 0 :(得分:0)

您需要连续阅读,周期,尽可能快地编码,然后分别管理您对数据执行的操作。不要混淆两者。