创建线程的四种方式

1.继承Thread类（缺点：无法再继承其他的类）

通过继承Thread类，重写run方法实现。主方法先把MyThread创建出来，然后“.start()”把线程放到预备队列。

public class CreateThread {
    public static void main(String[] args) {
        Thread myThread = new MyThread();
        myThread.start();
        System.out.println("完成完成完成完成完成")
    }
}

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

2.实现Runnable接口（优点：可以继承其他的类）

也可以通过lambda表达式实现，也是重写run方法，要放到new Thread（）参数中，才能使用，第二个参数可以写线程的名字。
lambda表达式“（）”是所需参数，“{ }”是表达式所需返回的内容。

public class CreateThread {
    public static void main(String[] args) {
        Runnable r1 = () -> {
            for (int i =0;i<10;i++){
                System.out.println("线程2："+i);
            }
        };

        Thread thread1 = new Thread(r1);
        thread1.start();

        thread1.setName("thread11111111111");
        System.out.println(thread1.getName());

    }
}

3.实现Callable<>接口，该接口有返回值

重写里头的call（）方法，new出来后，通过FutureTask<>（）调用，然后放到new Thread(futureTask).start()中，其返回值通过futureTask.get()接收。

public class TestCall {
    public static void main(String[] args) {
        CallThread callThread = new CallThread();
        FutureTask<Integer> futureTask = new FutureTask<>(callThread);
        new Thread(futureTask).start();
        try {
            int sum = futureTask.get();
            System.out.println(sum);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}

class CallThread implements Callable<Integer>{

    @Override
    public Integer call() throws Exception {
        int resutl = 0;
        for (int i=0;i<100;i++){
            resutl += i;
            System.out.println(resutl);
        }
        return resutl;
    }
}

4.使用线程池创建（减少开销）

方法一：
通过Executors创建，有三种方法：

• Executors.newCachedThreadPool()（无界线程池，可以进行自动线程回收）
• Executors.newFixedThreadPool(int)（固定大小线程池）
• Executors.newSingleThreadExecutor()（单个后台线程）

实现Runnable接口，然后通过service.submit(poolDemo)提交，线程需要通过service.shutdown()关闭。

package JUC;

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

public class TestThreadPool {
    public static void main(String[] args) {
        ExecutorService service = Executors.newFixedThreadPool(5);

        ThreadPoolDemo poolDemo = new ThreadPoolDemo();

        service.submit(poolDemo);

        service.shutdown();
    }
}

class ThreadPoolDemo implements Runnable{

    @Override
    public void run() {
        for (int i = 0; i< 10;i++){

            System.out.println(Thread.currentThread().getName() + i);
        }
    }
}

方法二：（调度功能）
通过Executors.newScheduledThreadPool(5)创建，参数指定线程数，比方法一多了个调度功能，可以指定时延或者定时执行，pool.schedule(poolDemo1,5,TimeUnit.MILLISECONDS)，第二个参数为时间，后面是时间的单位。

import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;


public class TestSchedule {
    public static void main(String[] args) {
        ThreadPoolDemo1 poolDemo1 = new ThreadPoolDemo1();
        ScheduledExecutorService pool = Executors.newScheduledThreadPool(5);
        pool.schedule(poolDemo1,5,TimeUnit.MILLISECONDS);
        pool.shutdown();
    }

}

class ThreadPoolDemo1 implements Runnable {

    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {

            System.out.println(Thread.currentThread().getName()+ "  :  " + i);
        }
    }
}