线程的创建方式

 

目录

1、继承Thread类

2、实现Runnable接口

3、实现Callable接口

 4、线程池创建线程

总结

---

线程创建方式有4种

1、继承Thread类

               第一种继承Thread类，重写run()方法

package cn;
class D extends Thread{

    @Override
    public void run() {
        for(int i=0;i<20;i++)
            System.out.println(getName()+"线程: "+i);
    }
}
public class Demo1 {
    public static void main(String[] args) {
        D d=new D();
        d.setName("我是继承实现的");
        d.start();
    }
}

我是继承实现的线程: 0
我是继承实现的线程: 1
我是继承实现的线程: 2
我是继承实现的线程: 3
我是继承实现的线程: 4
我是继承实现的线程: 5
我是继承实现的线程: 6
我是继承实现的线程: 7
我是继承实现的线程: 8
我是继承实现的线程: 9
我是继承实现的线程: 10
我是继承实现的线程: 11
我是继承实现的线程: 12
我是继承实现的线程: 13
我是继承实现的线程: 14
我是继承实现的线程: 15
我是继承实现的线程: 16
我是继承实现的线程: 17
我是继承实现的线程: 18
我是继承实现的线程: 19

2、实现Runnable接口

        第二种实现Runnable接口实现run()方法

package cn;
class E implements Runnable{

    @Override
    public void run() {
        for(int i=0;i<10;i++)
            System.out.println(Thread.currentThread().getName()+"线程: "+i);
    }
}
public class Demo2 {
    public static void main(String[] args) {
        E e=new E();
        Thread t=new Thread(e);
        t.setName("我是实现Runnable的");
        t.start();
    }
}

我是实现Runnable的线程: 0
我是实现Runnable的线程: 1
我是实现Runnable的线程: 2
我是实现Runnable的线程: 3
我是实现Runnable的线程: 4
我是实现Runnable的线程: 5
我是实现Runnable的线程: 6
我是实现Runnable的线程: 7
我是实现Runnable的线程: 8
我是实现Runnable的线程: 9

3、实现Callable接口

        第三种实现Callable接口实现call()方法

package cn;

import java.util.concurrent.Callable;
import java.util.concurrent.FutureTask;

class F implements Callable {

    @Override
    public Object call() throws Exception {
        for(int i=0;i<10;i++){
            System.out.println(Thread.currentThread().getName()+"线程：" +i);
        }
        return null;
    }
}

public class Demo3  {
    public static void main(String[] args) {
        F f=new F();
        FutureTask futureTask=new FutureTask(f);
        Thread t=new Thread(futureTask);
        t.setName("我是实现Callable接口的");
        t.start();
    }

}

我是实现Callable接口的线程：0
我是实现Callable接口的线程：1
我是实现Callable接口的线程：2
我是实现Callable接口的线程：3
我是实现Callable接口的线程：4
我是实现Callable接口的线程：5
我是实现Callable接口的线程：6
我是实现Callable接口的线程：7
我是实现Callable接口的线程：8
我是实现Callable接口的线程：9

 4、线程池创建线程

        最后一种线程池创建线程，创建创建池子把线程丢进去

package cn;


import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadPoolExecutor;

class G implements Runnable{

    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName()+"线程"+i);
        }
    }
}
public class Demo4 {
    public static void main(String[] args) {
        G p=new G();
        G p1=new G();
        ExecutorService executorService = Executors.newFixedThreadPool(10);
        ThreadPoolExecutor t= (ThreadPoolExecutor) executorService;
        executorService.execute(p);
        executorService.execute(p1);
        executorService.shutdown();
    }
}

pool-1-thread-2线程0
pool-1-thread-2线程1
pool-1-thread-2线程2
pool-1-thread-2线程3
pool-1-thread-2线程4
pool-1-thread-2线程5
pool-1-thread-2线程6
pool-1-thread-2线程7
pool-1-thread-2线程8
pool-1-thread-2线程9
pool-1-thread-1线程0
pool-1-thread-1线程1
pool-1-thread-1线程2
pool-1-thread-1线程3
pool-1-thread-1线程4
pool-1-thread-1线程5
pool-1-thread-1线程6
pool-1-thread-1线程7
pool-1-thread-1线程8
pool-1-thread-1线程9

总结

        继承Thread类和实现Runnable优先使用谁？

从本质来说Thread类它也是实现Runnable接口的，但继承具有局限只能单继承。相对而言Thread共享数据需经过处理如加static关键字等一系列处理而Runnable天然的共享数据，建议优先考虑实现接口的方法创建线程。

        Callable和Runnable 比较谁更强大？

从实现run()方法就可以看出Callable 更强大一些，它可以有返回值以及可以抛出异常而Runnable只能捕获异常

        线程池好处

提高响应速度，降低资源消耗，方便管理