创建线程的四种方式

1.继承Thread类，重写run()方法；
2.实现Runnable接口，重写run()方法；
3.实现Callable接口，重写call()方法；
4.使用线程池创建线程；

一、继承Thread类
步骤：
1.创建一个类继承Thread类，重写其run()方法，在run(）方法中编写需要执行的任务；
2.创建继续Thread类的对象；
3.调用其对象的start()方法，该方法表示启动一个线程，线程处于就绪状态，如果获取到cpu执行权，则会调用run()方法，执行对应的任务；

public class ThreadDemo extends Thread{
    private Thread t;
    private String threadName;
    ThreadDemo(String name)
    {
        threadName = name;
        System.out.println("创建" +  threadName );
    }
    @Override
    public void run(){
        System.out.println("运行"+threadName);
        try{
            for(int i = 4; i > 0; i--){
                System.out.println("线程"+threadName+","+i);
                Thread.sleep(50);
            }
        }catch (InterruptedException e){
            System.out.println("线程"+threadName+"中断");
        }
        System.out.println("线程"+threadName+"退出");
    }

    public void start(){
        System.out.println("启动"+threadName);
        if(t==null){
            t = new Thread(this,threadName);
            t.start();
        }
    }
}

public class ThreadTest {
    public static void main(String[] args) {
        ThreadTest();
    }

    private static void ThreadTest() {
        ThreadDemo T1 = new ThreadDemo("Thread-->1");
        T1.start();
        ThreadDemo T2 = new ThreadDemo("Thread-->2");
        T2.start();
    }
}

二、实现Runnable接口
步骤：
1.创建一个类，实现Runnable接口，重写run()方法，编写需要执行的代码；
2.创建一个Runnable接口实现类的对象；
3.将此对象作为形参传递到Thread类的构造器中，创建Thread类的对象，调用start()方法，启动线程；

public class RunnableDemo implements Runnable{
    private Thread t;
    private String threadName;
    RunnableDemo(String name){
        threadName = name;
        System.out.println("创建 " + threadName);
    }

    @Override
    public void run() {
        System.out.println("运行 " + threadName);
        try {
            for (int i = 4; i > 0; i--) {
                System.out.println("线程 " + threadName + ", " + i);
                Thread.sleep(50);
            }
        }catch (InterruptedException e){
            System.out.println("线程 " + threadName + " 运行中");
        }
        System.out.println("线程 " + threadName + " 运行结束");
    }

    public void start(){
        System.out.println("启动线程"+ threadName);
        if(t==null){
            t=new Thread(this,threadName);
            t.start();
        }
    }
}

public class ThreadTest {
    public static void main(String[] args) {
       runnableTest();
    }


    private static void runnableTest() {
        RunnableDemo R1=new RunnableDemo("runnableThread-->1");
        R1.start();
        RunnableDemo R2=new RunnableDemo("runnableThread-->2");
        R2.start();
    }
}

三、实现Callable接口
步骤：
1.创建Callable接口的实现类，并实现call()方法，该方法具有返回值，并且可以抛异常；
2.创建Callable实现类的实例，并使用FutureTask类来包装Callable对象，该FutureTask对象封装了该Callable对象的call()方法的返回值；
3.使用FutureTask对象作为Thread对象的target创建并启动新线程；
4.调用FutureTask对象的get()方法来获取子线程执行结束后的返回值；

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

public class CallableThreadTest implements Callable<Integer> {

    public static void main(String[] args)
    {
        CallableThreadTest ctt = new CallableThreadTest();
        FutureTask<Integer> ft = new FutureTask<>(ctt);
        for(int i = 0;i < 10;i++)
        {
            System.out.println(Thread.currentThread().getName()+" 的循环变量i的值"+i);
            if(i==5)
            {
                new Thread(ft,"有返回值的线程").start();
            }
        }
        try
        {
            System.out.println("子线程的返回值："+ft.get());
        } catch (InterruptedException e)
        {
            System.out.println("发生异常");
        } catch (ExecutionException e)
        {
            System.out.println("发生异常");
        }

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

Callable 和 Runnable接口的区别

1. Callable规定的方法是call()，而Runnable规定的方法是run()。
2. Callable的任务执行后可返回值，而Runnable的任务是不能返回值的。
3. call()方法可抛出异常，而run()方法是不能抛出异常的。

 四，线程池创建线程

我这里用newFixedThreadPool:创建一个固定数量的线程池

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

public class ThreadPool {
    public static void main(String[] args) {
        ExecutorService executor = Executors.newFixedThreadPool(5);
        for (int i = 0; i < 2; i++) {
            executor.execute(new Runnable() {
                @Override
                public void run() {
                    System.out.println("线程名： " + Thread.currentThread().getName() + " is running");
                }
            });
        }
    }
}