下面的异常是什么意思;我该怎么解决呢?
这是代码:
Toast toast = Toast.makeText(mContext, "Something", Toast.LENGTH_SHORT);
这是例外:
java.lang.RuntimeException: Can't create handler inside thread that has not called Looper.prepare()
at android.os.Handler.<init>(Handler.java:121)
at android.widget.Toast.<init>(Toast.java:68)
at android.widget.Toast.makeText(Toast.java:231)
你从工作线程调用它。您需要在主线程中调用Toast.makeText()(以及处理UI的大多数其他函数)。例如，您可以使用处理程序。
在文档中查找与UI线程通信。简而言之:
// Set this up in the UI thread.
mHandler = new Handler(Looper.getMainLooper()) {
@Override
public void handleMessage(Message message) {
// This is where you do your work in the UI thread.
// Your worker tells you in the message what to do.
}
};
void workerThread() {
// And this is how you call it from the worker thread:
Message message = mHandler.obtainMessage(command, parameter);
message.sendToTarget();
}
其他选项:
你可以使用Activity.runOnUiThread()。直截了当，如果你有一个活动:
@WorkerThread
void workerThread() {
myActivity.runOnUiThread(() -> {
// This is where your UI code goes.
}
}
你也可以发布到主循环程序。如果你只有一个Context，这很有用。
@WorkerThread
void workerThread() {
ContextCompat.getMainExecutor(context).execute(() -> {
// This is where your UI code goes.
}
}
弃用:
你可以使用AsyncTask，它对大多数在后台运行的东西都很有效。它有钩子，你可以调用它来指示进度，以及什么时候完成。
它很方便，但如果使用不当，可能会泄漏上下文。它已被正式弃用，您不应该再使用它了。
我也遇到了同样的问题，下面是我的解决方法:
private final class UIHandler extends Handler
{
public static final int DISPLAY_UI_TOAST = 0;
public static final int DISPLAY_UI_DIALOG = 1;
public UIHandler(Looper looper)
{
super(looper);
}
@Override
public void handleMessage(Message msg)
{
switch(msg.what)
{
case UIHandler.DISPLAY_UI_TOAST:
{
Context context = getApplicationContext();
Toast t = Toast.makeText(context, (String)msg.obj, Toast.LENGTH_LONG);
t.show();
}
case UIHandler.DISPLAY_UI_DIALOG:
//TBD
default:
break;
}
}
}
protected void handleUIRequest(String message)
{
Message msg = uiHandler.obtainMessage(UIHandler.DISPLAY_UI_TOAST);
msg.obj = message;
uiHandler.sendMessage(msg);
}
要创建UIHandler，你需要执行以下操作:
HandlerThread uiThread = new HandlerThread("UIHandler");
uiThread.start();
uiHandler = new UIHandler((HandlerThread) uiThread.getLooper());
希望这能有所帮助。
chicobbird的答案对我很有用。我唯一做的改变是在UIHandler的创建中
HandlerThread uiThread = new HandlerThread("UIHandler");
Eclipse拒绝接受其他任何东西。我想这是有道理的。
uiHandler显然是在某处定义的类全局。我仍然不知道Android是如何做到这一点的，以及正在发生什么，但我很高兴它能工作。现在我将继续研究它，看看我是否能理解Android在做什么，以及为什么一个人必须经历所有这些圆环和循环。chicobbird，谢谢你的帮助。
你需要从UI线程调用Toast.makeText(…):
activity.runOnUiThread(new Runnable() {
public void run() {
Toast.makeText(activity, "Hello", Toast.LENGTH_SHORT).show();
}
});
这是从另一个(复制)SO答案复制粘贴。
错误原因:
工作线程是用来做后台任务的，你不能在工作线程的UI上显示任何东西，除非你调用像runOnUiThread这样的方法。如果你试图在UI线程上显示任何东西而不调用runOnUiThread，将会有一个java.lang.RuntimeException。
所以，如果你在一个活动中，但从工作线程调用Toast.makeText()，这样做:
runOnUiThread(new Runnable()
{
public void run()
{
Toast toast = Toast.makeText(getApplicationContext(), "Something", Toast.LENGTH_SHORT).show();
}
});
上面的代码确保您在UI线程中显示Toast消息，因为您是在runOnUiThread方法中调用它。所以不再有java.lang.RuntimeException。
更新- 2016
最好的替代方案是使用RxAndroid(针对RxJava的特定绑定)让MVP中的P负责数据。
首先从你现有的方法返回Observable。
private Observable<PojoObject> getObservableItems() {
return Observable.create(subscriber -> {
for (PojoObject pojoObject: pojoObjects) {
subscriber.onNext(pojoObject);
}
subscriber.onCompleted();
});
}
像这样使用这个Observable -
getObservableItems().
subscribeOn(Schedulers.io()).
observeOn(AndroidSchedulers.mainThread()).
subscribe(new Observer<PojoObject> () {
@Override
public void onCompleted() {
// Print Toast on completion
}
@Override
public void onError(Throwable e) {}
@Override
public void onNext(PojoObject pojoObject) {
// Show Progress
}
});
}
----------------------------------------------------------------------------------------------------------------------------------
我知道我来晚了一点，但我要开始了。 Android主要工作在两种线程类型上，即UI线程和后台线程。根据android文档-
不要从UI线程外部访问Android UI工具包来解决这个问题，Android提供了几种从其他线程访问UI线程的方法。下面是一些可以帮助你的方法:
Activity.runOnUiThread(Runnable)
View.post(Runnable)
View.postDelayed(Runnable, long)
现在有各种方法来解决这个问题。
我将通过代码示例解释它:
runOnUiThread
new Thread()
{
public void run()
{
myactivity.this.runOnUiThread(new Runnable()
{
public void run()
{
//Do your UI operations like dialog opening or Toast here
}
});
}
}.start();
电影
用于为线程运行消息循环的类。线程默认执行 没有与它们关联的消息循环;要创建一个，请调用 Prepare()在线程中即运行循环，然后loop()到 让它处理消息，直到循环停止。
class LooperThread extends Thread {
public Handler mHandler;
public void run() {
Looper.prepare();
mHandler = new Handler() {
public void handleMessage(Message msg) {
// process incoming messages here
}
};
Looper.loop();
}
}
AsyncTask
AsyncTask允许您对用户执行异步工作 接口。它在工作线程中执行阻塞操作 然后在UI线程上发布结果，而不需要你这样做 自己处理线程和/或处理程序。
public void onClick(View v) {
new CustomTask().execute((Void[])null);
}
private class CustomTask extends AsyncTask<Void, Void, Void> {
protected Void doInBackground(Void... param) {
//Do some work
return null;
}
protected void onPostExecute(Void param) {
//Print Toast or open dialog
}
}
是
处理器允许您发送和处理Message和Runnable对象 与线程的messagqueuue相关联。
Message msg = new Message();
new Thread()
{
public void run()
{
msg.arg1=1;
handler.sendMessage(msg);
}
}.start();
Handler handler = new Handler(new Handler.Callback() {
@Override
public boolean handleMessage(Message msg) {
if(msg.arg1==1)
{
//Print Toast or open dialog
}
return false;
}
});
尝试这个，当你看到runtimeException由于循环程序没有准备之前的处理程序。
Handler handler = new Handler(Looper.getMainLooper());
handler.postDelayed(new Runnable() {
@Override
public void run() {
// Run your task here
}
}, 1000 );
在执行以下操作之前，我一直得到这个错误。
public void somethingHappened(final Context context)
{
Handler handler = new Handler(Looper.getMainLooper());
handler.post(
new Runnable()
{
@Override
public void run()
{
Toast.makeText(context, "Something happened.", Toast.LENGTH_SHORT).show();
}
}
);
}
并把它变成一个单例类:
public enum Toaster {
INSTANCE;
private final Handler handler = new Handler(Looper.getMainLooper());
public void postMessage(final String message) {
handler.post(
new Runnable() {
@Override
public void run() {
Toast.makeText(ApplicationHolder.INSTANCE.getCustomApplication(), message, Toast.LENGTH_SHORT)
.show();
}
}
);
}
}
Toast.makeText()只能从Main/UI线程调用。loop . getmainlooper()帮助你实现它:
JAVA
new Handler(Looper.getMainLooper()).post(new Runnable() {
@Override
public void run() {
// write your code here
}
});
科特林
Handler(Looper.getMainLooper()).post {
// write your code here
}
这种方法的优点是您可以在没有活动或上下文的情况下运行UI代码。
这是因为Toast.makeText()是从工作线程调用的。它应该像这样从主UI线程调用
runOnUiThread(new Runnable() {
public void run() {
Toast toast = Toast.makeText(mContext, "Something", Toast.LENGTH_SHORT);
}
});
Toast, alertdialog需要在UI线程上运行，你可以使用Asynctask在android开发中正确使用它们。但有些情况下，我们需要自定义超时，所以我们使用线程，但在线程中，我们不能使用Toast, alertdialog，就像我们在AsyncTask中使用的那样。我们需要单独的Handler来处理弹出这些。
public void onSigned() {
Thread thread = new Thread(){
@Override
public void run() {
try{
sleep(3000);
Message message = new Message();
message.what = 2;
handler.sendMessage(message);
} catch (Exception e){
e.printStackTrace();
}
}
};
thread.start();
}
在上面的例子中，我想睡我的线程在3秒后，我想显示一个吐司消息，在你的主线程实现处理程序。
handler = new Handler() {
public void handleMessage(Message msg) {
switch(msg.what){
case 1:
Toast.makeText(getActivity(),"cool",Toast.LENGTH_SHORT).show();
break;
}
super.handleMessage(msg);
}
};
我在这里使用了switch case，因为如果你需要以相同的方式显示不同的消息，你可以在Handler类中使用switch case…希望这对你有所帮助
要在线程中显示对话框或烤面包机，最简洁的方法是使用Activity对象。
例如:
new Thread(new Runnable() {
@Override
public void run() {
myActivity.runOnUiThread(new Runnable() {
public void run() {
myActivity.this.processingWaitDialog = new ProgressDialog(myActivity.this.getContext());
myActivity.this.processingWaitDialog.setProgressStyle(ProgressDialog.STYLE_SPINNER);
myActivity.this.processingWaitDialog.setMessage("abc");
myActivity.this.processingWaitDialog.setIndeterminate(true);
myActivity.this.processingWaitDialog.show();
}
});
expenseClassify.serverPost(
new AsyncOperationCallback() {
public void operationCompleted(Object sender) {
myActivity.runOnUiThread(new Runnable() {
public void run() {
if (myActivity.this.processingWaitDialog != null
&& myActivity.this.processingWaitDialog.isShowing()) {
myActivity.this.processingWaitDialog.dismiss();
myActivity.this.processingWaitDialog = null;
}
}
}); // .runOnUiThread(new Runnable()
...
当我的回调函数试图显示一个对话框时，我也遇到了同样的问题。
我用活动中的专用方法解决了这个问题-在活动实例成员级别-使用runOnUiThread(..)
public void showAuthProgressDialog() {
runOnUiThread(new Runnable() {
@Override
public void run() {
mAuthProgressDialog = DialogUtil.getVisibleProgressDialog(SignInActivity.this, "Loading ...");
}
});
}
public void dismissAuthProgressDialog() {
runOnUiThread(new Runnable() {
@Override
public void run() {
if (mAuthProgressDialog == null || ! mAuthProgressDialog.isShowing()) {
return;
}
mAuthProgressDialog.dismiss();
}
});
}
我就是这么做的。
new Handler(Looper.getMainLooper()).post(new Runnable() {
@Override
public void run() {
Toast(...);
}
});
可视组件“锁定”于来自外部线程的更改。 因此，由于toast在主屏幕上显示由主线程管理的内容，您需要在主线程上运行这段代码。 希望这对你有所帮助。
Rxjava和RxAndroid用户:
public static void shortToast(String msg) {
Observable.just(msg)
.observeOn(AndroidSchedulers.mainThread())
.subscribe(message -> {
Toast.makeText(App.getInstance(), message, Toast.LENGTH_SHORT).show();
});
}
我使用下面的代码来显示来自非主线程“context”的消息，
@FunctionalInterface
public interface IShowMessage {
Context getContext();
default void showMessage(String message) {
final Thread mThread = new Thread() {
@Override
public void run() {
try {
Looper.prepare();
Toast.makeText(getContext(), message, Toast.LENGTH_LONG).show();
Looper.loop();
} catch (Exception error) {
error.printStackTrace();
Log.e("IShowMessage", error.getMessage());
}
}
};
mThread.start();
}
}
然后使用如下:
class myClass implements IShowMessage{
showMessage("your message!");
@Override
public Context getContext() {
return getApplicationContext();
}
}
这通常发生在从任何后台线程调用主线程上的某些内容时。让我们看一个例子。
private class MyTask extends AsyncTask<Void, Void, Void> {
@Override
protected Void doInBackground(Void... voids) {
textView.setText("Any Text");
return null;
}
}
在上面的例子中，我们通过doInBackground()方法在主UI线程中的textview上设置文本，该方法只在工作线程上操作。
runOnUiThread(new Runnable() {
public void run() {
Toast.makeText(mContext, "Message", Toast.LENGTH_SHORT).show();
}
});
Handler handler2;
HandlerThread handlerThread=new HandlerThread("second_thread");
handlerThread.start();
handler2=new Handler(handlerThread.getLooper());
现在handler2将使用一个不同于主线程的线程来处理消息。
首先调用loop .prepare()，然后调用Toast.makeText().show()最后调用loop .loop():
Looper.prepare() // to be able to make toast
Toast.makeText(context, "not connected", Toast.LENGTH_LONG).show()
Looper.loop()
你需要在UI线程上创建吐司。请看下面的例子。
runOnUiThread(new Runnable() {
public void run() {
Toast.makeText(activity, "YOUR_MESSAGE", Toast.LENGTH_SHORT).show();
}
});
要显示Toast消息，请参考这篇文章
下面是Kotlin使用Coroutine的解决方案:
通过MainScope()使用CoroutineScope扩展类:
class BootstrapActivity : CoroutineScope by MainScope() {}
然后简单地这样做:
launch {
// whatever you want to do in the main thread
}
不要忘记添加协程的依赖项:
org.jetbrains.kotlinx:kotlinx-coroutines-core:${Versions.kotlinCoroutines}
org.jetbrains.kotlinx:kotlinx-coroutines-android:${Versions.kotlinCoroutines}
使用λ:
activity.runOnUiThread(() -> Toast.makeText(activity, "Hello", Toast.LENGTH_SHORT).show());
Java 8
new Handler(Looper.getMainLooper()).post(() -> {
// Work in the UI thread
});
科特林
Handler(Looper.getMainLooper()).post{
// Work in the UI thread
}
GL
协同程序会很好地做到这一点
CoroutineScope(Job() + Dispatchers.Main).launch {
Toast.makeText(context, "yourmessage",Toast.LENGTH_LONG).show()}
在线程外部创建处理器
final Handler handler = new Handler();
new Thread(new Runnable() {
@Override
public void run() {
try{
handler.post(new Runnable() {
@Override
public void run() {
showAlertDialog(p.getProviderName(), Token, p.getProviderId(), Amount);
}
});
}
}
catch (Exception e){
Log.d("ProvidersNullExp", e.getMessage());
}
}
}).start();
我得到了同样的问题，这段代码为我工作很好。 作为一个例子，这是我的代码做一个任务在后台和UI线程。 观察如何使用套筒:
new Thread(new Runnable() {
@Override
public void run() {
Looper.prepare();
// your Background Task here
runOnUiThread(new Runnable() {
@Override
public void run() {
// update your UI here
Looper.loop();
}
});
}
}).start();
