Java New Thread

[uncopyable]

Hallo,

gibt es in Java ne möglich einen Neuen Thread mit Parameter und return value zu starten?


Mit Parameter

class MyThread extends Thread {
     private String to;
 public MyThread(String to) {
          this.to = to;
 }
            
 @Override
  public void run() {
        System.out.println("hello " + to);
  }
 }
 public static void main(String[] args) {
     new MyThread("world!").start();
 } 

Mit return value

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;


public class Main
{
    public static void main(final String[] argv)
    {
        final ExecutorService service;
        final Future<String>  task;

        service = Executors.newFixedThreadPool(1);        
        task    = service.submit(new Foo());

        try 
        {
            final String str;

            // waits the 10 seconds for the Callable.call to finish.
            str = task.get();
            System.out.println(str);
        }
        catch(final InterruptedException ex)
        {
            ex.printStackTrace();
        }
        catch(final ExecutionException ex)
        {
            ex.printStackTrace();
        }

        service.shutdownNow();
    }
}

class Foo
    implements Callable<String>
{
    public String call()
    {
        try
        {
            // sleep for 10 seconds
            Thread.sleep(10 * 1000);
        }
        catch(final InterruptedException ex)
        {
            ex.printStackTrace();
        }

        return ("Hello, World!");
    }
} 

Hab versucht die Beispiele zu kombinieren aber leider funktioniert das nicht so wie ich es gern hätte, vielleicht weiß einer von euch wie ich das am besten lösen kann?

Danke schonmal

[Mentos]

Nimm doch nen SwingWorker. Den fand ich bzgl. des MClientens sehr passend.
MfG

[patlux]

Verstehe dein Problem nicht dass zu kombinieren xD

import java.util.concurrent.Callable; 
import java.util.concurrent.ExecutionException; 
import java.util.concurrent.ExecutorService; 
import java.util.concurrent.Executors; 
import java.util.concurrent.Future; 


public class Main 
{ 
    public static void main(final String[] argv) 
    { 
        final ExecutorService service; 
        final Future<String>  task; 

        service = Executors.newFixedThreadPool(1);         
        task    = service.submit(new Foo("world!")); 

        try  
        { 
            final String str; 

            // waits the 10 seconds for the Callable.call to finish. 
            str = task.get(); 
            System.out.println(str); 
        } 
        catch(final InterruptedException ex) 
        { 
            ex.printStackTrace(); 
        } 
        catch(final ExecutionException ex) 
        { 
            ex.printStackTrace(); 
        } 

        service.shutdownNow(); 
    } 
} 

class Foo 
    implements Callable<String> 
{ 

    private String to; 
 public Foo(String to) { 
          this.to = to; 
 } 

    public String call() 
    { 
        try 
        { 
            // sleep for 10 seconds 
            Thread.sleep(10 * 1000); 
System.out.println("hello " + to);
        } 
        catch(final InterruptedException ex) 
        { 
            ex.printStackTrace(); 
        } 

        return ("Hello, " + to); 
    } 
} 

Sollte eigentlich gehen. Hatte sowas in Java noch nie benötigt. löl