三种创建线程的方式详解。

1.继承thread类

2.实现runnable接口。

3.实现callable接口。

这三种方式具体如何创建如何调用详见下面代码，注释已经写得很详细了。例子中分别用这三种方式创建线程并分别启动了两个线程。具体区别自己细微体会下。

package com.thread.Lone;

/**
 * 创建线程的第一种方法
 * 继承java.lang.Thread，然后重写该类的run方法.
 */
public class ThreadExt extends java.lang.Thread {

        public void run(){
            System.out.println(Thread.currentThread().getName()+" start");
            for(int i=0;i<5;i++){
                System.out.println(Thread.currentThread().getName()+"  : "+i);
            }
            System.out.println(Thread.currentThread().getName()+" end");
        }

}

package com.thread.Lone;

/**
 * 第二种创建线程的方法，实现Runnable接口
 * 因为java不支持多继承，那么假设你的类本身继承了一个父类
 * 这时候还想创建线程的话，那么实现java.lang.Runnable就比较合适了。
 */
public class ThreadRunnable implements java.lang.Runnable {
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+" start");
        for(int i=0;i<5;i++){
            System.out.println(Thread.currentThread().getName()+"  : "+i);
        }
        System.out.println(Thread.currentThread().getName()+" end");
    }
}

package com.thread.Lone;

import java.util.concurrent.Callable;

/**
 * 前面两种方式，都没有返回值，那如果我们希望线程能把执行结果返回到主程序，就需要用到concurrent包里面的东西
 * java.util.concurrent.FutureTask 和 java.util.concurrent.Callable
 * 这里需要实现Callable接口，主要是为了实现call()方法，而call方法就是带有返回值的。
 * 启动方式见主程序。
 */
public class ThreadFuture implements Callable{
    @Override
    public Object call() throws Exception {

        System.out.println(Thread.currentThread().getName()+" start");
        int i;
        for(i=0;i<5;i++){
            System.out.println(Thread.currentThread().getName()+"  : "+i);
        }
        System.out.println(Thread.currentThread().getName()+" end");
        //为了体现Future的get()的等待效果，这里休息2秒
        Thread.sleep(2000);
        return Thread.currentThread().getName()+" 总共循环了"+i+"次";
    }
}

package com.thread.Lone;

import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

/**
 * 在这个类里面我们会分别启动不同方式创建的线程。
 */
public class TestRun {
    public static void main(String[] args) throws ExecutionException, InterruptedException {

        //  启动继承Thread类的线程
        //  执行这段代码你可以发现console打出的log基本每次都不一样
        //  甚至有时候ext2的log会输出在ext1之前，可以看出线程启动之后，具体的执行已经和主程序无关，也不会受到其他线程的影响。
        ThreadExt ext1 = new ThreadExt();
        //这里有一个好习惯就是，对于你启动的线程最好命名一下方便排查问题。
        ext1.setName("ThreadExt one");
        ThreadExt ext2 = new ThreadExt();
        ext2.setName("ThreadExt two");
        //通过阅读源码可以发现，最终调用start()方法是去调用一个本地的start0方法
        //private native void start0(); 由于我不懂C也就不去看了。
        ext1.start();
        ext2.start();

        //下面启动实现runnable接口的线程
        //启动方法略有不同，因为runnable接口本身是没有start()方法的。
        //所以要启动方式是，新建一个Thread对象并把自己的对象当做Target传进去
        //而在Thread的run()方法的注释里面有这么写到：当构建Thread的时候target不为空，调用target的Run，而如果为空，则什么都不做。
        ThreadRunnable threadRunnable1 = new ThreadRunnable();
        //这里可以使用带名字的构造函数
        Thread t1 = new Thread(threadRunnable1,"threadRannable1 ");
        t1.start();
        //匿名方式
        new Thread(threadRunnable1,"threadRannable2 ").start();

        //下面启动实现Callable的线程
        //和实现Runnable的线程类似，最终的启动方式也是通过Thread.start来启动的。
        //但是Thread只接受Runnalbe类型的target，而我们的类实现的是callable接口,明显不匹配
        //这时候就需要引入一个FutureTask类，这个类本身实现了runnable但是持有一个callable对象。是一个典型的适配器模式，将一个Callable对象伪装成一个Runnable对象
        ThreadFuture threadFuture  = new ThreadFuture();
        //把threadFuture给传入到futureTask
        FutureTask futureTask = new FutureTask(threadFuture);
        //这时候，我们就可以把持有threadFuture对象的FutureTask当做target传给Thread对象。
        //通过源码可以看到，当start()执行的时候，会走到futureTask的Run方法，而futureTask的run方法，又回去调用ThreadFuture的call方法，并且把返回值保存到FutureTask的outcome属性上。
         new Thread(futureTask,"ThreadFuture1 ").start();
        //当我们调用get()的时候，其实会去判断当前的状态，如果线程已经跑完(state=1)，就拿到outCome给我们，而如果没有跑完就会等待跑完。
         System.out.println(futureTask.get());
        //所以如果单独调ThreadFuture相关代码的话，就可以看到不同，这里在ThreadFuture1执行完之前是不会执行ThreadFuture2的，因为get会处在等待状态,一直等到当前线程执行完成才会继续走下面的逻辑.
        //另外需要注意的是，futureTask在线程执行完之后，本身的状态已经变成Normal了，这时候再次启动同一个futureTask的时候，实际上是什么都不做的。
        // 例如：new Thread(futureTask,"ThreadFuture2 ").start(); 其实并不会走到ThreadFuture
        //想要新启动一个线程需要new一个futureTask。
        FutureTask futureTask2 = new FutureTask(threadFuture);
        new Thread(futureTask2,"ThreadFuture2 ").start();
        System.out.println(futureTask2.get());

    }
}

 

转载于:https://www.cnblogs.com/my-king/p/7810583.html