【操作系统】创建线程的方式

学习目标：

目标：掌握操作系统知识

---

学习内容：

本文内容：创建线程的方式

---

创建线程的方式主要有3种：

1. 继承Thread类，重写Thread中的run()方法
2. 实现Runnable接口，重写run()方法
3. 实现Callable接口，重写call()方法

1创建线程的方法一 ： 继承Thread类

1.1 写法一

public class ThreadDemo01 {
    static class MyThread extends Thread{
        @Override
        public void run() {
            System.out.println("我是一个线程");
            while(true){}
        }
    }
    public static void main(String[] args) {
        Thread t=new MyThread();
        t.start();
        while(true){}
    }
}

运行结果：

在ThreadDemo01中使用了类继承了Thread类，并重写了Thread类中的run()方法，run()方法就是创建出一个任务，然后加了两个死循环让线程一直运行下去，我们就可以使用jconsole观察线程的运行情况

下图就是当前类中的main线程的运行状态

下图是继承Thread类创建的新线程的运行状态

1.2 写法二

public class NewThread {
    public static void main(String[] args) {
        //匿名内部类+Thread的方式创建一个线程
        Thread t = new Thread("我是刚创建的线程"){
            @Override
            public void run() {//线程要执行的任务
                while (true){}
            }
        };
        t.start();
    }
}

第二种方法写着比较简单，其中Thread t = new Thread(“我是刚创建的线程”)中的参数可以指定新线程的名字，更方便在jconsole中观察，如图，直接可以看到线程的名称

2 创建线程的方法二 ：实现Runnable接口

Runnable是Java中任务的概念，new一个Runnable，就是定义一个任务的描述，再传入Thread线程中执行

public class NewRunnable {
    public static void main(String[] args) {
        //使用Runnable接口创建一个任务，在创建线程
        Runnable r = new Runnable() {
            @Override
            public void run() {
                System.out.println("ok");
            }
        };
        Thread t = new Thread(r);
        t.start();

        //以上合并的写法
        Thread tt = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("合并写法");
            }
        });
        tt.start();
    }
}

运行结果

3 创建线程的方法三：实现Callable接口

实现Callable接口，重写call()方法，call()方法具有返回值，这种创建线程的方式提供了一种获取线程返回结果的方式，需要借助FutureTask类

public class CallableTest {

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //Callable为任务描述，提供了任务执行完毕的返回结果
        Callable<Integer> c = new Callable<Integer>() {
            @Override
            public Integer call() throws Exception {
                System.out.println(1);
                return 2;
            }
        };
        //Future/FutureTask，构造时，传入Callable对象，本身是Runnable实现类
        FutureTask task = new FutureTask(c);
        Thread t=new Thread(task);
        t.start();
        System.out.println(3);
        // 使用get()方法会让当前线程阻塞等待，直到其他线程执行完毕（和join类似），返回结果
        System.out.println(task.get());
    }
}

运行结果：

将以上代码的后两行交换后

public class CallableTest {

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //Callable为任务描述，提供了任务执行完毕的返回结果
        Callable<Integer> c = new Callable<Integer>() {
            @Override
            public Integer call() throws Exception {
                System.out.println(1);
                return 2;
            }
        };
        //Future/FutureTask，构造时，传入Callable对象，本身是Runnable实现类
        FutureTask task = new FutureTask(c);
        Thread t=new Thread(task);
        t.start();
       
        // 使用get()方法会让当前线程阻塞等待，直到其他线程执行完毕（和join类似），返回结果
        System.out.println(task.get());
        System.out.println(3);
    }
}

运行结果：

会发现get()方法会让线程阻塞，等其他线程执行完毕之后，才继续执行，和join()方法类似

4 创建线程的其他方法

使用lambda表达式创建线程会更方便一点

public class ThreadDemo04 {
    public static void main(String[] args) {
        Thread t=new Thread(()->{
            System.out.println("我是一个线程");
            while(true){

            }
        },"这是线程的名字");
        t.start();
    }
}