Java 创建线程的方法

为了偷懒少敲几个字这里我写了一个Util类：

 package test;

 public class Util {
     static void println() {System.out.println();}
     static void println(Object obj) {System.out.println(obj);}
 }

并且在之后的代码中都加入了：

 package test;
 import static test.Util.*;

1.实现Runnable接口

 class simpleRunnable implements Runnable {
     private int n = 3;
     private static int count = 0;
     protected final int id = count++;

     public simpleRunnable() {
         println("#" + id +" start");
     }

     @Override
     public void run() {
         while(n-->0){
             println("#" +id +"：" + n);
             Thread.yield();
         }
         println("#" + id +" end");
     }
 }

 public class test {
     public static void main(String[] args) {
         new Thread(new simpleRunnable()).start();
     }
 }

还有一种自管理的Runnable：

 class simpleRunnable2 implements Runnable {
     private Thread t = new Thread(this);
     private int n = 3;
     private static int count = 0;
     private final int id = count++;
     public simpleRunnable2() {t.start();}
     @Override
     public void run() {
         while(n-->0){
             println("#" +id +"：" + n);
             Thread.yield();
         }
         println("#" + id +" end");
     }
 }

 public class test {
     public static void main(String[] args) {
         new simpleRunnable2();
     }
 }

2.继承Thread类

 class simpleThread extends Thread{
     private int n = 3;
     private static int count = 0;
     private final int id = count++;

     public simpleThread() {
         println("#" + id +" start");
     }

     public void run() {
         while(n-->0){
             println("#" +id +"：" + n);
             Thread.yield();
         }
         println("#" + id +" end");
     }
 }

 public class test {
     public static void main(String[] args) {
         new simpleThread().start();
     }
 }

3.内部类

3.1实现Runnable接口的内部类

 class innerRunnable{
     private static int count = 0;
     private Inner inner;
     private class Inner implements Runnable {
         private int n = 3;
         private final int id = count++;
         Thread t = new Thread(this);
         public Inner() {t.start();}
         @Override
         public void run() {
             while(n-->0){
                 println("#" +id +"：" + n);
                 Thread.yield();
             }
             println("#" + id +" end");
         }
     }
     public innerRunnable() {
         inner = new Inner();
     }
 }

 class innerRunnable2{
     private static int count = 0;
     private Thread t;
     public innerRunnable2() {
         t = new Thread(new Runnable(){
             //实现Runnable接口的匿名内部类
             private int n = 3;
             private final int id = count++;
             @Override
             public void run() {
                 while(n-->0){
                     println("ir2#" +id +"：" + n);
                     Thread.yield();
                 }
                 println("ir2#" + id +" end");
             }
         });
         t.start();
     }
 }

 public class test {
     public static void main(String[] args) {
         new innerRunnable();
         new innerRunnable2();
     }
 }

3.2继承Thread类的内部类

 class innerThread {
     private static int count = 0;
     private Inner inner;
     private class Inner extends Thread {
         private int n = 3;
         private final int id = count++;
         public Inner(){
             super();
             start();
         }
         public void run() {
             while(n-->0){
                 println("#" +id +"：" + n);
                 Thread.yield();
             }
             println("#" + id +" end");
         }
     }
     public innerThread(){
         inner = new Inner();
     }
 }

 public class test {
     public static void main(String[] args) {
         new innerThread();
     }
 }

当然同样可以用匿名匿名内部类，和Runnable是类似的，就不放上来了。

3.3在方法中使用匿名内部类

 class ThreadMethod {
     private static int count = 0;
     private Thread t;
     public void runTask() {
         if(t == null) {
             t = new Thread(new Runnable(){
                 private int n = 3;
                 private final int id = count++;
                 @Override
                 public void run() {
                     while(n-->0){
                         println("ir2#" +id +"：" + n);
                         Thread.yield();
                     }
                     println("ir2#" + id +" end");
                 }
             });
             t.start();
         }
     }
 }

 public class test {
     public static void main(String[] args) {
         new innerThread();
     }
 }

4.使用Executor

首先import一些用的到的包：

 import java.util.ArrayList;
 import java.util.List;
 import java.util.concurrent.Callable;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
 import java.util.concurrent.Future;
 import java.util.concurrent.TimeUnit;

4.1CachedThreadPool

public class test {
    public static void main(String[] args) {
        ExecutorService exec = Executors.newCachedThreadPool();
        for(int i = 0; i < 5; i++)
            exec.execute(new simpleRunnable());
        exec.shutdown();
    }
}

CachedThreadPool为每个任务创建一个线程。

4.2FixedThreadPool

 public class test {
     public static void main(String[] args) {
         ExecutorService exec = Executors.newFixedThreadPool(3);
         for(int i = 0; i < 5; i++)
             exec.execute(new simpleRunnable());
         exec.shutdown();
     }
 }

newFixedThreadPool()需要一个整型参数，记为n，并当参数n <=0 时抛出IllegalArgumentException；这个方法会一次行创建n个线程，并且在这n个线程都在有任务时将后来的线程加入一个队列中，所有的任务都被new并且被接收。

4.3SingleThreadExecutor

 public class test {
     public static void main(String[] args) {
         ExecutorService exec = Executors.newSingleThreadExecutor();
         for(int i = 0; i < 5; i++)
             exec.execute(new simpleRunnable());
         exec.execute(new simpleRunnable());
         exec.shutdown();
     }
 }

SingleThreadExecutor就相当于线程数为1的FixedThreadPool。

4.4实现Callable接口

 class simpleCallable implements Callable<Integer>{
     @Override
     public Integer call() throws Exception {
         return (int)(Math.random() * 10 + 1);
     }
 }
 public class test {
     public static void main(String[] args) {
         ExecutorService exec = Executors.newCachedThreadPool();
         List<Future<Integer>> list = new ArrayList();
         for(int i = 0; i < 5; i++)
             list.add(exec.submit(new simpleCallable()));
         for(Future<Integer> f : list)
             try {
                 println(f.get());
             } catch (InterruptedException e) {
                 e.printStackTrace();
             } catch (ExecutionException e) {
                 e.printStackTrace();
             } finally {
                 exec.shutdown();
             }
     }
 }

Runnable是执行工作的独立任务，但是它不会返回任何值，而实现Callable<V>可以在call()方法中产生类型为V的对象并返回其引用（我觉得这样说会比“返回类型为V的对象”更合适一些），并且必须使用ExecutorService。submit()来调用它；submit方法会产生Future对象并返回其引用，第一个for并不会被阻塞；可以用isDone()来查询任务是否完成，或者直接使用get()来取得结果，当get()时任务未完成则会阻塞get()。

4.5使用ThreadFactory

 class simpleThreadFactory implements ThreadFactory {
     @Override
     public Thread newThread(Runnable r) {
         Thread t = new Thread(r);
         return t;
     }
 }

 public class test {
     public static void main(String[] args) {
         ExecutorService exec = Executors.newCachedThreadPool(new simpleThreadFactory());
         exec.execute(new simpleRunnable());
         exec.shutdown();
     }
 }