多线程的实现

进程：所有运行中的任务通常对应一个进程，当一个程序进入内存运行时，即变成一个进程。
进程包含三个特征：独立性，动态性，并发性

线程：一个程序同时执行多个任务。通常，每一个任务就称为一个线程。与进程相比较，线程更"轻量级"，创建、撤销一个线程比启动一个新进程开销要小的多。没有进程就没有线程，进程一旦终止，其内的线程也将不复存在。
多进程与多线程区别：本质区别在于，每个进程拥有自己的一整套变量，而线程则共享数据。共享变量使得线程之间的通信比进程之间通信更有效、更方便

并发性和并行性是两个不同的概念：
并行：指在同一时刻，有多条指令在多个处理器上同时执行
并发：指在同一时刻只能有一条指令执行，但多个进程指令被快速轮换执行，使得在宏观上具有多个进程同时执行的效果

线程的状态：

解析：线程的创建通过start()方法进行。得到CPU时间片，自动执行run()方法。而不能直接用run()方法，因为run()方法无就绪状态。
启动多线程：public synchronized void start()此方法会自动调用线程的run()方法
在start()方法中调用了start0()方法，而这个方法是一个只声明而未实现的方法同时使用native关键字进行定义。在C++创建了一个线程，让它指向java线程。
native_thread=new JavaThread(&thread_entry,sz);将线程与本地系统关联起来。
注：当线程启动后，线程的代码执行顺序与启动的代码执行顺序无关。
多线程的实现：
1.继承Thread类实现多线程
步骤：
（1）定义Thread类的子类，并重写该类的run()方法，该run()方法的方法体就代表了线程需要完成的任务；
（2）创建Thread子类的实例，即创建了线程对象
（3）调用线程对象的start()方法来创建并启动多线程
代码实现：

package com.zh.R;

public class MyThread extends Thread {
private String title;

    public MyThread(String title) {
        this.title = title;
    }


    @Override
    public void run() {  //所有线程从此处开始执行
        for (int i = 0; i < 10; i++) {
            System.out.println(this.title + " " + i);
        }
    }
}

测试类，创建并启动线程

public class TestMyThread {
    public static void main(String[] args) {
        Thread thread=new MyThread("A");
        thread.start();  //创建并启动线程
        }
}

2. Runnable()接口实现多线程
   步骤：
   （1）定义Runnable接口的实现类，并重写该接口的run()方法
   （2）创建Runnable实现类的实例，并以此实例作为Thread的target来创建Thread对象，该Thread对象才是真正的线程对象
   （3）调用线程对象的start()方法来启动该线程
   Runnable接口对象可以采用匿名内部类或者Lambda表达式来定义。
   使用匿名内部类进行Runnable对象创建：
   代码实现：

public static void main(String[] args) {
 new Thread(new Runnable() {
 @Override
 public void run() {
 System.out.println("Hello World");
 }
 }).start();
 }
}

使用Lamdba表达式进行Runnable对象创建
代码实现：

public static void main(String[] args) {
        new Thread(()->{
            for (int i=0; i<10; i++){
                System.out.println("Thread1 "+i);
            }
        }).start();
            new Thread(() -> System.out.println("Hello Thread")).start();

        }

3. Callable实现多线程（有返回值）
   步骤：
   (1)创建Callable接口的实现类，并实现call()方法，该call()方法将作为线程执行体，且该call()方法有返回值，再创建Callable实现类的特例
   (2)使用FutureTask类来包装Callable对象，该FutureTask对象封装了Callable对象的call()方法的返回值
   注：内部：FutureTask里用的run()方法，run()方法调的call()方法
   （3）使用FutureTask对象作为Thread对象的target创建并启动新线程
   （4）调用FutureTask对象的get()方法来获得子线程执行结束后的返回值
   （注：直接调用get()方法，会造成阻塞，所以一般会给个时间）
   代码实现：

public class MyCallable implements Callable<Integer> {
    @Override
    public Integer call() throws Exception {
        int sum = 0;
        for (int i = 1; i <= 100; i++) {
            sum += i;
        }
        Thread.sleep(1000);
        return sum;
    }
}

测试（main())

public class TestMyCallable {
    public static void main(String[] args) {
        Callable<Integer> callable=new MyCallable();
        //Runnable  -> run  -> void
        //Callable  -> run (异步) -> V(int) 将来

        //FutureTask  -> Runnable
        FutureTask<Integer> futureTask=new FutureTask<>(callable);
        Thread thread=new Thread(futureTask);
        thread.start();
        try {
            Integer sum = futureTask.get(1, TimeUnit.MILLISECONDS);
            System.out.println(sum);
        } catch (InterruptedException e) {//中断
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        } catch (TimeoutException e) {
            e.printStackTrace();
        }
        System.out.println("main结束");

    }
}

三者的特点：
1.继承Thread:
继承类只能单继承，不能再继承其他类（受限于Java的类的继承）
业务实现在run方法中，业务和线程实现耦合
业务是不能共享的
2.实现Runnable接口
解决单继承问题
业务实现和线程实现解耦
业务可以共享
使用Lambda和匿名内部类的匿名对象的方式创建Runnable
run返回值是void，业务有返回值的结果无法处理
3.实现Callable接口
解决单继承问题
业务实现和线程实现解耦
业务可以共享
可以处理返回结果
使用Callable的业务对象，通过FutureTask来获取执行结果。