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." );

       }

     });

   }

}