在另一个线程中处理UI组件

Question

I want to change few components in another thread. I did it, but I don't know is it good enough (or too bad). This is how I do:

public class FullMapFragment extends Fragment {    

    private AlertDialog alertDialog; //volatile?
    ...

Runnable class for handler:

public class ShowAlertDialog implements Runnable{

    private AlertDialog alertDialog;

    public  ShowAlertDialog (AlertDialog alertDialog)
    {
        this.alertDialog=alertDialog;
    }
    public void run()
    {
         //do something with dialog
    }

In another thread:

public class UpdateMapRunnable implements Runnable {

    public UpdateMapRunnable(FullMapFragment fragment) {
        this.fragment = fragment;

    }

    private FullMapFragment fragment; //volatile?

    private final Handler uiHandler = new Handler();

    @Override
    public void run() {     
        uiHandler.post(new ShowAlertDialog (fragment.getAlertDialog()));            
    }

Is that ok? Do I have to add volatile modificator to those fields?

Answer 1

You should never modify UI components outside UI thread . Because if you'll change Dialog's components in the working thread while it is being rendered in AWT EQ, you will get an error and volatile won't help. But if you just want dialog to be accessible in another thread to prepare it, and you surely will show it only after all modifications, just make it final, it will be enough. Again, volatile won't help, as it only makes pointer volatile, not the entire object . And if you need concurrent changes on Dialog's properties, you need to sync it's fields/methods. Type of sync will vary depending on access mode. If one thread writes and others only read, volatile is ok, if more than 1 writer, you'll need something more strict, like Atomic or synchronized.

So, you can:

1) / for concurrent changes / create a data model, which you compute and change (which can be a long work) and then in UI thread you only modify UI components corresponding to model state (which is fast). Here you will need some synchronization.

2) / for non-concurrent changes / send a runnable code to UI thread to do all the work (in case you need threading, but not for UI work) like that:

EventQueue.invokeLater( ()->{ /*your work here*/ } );

3) do both 1 and 2. Almost all cases finally come to this.

If everything is written right you will need synchronization only when where is more than 1 worker (non-ui) thread.