进程与线程（chapter14）2022-07-06

进程与线程的区别

进程（process）是操作系统的任务单元，每一个程序启动后，操作系统都会为其分配进程编号PID

线程（Thread）是进程中的任务单元，程序启动的时候，首先会创建主线程，可以在主线程中开辟子线程，每一个线程都都对应一个虚拟机栈，栈是线程私有的，堆和方法区是线程共享的

串行

        在一台机器上单线程执行

并行

        并发：在同一台机器上多线程并行执行（存在资源竞争关系）

        并行：在多台的机器上并行执行（不存在资源竞争关系）

Java中实现多线程的方式有4种

重写：父类有返回异常，子类也要有返回异常 

创建线程的几种方式

1.继承Thread类，重写run方法

public static void main(String[] args) {
        System.out.println("主线程开始");
        MyThread mt =new MyThread();//开辟子线程
        mt.start();
        System.out.println("主线程结束");

    }
    //内部类
    static class MyThread extends Thread{
        @Override
        public void run() {
            System.out.println("子线程开始");
            try {
                Thread.sleep(10000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("子线程结束");
        }
    }

2.实现Runnable接口，重写run方法

public static void main(String[] args) {
        System.out.println("主线程开始");
        MyRunnable mr = new MyRunnable();//创建Runnable对象
        Thread t = new Thread(mr);//用官方的Thread类创建线程对象，并把Runnable对象作为Thread构造方法的参数
        t.start();//调用start
        //t.run();
        System.out.println("主线程结束");
    }

    static class MyRunnable implements Runnable{

        //静态内部类
        //实现线程的方式2.实现Runnable接口，重写run方法
        // Dogde 父类是Aniaml，这时候Dog还能继承Thread吗？
        // 官方的意思是：当一个类已经有父类了，此时不方便继承Thread，可以采用实现Runnable接口的方式
        @Override
        public void run() {
            System.out.println("子线程开始");
            try {
                Thread.sleep(10000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("子线程结束");
        }
    }

3.实现Callable接口，重写call方法

public static void main(String[] args) {
        MyCallable mc = new MyCallable();//创建一个Callable对象
        FutureTask<Integer> ft = new FutureTask<>(mc);//创建一个FutureTask对象，用Callable对象作为构造方法（）
//        System.out.println("主线程开始");
        Thread t = new Thread(ft);//创建一个Thread对象，用FutureTask对象作为构造方法的参数
        t.start();
//      用FutureTask对象的get（）方法取子线程call方法的返回值
        
//        Integer sum = ft.get();会阻塞主线程，主线程没有运算结束，没有返回值
            while (true){
                try{
                    if (ft.isDone()){//isDone()方法可以判定子线程有没有运行结束
                        Integer sum = ft.get();//在取子线程返回值的时候，子线程可以正常返回，也可以异常返回
                        System.out.println("子线程返回值："+ sum);
                        break;
                    }else{
                        System.out.println("子线程未结束");
                        
                    }
                }
                catch (Exception e){
                    e.printStackTrace();
                }
            }


//        System.out.println("主线程结束");
    }


    //静态内部类
    //实现线程的方式3.实现Callable接口，重写call方法
    // 需要指定泛型,这个泛型是作为子线程返回值得数据类型
    // 实现线程的方式1和方式2都无法实现子线程运行结束后返回一个结果，因为run方法的返回值类型是void
    static class MyCallable implements Callable<Integer>{

        @Override
        public  Integer call() throws Exception {
            Integer sum = 0;
            for (int i = 0; i < 100; i++) {
                sum += i;
                Thread.sleep(100);
            }
            return sum;
        }
    }

4.使用线程池类

 

 

 

线程的生命周期状态

1.新建（new）：

新创建了一个线程对象

2.可运行（runnable）：

线程对象创建后，当调用线程对象的start（）方法，该线程处于就绪状态，等待被线程调度选中，获取cpu的使用权

3.运行（running）：

可运行状态（runnable）的线程获得了cpu时间片（timeslice），执行程序代码，注：就绪状态是进入到运行状态的唯一入口，也就是说，线程要想进入运行状态执行，首先必须处于就绪状态中；

4.阻塞（block）：

处于运行状态中的线程由于某种原因，暂时放弃对CPU的使用权，停止执行，此时进入阻塞状态，直到其进入到就绪状态，才有机会再次被cpu调用以进入到运行状态

    阻塞的情况分两种：

    1.阻塞时候释放锁

    2.阻塞时候不释放锁

5.死亡（dead）：

线程run（）、main（) 方法执行结束，或者因异常退出了run（）方法，则该线程结束生命周期，死亡的线程不可以再次复生。