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();
    }
}