2022-08-02第一小组 孔海波 学习笔记

今日学习情况：理解
心情：80%

多线程

实现多线程的方法

       线程的实现方法有三种，分别时继承Thread类并且重写run()方法、实现Runnable接口并且实现run()方法、最后就是实现Callable接口并实现call()方法。
       第一种实现方法，继承Thread类：

public class Boke {
    public static void main(String[] args) {
        MyThreadOne myThreadOne = new MyThreadOne();
        myThreadOne.start();//启动线程
    }
}
class MyThreadOne extends Thread{
    @Override
    public void run() {
        System.out.println("一个线程开启了");
    }
}

       第二种实现方法， 实现Runnable接口，由于Runable接口只有一个run的抽象方法，所以我们实现后无法启动线程，我们需要创建一个Thread对象，在实例化对象时调用带参的构造函数，将我们创建的实现Runnable的对象作为参数传入，再调用Thread对象去开启线程：

public class Boke {
    public static void main(String[] args) {
        MyThreadTow myThreadTow = new MyThreadTow();
        Thread thread = new Thread(myThreadTow);
    }
}

class MyThreadTow implements Runnable{
    @Override
    public void run() {
        System.out.println("另一个线程开启了");
    

       第三种实现方法，实现Callable接口，实现Callable后我能就需要重写其中的call()方法，因为Callable也只一个抽象方法，所以我们也需要依靠Thread类去开启线程，但是Thread的构造函数中并没有带Callable类型参数的构造函数，所以我们需要生成FutureTask对像，实例化时将实现Callable接口类的对象作为参数传入构造函数。因为FutureTask是间接实现于Runable接口，所以可以传入Thread的构造函数中：

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

public class Boke {
    public static void main(String[] args) {
        MyThreadThree myThreadThree = new MyThreadThree();
        FutureTask futureTask = new FutureTask<>(myThreadThree);
        Thread thread = new Thread(futureTask);
    }
}

class MyThreadThree implements Callable<String>{
    @Override
    public String call() throws Exception {
        System.out.println("第三个线程开启了");
        return "";
    }
}

线程的生命周期

* NEW：这个状态主要是先未被star（）调用；
* RUNNABLE”线程正在JVM被执行，等待来自操作系统的调度
* BLOCKED：阻塞，因为某些原因需要挂起。（外部原因，等待一般都是主动等待，等待还可以传入参数确定等待时间）
* WAITING：无限期等待，依赖于Object类，若果没有唤醒就一直等待
* TIMED_WAITING:有限期等待，线程指定一个时间等待
* TERMINATED：终止线程的状态，线程已经执行完毕