[Java] Java多线程——之一创建线程的四种方法

package thread;
 
public class ThreadRunnable implements Runnable {
  public void run() {
  for (int i = 0; i < 10; i++) {
    System.out.println(Thread.currentThread().getName() + ":" + i);
  }
  }
}
 
 
package thread;
 
public class ThreadMain {
  public static void main(String[] args) throws Exception {
  ThreadRunnable threadRunnable1 = new ThreadRunnable();
  ThreadRunnable threadRunnable2 = new ThreadRunnable();
  ThreadRunnable threadRunnable3 = new ThreadRunnable();
  ThreadRunnable threadRunnable4 = new ThreadRunnable();
  Thread thread1 = new Thread(threadRunnable1);
  Thread thread2 = new Thread(threadRunnable2);
  Thread thread3 = new Thread(threadRunnable3);
  Thread thread4 = new Thread(threadRunnable4);
  thread1.start();
  thread2.start();
  thread3.start();
  thread4.start();
  }
}

public class ThreadEx extends Thread {
  public void run() {
  for (int i = 0; i < 10; i++) {
    System.out.println(Thread.currentThread() + ":" + i);
  }
  }
}
 
 
public class ThreadMain {
  public static void main(String[] args)
  {
  ThreadEx threadEx = new ThreadEx();
  threadEx.start();
  }
}

package thread;
 
import java.util.concurrent.*;
 
public class ThreadCallable {
  public static void main(String[] args) throws Exception {
  FutureTask<Integer> futureTask = new FutureTask<Integer>(new Callable<Integer>() {
    public Integer call() throws Exception {
    for (int i = 0; i < 10; i++) {
      System.out.println(Thread.currentThread().getName() + ":" + i);
    }
    return 1;
    }
  });
  Executor executor = Executors.newFixedThreadPool(1);
  ((ExecutorService) executor).submit(futureTask);
 
  //获得线程执行状态
  System.out.println(Thread.currentThread().getName() + ":" + futureTask.get());
  }
}

package thread;
 
import java.util.concurrent.Callable;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadFactory;
 
import static java.lang.Thread.sleep;
 
public class ThreadExecutors {
  private final String threadName;
 
  public ThreadExecutors(String threadName) {
  this.threadName = threadName;
  }
 
  private ThreadFactory createThread() {
  ThreadFactory tf = new ThreadFactory() {
    public Thread newThread(Runnable r) {
    Thread thread = new Thread();
    thread.setName(threadName);
    thread.setDaemon(true);
    try {
      sleep(1000);
    }
    catch (InterruptedException e) {
      e.printStackTrace();
    }
    return thread;
    }
  };
  return tf;
  }
 
  public Object runCallable(Callable callable) {
  return Executors.newSingleThreadExecutor(createThread()).submit(callable);
  }
 
  public Object runFunture(Runnable runnable) {
  return Executors.newSingleThreadExecutor(createThread()).submit(runnable);
  }
}
 
 
 
package thread;
 
import java.util.concurrent.*;
 
public class ThreadMain {
  public static void main(String[] args) throws Exception {
  ThreadExecutors threadExecutors = new ThreadExecutors("callableThread");
  threadExecutors.runCallable(new Callable() {
    public String call() throws Exception {
    return "success";
    }
  });
 
  threadExecutors.runFunture(new Runnable() {
    public void run() {
    System.out.println("execute runnable thread.");
    }
  });
  }
}

• 1）两个接口需要实现的方法名不一样，Runnable需要实现的方法为run()，Callable需要实现的方法为call()。
  
• 2）实现的方法返回值不一样，Runnable任务执行后无返回值，Callable任务执行后可以得到异步计算的结果。
  
• 3）抛出异常不一样，Runnable不可以抛出异常，Callable可以抛出异常。