คืนค่าจากเธรด

ฉันมีวิธีการกับไฟล์HandlerThread. ค่าได้รับการเปลี่ยนแปลงภายในThreadและฉันต้องการส่งคืนกลับเป็นtest()วิธีการ มีวิธีทำไหม?

public void test()
{   
    Thread uiThread = new HandlerThread("UIHandler"){
        public synchronized void run(){
            int value; 
            value = 2; //To be returned to test()
        }
    };
    uiThread.start();
}

คุณสามารถใช้อาร์เรย์ตัวแปรสุดท้ายแบบโลคัล ตัวแปรต้องเป็นประเภทที่ไม่ใช่พื้นฐานดังนั้นคุณจึงสามารถใช้อาร์เรย์ได้ คุณต้องซิงโครไนซ์สองเธรดตัวอย่างเช่นการใช้CountDownLatch :

public void test()
{   
    final CountDownLatch latch = new CountDownLatch(1);
    final int[] value = new int[1];
    Thread uiThread = new HandlerThread("UIHandler"){
        @Override
        public void run(){
            value[0] = 2;
            latch.countDown(); // Release await() in the test thread.
        }
    };
    uiThread.start();
    latch.await(); // Wait for countDown() in the UI thread. Or could uiThread.join();
    // value[0] holds 2 at this point.
}

คุณยังสามารถใช้Executorและสิ่งCallableนี้:

public void test() throws InterruptedException, ExecutionException
{   
    ExecutorService executor = Executors.newSingleThreadExecutor();
    Callable<Integer> callable = new Callable<Integer>() {
        @Override
        public Integer call() {
            return 2;
        }
    };
    Future<Integer> future = executor.submit(callable);
    // future.get() returns 2 or raises an exception if the thread dies, so safer
    executor.shutdown();
}

โดยปกติคุณจะทำสิ่งนี้

 public class Foo implements Runnable {
     private volatile int value;

     @Override
     public void run() {
        value = 2;
     }

     public int getValue() {
         return value;
     }
 }

จากนั้นคุณสามารถสร้างเธรดและดึงค่า (เนื่องจากได้ตั้งค่าไว้)

Foo foo = new Foo();
Thread thread = new Thread(foo);
thread.start();
thread.join();
int value = foo.getValue();

tl;drเธรดไม่สามารถส่งคืนค่าได้ (อย่างน้อยก็ไม่มีกลไกการโทรกลับ) คุณควรอ้างอิงเธรดเหมือนคลาสธรรมดาและถามค่า

สิ่งที่คุณกำลังมองหาน่าจะเป็นCallable<V>อินเทอร์เฟซแทนRunnableและการดึงค่าด้วยFuture<V>อ็อบเจกต์ซึ่งช่วยให้คุณรอจนกว่าค่าจะได้รับการคำนวณ คุณสามารถบรรลุนี้กับที่คุณจะได้รับจากExecutorServiceExecutors.newSingleThreadExecutor()

public void test() {
    int x;
    ExecutorService es = Executors.newSingleThreadExecutor();
    Future<Integer> result = es.submit(new Callable<Integer>() {
        public Integer call() throws Exception {
            // the other thread
            return 2;
        }
    });
    try {
        x = result.get();
    } catch (Exception e) {
        // failed
    }
    es.shutdown();
}

วิธีแก้ปัญหานี้เป็นอย่างไร?

มันไม่ได้ใช้คลาสเธรด แต่มันทำงานพร้อมกันและในลักษณะที่ทำตามที่คุณร้องขอ

ExecutorService pool = Executors.newFixedThreadPool(2); // creates a pool of threads for the Future to draw from

Future<Integer> value = pool.submit(new Callable<Integer>() {
    @Override
    public Integer call() {return 2;}
});

ตอนนี้สิ่งที่คุณทำคือพูดvalue.get()เมื่อใดก็ตามที่คุณต้องการคว้ามูลค่าที่ส่งคืนเธรดจะเริ่มต้นในวินาทีที่คุณให้valueคุณค่าดังนั้นคุณไม่จำเป็นต้องพูดอะไรthreadName.start()เลย

อะไรFutureคือสัญญากับโปรแกรมคุณสัญญากับโปรแกรมว่าคุณจะได้รับคุณค่าที่ต้องการในอนาคตอันใกล้นี้

หากคุณโทรหา.get()ก่อนที่จะเสร็จเธรดที่เรียกมันจะรอจนกว่าจะเสร็จ

หากคุณต้องการค่าจากวิธีการโทรก็ควรรอให้เธรดเสร็จสิ้นซึ่งทำให้การใช้เธรดไม่มีจุดหมาย

เพื่อตอบคำถามของคุณโดยตรงค่านี้สามารถเก็บไว้ในอ็อบเจ็กต์ที่ไม่แน่นอนใด ๆ ทั้งวิธีการโทรและเธรดมีการอ้างอิงถึง คุณสามารถใช้ด้านนอกthisได้ แต่นั่นจะไม่เป็นประโยชน์อย่างยิ่งนอกเหนือจากตัวอย่างเล็กน้อย

หมายเหตุเล็กน้อยเกี่ยวกับรหัสในคำถาม: การขยายThreadมักจะเป็นรูปแบบที่ไม่ดี การขยายชั้นเรียนโดยไม่จำเป็นเป็นความคิดที่ไม่ดี ฉันสังเกตเห็นว่าrunวิธีการของคุณตรงกันด้วยเหตุผลบางประการ ในขณะที่วัตถุในกรณีนี้คือThreadคุณอาจเข้าไปยุ่งเกี่ยวกับสิ่งที่Threadใช้ล็อคสำหรับ (ในการนำไปใช้อ้างอิงบางสิ่งที่เกี่ยวข้องกับjoinIIRC)

ตั้งแต่ Java 8 เป็นต้นไปเรามีCompletableFuture. ในกรณีของคุณคุณอาจใช้วิธีการsupplyAsyncเพื่อให้ได้ผลลัพธ์หลังการดำเนินการ

กรุณาหาอ้างอิงบางอย่างที่นี่

    CompletableFuture<Integer> completableFuture
      = CompletableFuture.supplyAsync(() -> yourMethod());

   completableFuture.get() //gives you the value

การใช้ Future ที่อธิบายไว้ในคำตอบข้างต้นจะได้ผล แต่ f.get () จะบล็อกเธรดจนกว่าจะได้รับผลลัพธ์ซึ่งเป็นการละเมิดการทำงานพร้อมกัน

ทางออกที่ดีที่สุดคือใช้ ListenableFuture ของฝรั่ง ตัวอย่าง :

    ListenableFuture<Void> future = MoreExecutors.listeningDecorator(Executors.newFixedThreadPool(1, new NamedThreadFactory).submit(new Callable<Void>()
    {
        @Override
        public Void call() throws Exception
        {
            someBackgroundTask();
        }
    });
    Futures.addCallback(future, new FutureCallback<Long>()
    {
        @Override
        public void onSuccess(Long result)
        {
            doSomething();
        }

        @Override
        public void onFailure(Throwable t)
        {

        }
    };

ด้วยการปรับเปลี่ยนโค้ดเล็กน้อยคุณสามารถทำได้โดยทั่วไปมากขึ้น

 final Handler responseHandler = new Handler(Looper.getMainLooper()){
            @Override
            public void handleMessage(Message msg) {
                //txtView.setText((String) msg.obj);
                Toast.makeText(MainActivity.this,
                        "Result from UIHandlerThread:"+(int)msg.obj,
                        Toast.LENGTH_LONG)
                        .show();
            }
        };

        HandlerThread handlerThread = new HandlerThread("UIHandlerThread"){
            public void run(){
                Integer a = 2;
                Message msg = new Message();
                msg.obj = a;
                responseHandler.sendMessage(msg);
                System.out.println(a);
            }
        };
        handlerThread.start();

วิธีการแก้ :

1. สร้างHandlerเธรดใน UI ซึ่งเรียกว่าเป็นresponseHandler
2. เริ่มต้นสิ่งนี้HandlerจากLooperเธรด UI
3. ในHandlerThreadโพสต์ข้อความนี้responseHandler
4. handleMessgaeแสดงToastค่าที่ได้รับจากข้อความ วัตถุข้อความนี้เป็นแบบทั่วไปและคุณสามารถส่งแอตทริบิวต์ประเภทต่างๆได้

ด้วยวิธีนี้คุณสามารถส่งหลายค่าไปยังเธรด UI ในช่วงเวลาที่ต่างกัน คุณสามารถเรียกใช้ (โพสต์) Runnableอ็อบเจ็กต์จำนวนมากได้HandlerThreadและแต่ละอ็อบเจ็กต์Runnableสามารถกำหนดค่าในMessageอ็อบเจ็กต์ซึ่ง UI Thread สามารถรับได้