java线程的创建

线程的创建

    创建线程对象有4种方式：1.继承Thread类 2.实现Runnable接口3.使用Executor框架来创建线程池4.实现Callable接口。一个新的线程对象是由其parent线程（默认在哪个线程中创建线程对象，哪个线程就是这个新线程的parent线程，如在main函数中创建线程对象，则main线程就是新线程的parent线程）来进行空间分配的，child线程继承了parent线程是否为守护线程，优先级等，同时还会分配一个唯一的ID来表示这个child线程。线程对象被初始化后，在对内存中等待运行。

1.继承Thread类

1.1创建一个类继承Thread类

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

 

//创建线程
ClassExtendsThread thread = new ClassExtendsThread();
//线程启动，注意一定要调用start方法，不能调用run()方法
thread.start();

1.2 匿名内部类

    也可以利用匿名内部类的方法创建一个线程并启动,当然1.1和1.2本质上是相同的创建方法，这里直接利用匿名内部类创建了一个Thread()类的对象，并覆写了run()方法。（ 建议不了解匿名内部类和lambda表达式的同学复习一下这两个概念和使用场景。）

new Thread(){
    public void run(){
        @Override
        for(int i=0;i<10;i++){
            System.out.println(Thread.currentThread().getName()+" "+i);
        }
    }
}.start();

2.实现Runnable接口

2.1 创建一个类实现Runnable接口

    在利用Thread创建线程时,将实现了Runnable接口的类的对象作为参数传入构造函数，从而新建一个线程。

class ClassImplementsRunnable implements Runnable{
    @Override
    public  void run(){
        for(int i=0;i<10;i++){
            System.out.println(Thread.currentThread().getName()+" "+i);
        }
    }
}
Thread t3 = new Thread(new ClassImplementsRunnable());
t3.start();

2.2 利用匿名内部类

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

2.3 利用lambda表达式

new Thread(()->{
    for(int i=0;i<10;i++){
        System.out.println(Thread.currentThread().getName()+" "+i);
    }
}).start();

3.使用Executor框架创建线程池

如果只想看简单的例子，可以看下面实现Callable接口的例子，其中使用线程池创建了线程。使用线程池的情况较复杂，准备在另一篇博客种总结。

4.实现Callable接口

Runnable和Callable的区别：

1、Callable规定的方法是call(),Runnable规定的方法是run().

2、Callable的任务执行后可返回值，而Runnable的任务是不能返回值得

3、call方法可以抛出异常，run方法不可以

4、运行Callable任务可以拿到一个Future对象，表示异步计算的结果。它提供了检查计算是否完成的方法，以等待计算的完成，并检索计算的结果。通过Future对象可以了解任务执行情况，可取消任务的执行，还可获取执行结果。

如下是仿照网上例子，实现Callable接口，通过线程池创建线程，异步计算一个数组中所有数字的和，ExecutorService、Callable、Future三个接口实际上都是属于Executor框架，ExecutoreService提供了submit()方法，传递一个Callable对象，或Runnable对象，返回Future。如果Executor后台线程池还没有完成Callable的计算，这调用返回Future对象的get()方法，会阻塞直到计算完成。

import java.util.HashSet;
import java.util.Set;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

public class CallableTest{
    public static void main(String [] args ) {
        int [] arr = {1,2,3,4};

        //创建一个线程池
        ExecutorService pool = Executors.newCachedThreadPool(  );
        Set<Future<Integer>> set = new HashSet<Future<Integer>>();

        for (int val: arr) {
            Callable<Integer> callable = new testCallable(val);
            //创建对象，并通过Future类对象获取异步计算的结果
            Future<Integer> future = pool.submit(callable);
            set.add(future);
        }
        int sum = 0;
        for (Future<Integer> future : set) {
            try {
                sum += future.get();
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (ExecutionException e) {
                e.printStackTrace();
            }
        }
        System.out.println("数组中所有数字的和为：" + sum);
    }


}


class testCallable implements Callable<Integer>{
    private int val;

    public testCallable(int val){

        this.val = val;
    }

    @Override
    public Integer call() throws Exception {
        System.out.println(Thread.currentThread().getName() + ": 开始执行！" );
        try {
            //假设处理需要2秒
            Thread.currentThread().sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + ": 正在处理！" );
        System.out.println(Thread.currentThread().getName() + ": " +  "本线程处理的数字为：" + val);
        return val;
    }
}

 

参考：

1.https://blog.csdn.net/dreamcatchergo/article/details/36024489

2.https://www.cnblogs.com/dolphin0520/p/3949310.html

3.《实战java高并发程序设计》

4.https://www.cnblogs.com/felixzh/p/6036074.html