Java Android截击未来请求'；s正在超时

我试图构建一个“Random Article”对象，这意味着一篇来自Wikipedia的随机解析文章。我需要使本文同步的过程，以便控制运行代码的顺序

这是我的班级：

import android.content.Context;
import android.os.AsyncTask;
import android.os.Handler;
import android.util.Log;
import android.widget.Toast;

import com.android.volley.Request;
import com.android.volley.RequestQueue;
import com.android.volley.toolbox.JsonObjectRequest;
import com.android.volley.toolbox.RequestFuture;
import com.android.volley.toolbox.Volley;
import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
import org.json.JSONObject;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

import static android.content.ContentValues.TAG;

public class RandomArticle {

    private RequestQueue requestQueue;
    private Gson gson;
    private String linkForRandomArticle="https://he.wikipedia.org/w/api.php?%20format=json&action=query&prop=extracts&exsentences=2&exintro=&explaintext=&generator=random&grnnamespace=0";
    private String title, firstParagraph, id, link;
    private JSONObject result;
    static Context context;

    public RandomArticle(final Context context){
        requestQueue = Volley.newRequestQueue(context);
        GsonBuilder gsonBuilder = new GsonBuilder();
        gson = gsonBuilder.create();

         new Handler().post(new Runnable() {
    public void run() {
        ThreadA threadA = new ThreadA();
        try{
            try {

                try{
                    result=threadA.execute().get(10, TimeUnit.SECONDS);
                }
                catch (TimeoutException e){
                    Log.e(TAG,Log.getStackTraceString(e));
                }
            }
            catch (InterruptedException e){
                Log.e(TAG,Log.getStackTraceString(e));
            }
        }
        catch (ExecutionException e) {
            Log.e(TAG,Log.getStackTraceString(e));
        }

    }
});


    protected class ThreadA extends AsyncTask<Void, Void, JSONObject> {

        public ThreadA() {
        }

        @Override
        protected JSONObject doInBackground(Void... params) {
            RequestFuture<JSONObject> future = RequestFuture.newFuture();
            final JsonObjectRequest request = new JsonObjectRequest(Request.Method.POST,
                    linkForRandomArticle,
                    new JSONObject(),
                    future, future);

            requestQueue.add(request);

            try {
                try {
                    int REQUEST_TIMEOUT = 10;
                    try{
                        return future.get(REQUEST_TIMEOUT, TimeUnit.SECONDS);
                    }
                    catch (TimeoutException e){
                        Log.e(TAG,Log.getStackTraceString(e));

                    }

                } catch (ExecutionException e) {
                    Log.e(TAG,Log.getStackTraceString(e));
                }
            }
            catch (InterruptedException e){
                Log.e(TAG,Log.getStackTraceString(e));
            }

            return null;
        }
    }

}

它只是超时，然后结果变为空

这是我得到的错误：

05-05 15:55:39.912 25444-25519/com.example.barda.wikirace E/ContentValues:
java.util.concurrent.TimeoutException
at com.android.volley.toolbox.RequestFuture.doGet(RequestFuture.java:121)
at com.android.volley.toolbox.RequestFuture.get(RequestFuture.java:97)
at com.example.barda.wikirace.RandomArticle$Thread.doInBackground(RandomArticle.java:73)
at com.example.barda.wikirace.RandomArticle$Thread.doInBackground(RandomArticle.java:58)
at android.os.AsyncTask$2.call(AsyncTask.java:305)
at java.util.concurrent.FutureTask.run(FutureTask.java:237)
at android.os.AsyncTask$SerialExecutor$1.run(AsyncTask.java:243)
at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1133)
at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:607)
at java.lang.Thread.run(Thread.java:761)

我已经在网上搜索了很多，以便找到与我需要的东西相似的东西。这个答案是最好的匹配：

我已经尝试过这个答案，并在我的代码中实现它

我想知道如何修理它。谢谢

由于

get（）

会一直阻塞直到出现结果，因此考虑到您的代码有两种可能性：

JsonObjectRequest

超时或失败，出现异常。如果不查看日志输出，就无法确定是否发生了这种情况。此外，您没有记录该故障的原因，因此即使日志中包含“Failed”一行，确切原因仍不清楚

结果是

null

，但是似乎只有在解析过程中发生错误时才会发生这种情况，这会导致抛出

ExecutionException

---

改进日志记录是一个好主意，这样您就可以确切地知道故障发生的位置和原因。

问题在于使用以下方法：

  new Handler().post(new Runnable() {
        public void run() {
            ThreadA threadA = new ThreadA();
            try{
                try {

                    try{
                        result=threadA.execute().get(10, TimeUnit.SECONDS);
                    }
                    catch (TimeoutException e){
                        Log.e(TAG,Log.getStackTraceString(e));
                    }
                }
                catch (InterruptedException e){
                    Log.e(TAG,Log.getStackTraceString(e));
                }
            }
            catch (ExecutionException e) {
                Log.e(TAG,Log.getStackTraceString(e));
            }

        }
    });

与此相反：

 Thread t = new Thread(new Runnable() {
            @Override
            public void run() {
                Log.d("RT", "Thread t Begins");
                ThreadA threadA = new ThreadA();
                try{
                    try {

                        try{
                            result=threadA.execute().get(10, TimeUnit.SECONDS);
                        }
                        catch (TimeoutException e){
                            Log.e(TAG,Log.getStackTraceString(e));
                        }
                    }
                    catch (InterruptedException e){
                        Log.e(TAG,Log.getStackTraceString(e));
                    }
                }
                catch (ExecutionException e) {
                    Log.e(TAG,Log.getStackTraceString(e));
                }

            }
        });
        t.start();

---

它可能是新的线程

使用下面刚刚更改的代码片段，我得到了响应

公共类随机化文章{

private RequestQueue requestQueue;
private Gson gson;
private String linkForRandomArticle = "https://he.wikipedia.org/w/api.php?%20format=json&action=query&prop=extracts&exsentences=2&exintro=&explaintext=&generator=random&grnnamespace=0";
private String title, firstParagraph, id, link;
private JSONObject result;
static Context context;

public RandomArticle(final Context context) {
   this.context = context;
}

 public JSONObject getRamdomArticle(){
     requestQueue = Volley.newRequestQueue(context);
     GsonBuilder gsonBuilder = new GsonBuilder();
     gson = gsonBuilder.create();
     ThreadA threadA = new ThreadA();
     try {
         try {

             try {
                 result = threadA.execute().get(100, TimeUnit.SECONDS);
                 assert result != null;
             } catch (TimeoutException e) {
                 Log.e(TAG, Log.getStackTraceString(e));
             }
         } catch (InterruptedException e) {
             Log.e(TAG, Log.getStackTraceString(e));
         }
     } catch (ExecutionException e) {
         Log.e(TAG, Log.getStackTraceString(e));
     }
     return result;
 }



class ThreadA extends AsyncTask<Void, Void, JSONObject> {

    public ThreadA() {
    }

    @Override
    protected JSONObject doInBackground(Void... params) {
        RequestFuture<JSONObject> future = RequestFuture.newFuture();
        final JsonObjectRequest request = new JsonObjectRequest(Request.Method.POST,
                linkForRandomArticle,
                new JSONObject(),
                future, future);

        requestQueue.add(request);

        try {
            try {
                int REQUEST_TIMEOUT = 100;
                try {
                    return future.get(REQUEST_TIMEOUT, TimeUnit.SECONDS);
                } catch (TimeoutException e) {
                    Log.e(TAG, Log.getStackTraceString(e));

                }

            } catch (ExecutionException e) {
                Log.e(TAG, Log.getStackTraceString(e));
            }
        } catch (InterruptedException e) {
            Log.e(TAG, Log.getStackTraceString(e));
        }

        return null;
    }
}

私有请求队列请求队列；
私人Gson；
私有字符串linkForRandomArticle=”https://he.wikipedia.org/w/api.php?%20format=json&action=query&prop=extracts&exsentences=2&exintro=&explaintext=&generator=random&grnnamespace=0";
私有字符串标题，第一段，id，链接；
私有JSONObject结果；
静态语境；
公开文章（最终上下文）{
this.context=上下文；
}
公共JSONObject getRamdomArticle（）{
requestQueue=Volley.newRequestQueue（上下文）；
GsonBuilder GsonBuilder=新的GsonBuilder（）；
gson=gsonBuilder.create（）；
ThreadA ThreadA=新ThreadA（）；
试一试{
试一试{
试一试{
结果=threadA.execute（）.get（100，TimeUnit.SECONDS）；
断言结果！=null；
}捕获（超时异常e）{
Log.e（TAG，Log.getStackTraceString（e））；
}
}捕捉（中断异常e）{
Log.e（TAG，Log.getStackTraceString（e））；
}
}捕获（执行例外）{
Log.e（TAG，Log.getStackTraceString（e））；
}
返回结果；
}
类ThreadA扩展异步任务{
公共图书馆a（{
}
@凌驾
受保护的JSONObject doInBackground（无效…参数）{
RequestFuture=RequestFuture.newFuture（）；
final JsonObjectRequest=新JsonObjectRequest（request.Method.POST，
链接文章，
新建JSONObject（），
未来,未来),；
添加（请求）；
试一试{
试一试{
int请求_超时=100；
试一试{
返回future.get（请求超时，时间单位为秒）；
}捕获（超时异常e）{
Log.e（TAG，Log.getStackTraceString（e））；
}
}捕获（执行例外）{
Log.e（TAG，Log.getStackTraceString（e））；
}
}捕捉（中断异常e）{
Log.e（TAG，Log.getStackTraceString（e））；
}
返回null；
}
}

---

}

（new Thread（））.execute（）

您没有收到任何编译错误吗？没有。代码工作正常。这个Thread类是

java.lang.Thread

还是来自某个第三方库的其他线程类？您可以显示您的导入语句吗？我已经将它们添加到post.Static context和Volley中了？这听起来像是内存泄漏，也很痛苦。我总是想知道人们什么时候不使用改型。使用

.printStackTrace（）

，特定的异常有一个导致它的异常，以便知道需要打印整个跟踪的原因。

private RequestQueue requestQueue;
private Gson gson;
private String linkForRandomArticle = "https://he.wikipedia.org/w/api.php?%20format=json&action=query&prop=extracts&exsentences=2&exintro=&explaintext=&generator=random&grnnamespace=0";
private String title, firstParagraph, id, link;
private JSONObject result;
static Context context;

public RandomArticle(final Context context) {
   this.context = context;
}

 public JSONObject getRamdomArticle(){
     requestQueue = Volley.newRequestQueue(context);
     GsonBuilder gsonBuilder = new GsonBuilder();
     gson = gsonBuilder.create();
     ThreadA threadA = new ThreadA();
     try {
         try {

             try {
                 result = threadA.execute().get(100, TimeUnit.SECONDS);
                 assert result != null;
             } catch (TimeoutException e) {
                 Log.e(TAG, Log.getStackTraceString(e));
             }
         } catch (InterruptedException e) {
             Log.e(TAG, Log.getStackTraceString(e));
         }
     } catch (ExecutionException e) {
         Log.e(TAG, Log.getStackTraceString(e));
     }
     return result;
 }



class ThreadA extends AsyncTask<Void, Void, JSONObject> {

    public ThreadA() {
    }

    @Override
    protected JSONObject doInBackground(Void... params) {
        RequestFuture<JSONObject> future = RequestFuture.newFuture();
        final JsonObjectRequest request = new JsonObjectRequest(Request.Method.POST,
                linkForRandomArticle,
                new JSONObject(),
                future, future);

        requestQueue.add(request);

        try {
            try {
                int REQUEST_TIMEOUT = 100;
                try {
                    return future.get(REQUEST_TIMEOUT, TimeUnit.SECONDS);
                } catch (TimeoutException e) {
                    Log.e(TAG, Log.getStackTraceString(e));

                }

            } catch (ExecutionException e) {
                Log.e(TAG, Log.getStackTraceString(e));
            }
        } catch (InterruptedException e) {
            Log.e(TAG, Log.getStackTraceString(e));
        }

        return null;
    }
}