线程的创建方法

方法1 继承Thread类并重写run

1. 继承 Thread 来创建一个线程类.，并重写run方法

class MyThread extends Thread { 
    @Override
    public void run() {
        System.out.println("这里是线程运行的代码"); 
    }
}

2. 创建 MyThread 类的实例

MyThread t = new MyThread();
//或者
//Thread t = new MyThread();

3. 调用 start 方法启动线程

t.start();  // 线程开始运行

创建mythread类并继承thread并重写run方法；实例化一个mythread为对象t，并调用t。start方法

方法2 实现Runnable接口

1. 实现 Runnable 接口

class MyRunable implements Runnable{
    public void run(){
    }
}

2. 创建 Thread 类实例, 调用 Thread 的构造方法时将 Runnable 对象作为 target 参数

Thread t = new Thread(new MyRunnable());

3. 调用 start 方法

t.start();  // 线程开始运行

示例

package thread;
//Runable的作用是描述一个要执行的任务，run方法就是任务的执行细节。
class MyRunable implements Runnable{
    public void run(){
        System.out.println("执行Runable");

    }
}

public class ThreadDemo2 {
    public static void main(String[] args) {
        Runnable runnable =  new MyRunable();
        Thread t = new Thread(runnable);
        t.start();
    }
}

构建myRunable类实现runable接口，重写run方法，主函数实例化myRunable,将实例化对象作为参数传输new thread，执行start方法；

上述两种方式的区别

1. 继承 Thread 类, 直接使用 this 就表示当前线程对象的引用.
2. 实现 Runnable 接口, this 表示的是 MyRunnable 的引用. 需要使用 Thread.currentThread()来获取当前线程对象的引用
3. 在逻辑上就是将线程和线程本身要做的任务分开，也就是解耦合；目的是为了未来如果需要改动代码，不用多线程而使用多进程，线程池等，代码改动会小一点。

同时上述方式可以使用lambada表达式和匿名内部类的方式进行简化

        Thread thread1  = new Thread(new Runnable() {
            @Override
            public void run() {

                while(true){
                    System.out.println("线程方法体1");
                }
            }
        });

        Thread thread2 = new Thread(){
            @Override
            public void run() {
                while(true){
                    System.out.println("线程方法体2");
                }
            }
        };

方法3使用callable接口重写call方法

public class ThreadDemo32 {
    public static void main(String[] args)  {
        Callable<Integer> callable = new Callable<Integer>() {
            @Override
            public Integer call() throws Exception {
                return null;
            }
        };
        FutureTask<Integer> futureTask = new FutureTask<Integer>(callable);
        Thread thread = new Thread(futureTask);
        thread.start();
    }
}

Callable 是一个 interface . 相当于把线程封装了一个 “返回值”. 方便程序猿借助多线程的方式计算 结果.
Callable 和 Runnable 相对, 都是描述一个 “任务”. Callable 描述的是带有返回值的任务,
Runnable 描述的是不带返回值的任务.
Callable 通常需要搭配 FutureTask 来使用. FutureTask 用来保存 Callable 的返回结果. 因为 Callable 往往是在另一个线程中执行的, 啥时候执行完并不确定.FutureTask 就可以负责这个等待结果出来的工作.
所以相对来说，使用callable要少使用很多wait,notify，sychronized

方法4 使用线程池创建线程

线程池的创建方法非常多，我们这里举例几种

使用固定形式的线程
调用Executor类的静态方法newFixedTheadPool，实例化ExcutorSevice 对象
使用ExcutorSevice的成员方法submit注册执行体

public class Test {
    public static void main(String[] args) {
        ExecutorService executors = Executors.newFixedThreadPool(2);
        executors.submit(new Runnable() {
            @Override
            public void run() {
                while(true){
                    System.out.println("线程1");
                }

            }
        });
        executors.submit(new Runnable() {
            @Override
            public void run() {
                while(true){
                    System.out.println("线程2");
                }
            }
        });
        //默认直接抛弃了，所以线程三根本不会提交到线程池中
        executors.submit(new Runnable() {
            @Override
            public void run() {
                while(true){
                    System.out.println("线程3");
                }
            }
        });
    }
}

实例化自定义线程池ThreadPoolExcutor，调用ThreadPoolExcutor的submit方法提交方法体

public class Test {
    public static void main(String[] args) {
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(3, 10, 1, TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(10));
        for (int i = 0; i < 3; i++) {
            int c = i;
            threadPoolExecutor.submit(new Runnable() {
                int d = c;
                @Override
                public void run() {
                    while (true) {
                        System.out.println("线程" + d);
                    }
                }
            });
        }
    }
}