JAVA多线程的五种实现方式--Thread类，Runnable接口，匿名内部类，Callable和FutureTask，线程池

JAVA多线程的五种实现方式–Thread类，Runnable接口，匿名内部类，Callable和FutureTask，线程池

构造方法
public Thread() :分配一个新的线程对象。
public Thread(String name) :分配一个指定名字的新的线程对象。
public Thread(Runnable target) :分配一个带有指定目标新的线程对象。
public Thread(Runnable target,String name) :分配一个带有指定目标新的线程对象并指定名字。
常用方法
public String getName() :获取当前线程名称。
public void start() :导致此线程开始执行; Java虚拟机调用此线程的run方法。
public void run() :此线程要执行的任务在此处定义代码。
public static void sleep(long millis) :使当前正在执行的线程以指定的毫秒数暂停（暂时停止执行）。
public static Thread currentThread() :返回对当前正在执行的线程对象的引用。

Thread执行

重写run()方法，new出线程对象.start()

public class DemoThread extends Thread{
    @Override
    public void run() {
        for (int i = 0; i <10 ; i++) {
            System.out.println("zilei"+i);
        }
    }
}

public class DemoMainThread {

    public static void main(String[] args) {

        DemoThread dethread = new DemoThread();
        dethread.start();//建立的线程
      	for (int i = 0; i <10 ; i++) {//主线程
            System.out.println("zhu"+i);
        }
    }
}

java.lang.Runnable执行

把Runnable接口实现类实例化后放入new Thread（）

public class RunnableImpl implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i <20 ; i++) {
            System.out.println(i);
        }
    }
}

public class DemoRunnable {
    public static void main(String[] args) {
        RunnableImpl r1 = new RunnableImpl();
        Thread t1 = new Thread(r1,"Runnable线程");//在这里放入(可以直接给线程起名)
        t1.start();
        for (int i = 0; i <20 ; i++) {
            System.out.println(Thread.currentThread().getName()+"  "+i);
        }
    }
}

实现Runnable接口比继承Thread类所具有的优势：

1. 适合多个相同的程序代码的线程去共享同一个资源。
2. 可以避免java中的单继承的局限性。
3. 增加程序的健壮性，实现解耦操作，代码可以被多个线程共享，代码和线程独立。
4. 线程池只能放入实现Runable或Callable类线程，不能直接放入继承Thread的类。

匿名内部类

//匿名内部类
public class DemoNiming {
    public static void main(String[] args) {
        new Thread(){
            @Override
            public void run() {
                for (int i = 0; i <10 ; i++) {
                    System.out.println("子1："+i);
                }
            }
        }.start();

         Runnable r1=new Runnable(){
            @Override
            public void run() {
                for (int i = 0; i <10 ; i++) {
                    System.out.println("子2："+i);
                }
            }
        };
         new Thread(r1).start();
    }
}

在java中，每次程序运行至少启动2个线程。一个是main线程，一个是垃圾收集线程。因为每当使用 java命令执行一个类的时候，实际上都会启动一个JVM，每一个JVM其实在就是在操作系统中启动了一个进程。

Callable和FutureTask

a:创建Callable接口的实现类 ，并实现Call方法
b:创建Callable实现类的实现，使用FutureTask类包装Callable对象，该FutureTask对象封装了Callable对象的Call方法的返回值
c:使用FutureTask对象作为Thread对象的target创建并启动线程
d:调用FutureTask对象的get()来获取子线程执行结束的返回值

public class ThreadDemo03 {

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub

        Callable<Object> oneCallable = new Tickets<Object>();
        FutureTask<Object> oneTask = new FutureTask<Object>(oneCallable);

        Thread t = new Thread(oneTask);

        System.out.println(Thread.currentThread().getName());

        t.start();

    }

}

class Tickets<Object> implements Callable<Object>{

    //重写call方法
    @Override
    public Object call() throws Exception {
        // TODO Auto-generated method stub
        System.out.println(Thread.currentThread().getName()+"-->我是通过实现Callable接口通过FutureTask包装器来实现的线程");
        return null;
    }   
}

线程池

public class Runnable02Impl implements Runnable {
    @Override public void run() { System.out.println("我要一个教练");
    try {
        Thread.sleep(2000);//暂停2s
    } catch (InterruptedException e)
    {
        e.printStackTrace(); }
    System.out.println("教练来了： " + Thread.currentThread().getName());
    System.out.println("教我游泳,交完后，教练回到了游泳池"); }
}

public class DemoThreadPool {
    public static void main(String[] args) {
        ExecutorService e1 = Executors.newFixedThreadPool(2);
        e1.submit(new Runnable02Impl());
        e1.submit(new Runnable02Impl());
    }
}