文章目录

• 一、创建任务和线程的方式
• 二、三种方式的代码实现
• • • 方法一：通过实现Runnable接口创建线程
    • 方法二：通过继承Thread类创建线程
    • 方法三：使用Callable和Future来创建线程
    • 方法四：通过线程池来创建线程
• 三、Java中何时会出现线程调度？
• 四、线程和方法调用栈

---

提示：以下是本篇文章正文内容，Java系列学习将会持续更新

一、创建任务和线程的方式

1.Java线程在代码中是如何体现的
  java.lang.Thread类(包括其子类)的一个对象 Thread——线程
2.如何在代码中创建线程(最基本) Runnable——让这个线程去完成的工作 (任务)
  ①先创建任务类，并实现Runhable接口。
   创建任务类对象。
   创建Thread对象，并将任务类对象传入其中。
  ②创建任务类对象直接继承Thread类。
   实例化该任务类对象。
  ③直接创建Thread对象，并实现Runnable接口。
3.启动线程
  调用Thread对象的start()方法。
  我们写的无论是Thread的子类还是Runnable的实现类，只是给线程启动的“程序”。
  所以，同一个程序，可以启动多个线程。

二、三种方式的代码实现

方法一：通过实现Runnable接口创建线程

public class Achieve_Runnable {
    public static void main(String[] args) {
		
		// Thread实例中传入任务类
        Runnable task1 = new PrintA();
        Thread t1 = new Thread(task1);

        // 以匿名内部类的方式实现Runnable接口
        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 100; i++) {
                    System.out.print("* ");
                }
            }
        });

        // 以lamoda表达式的方式实现Runnable接口
        Thread t3 = new Thread(() -> {
            for (int i = 0; i < 100; i++) {
                System.out.print("$ ");
            }
        });

        t1.start();
        t2.start();
        t3.start();
    }
}

class PrintA implements Runnable {
    @Override
    public void run() {
        // 打印100个A
        for (int i = 0; i < 100; i++) {
            System.out.print("A ");
        }
    }
}

回到目录…

方法二：通过继承Thread类创建线程

public class Extend_Thread {
    public static void main(String[] args) {
        Thread t = new PrintOne();
        t.start();
    }
}

class PrintOne extends Thread {
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.print(1 + " ");
        }
    }
}

回到目录…

方法三：使用Callable和Future来创建线程

注意：和Runnable接口不一样，Callable接口提供了一个call()方法来作为线程的执行体，call()方法比run()方法功能要更加强大，call()方法可以有返回值，call()方法可以声明抛出异常（前两种如果要抛异常只能通过try-catch来实现）。

步骤：

1. 创建Callable接口的实现类，并实现call()方法，然后创建该类的实例
2. 使用FutureTask类来包装Callable对象。该FutureTask对象封装了Callable对象的call()方法的返回值
3. 使用FutureTask对象作为Thread对象的target创建并启动线程（因为FutureTask实现了Runnable接口并在重写的run方法中执行call方法）
4. 调用FutureTask对象的get方法来获取线程执行结束后的返回值

import java.util.concurrent.*;

class PrintA implements Callable {
    @Override
    public String call() throws Exception {
        for (int i = 0; i < 100; i++) {
            System.out.print("A ");
        }
        return "yes";
    }
}

public class Main {
    public static void main(String[] args) throws ExecutionException, InterruptedException {

        Callable callable = new PrintA();
        FutureTask futureTask = new FutureTask(callable);
        Thread t = new Thread(futureTask);

        // 启动线程
        t.start();
        // 输出返回值
        System.out.println(futureTask.get());
    }
}

回到目录…

方法四：通过线程池来创建线程

public class Main {
    public static void main(String[] args) {
        // 定长线程池
        ExecutorService service1 = Executors.newFixedThreadPool(30);
        // 定时线程池
        ExecutorService service2 = Executors.newScheduledThreadPool(30);
        // 可缓存线程池
        ExecutorService service3 = Executors.newCachedThreadPool();
        // 单线程化线程池
        ExecutorService service4 = Executors.newSingleThreadExecutor();
        // 自定义线程池
        ExecutorService service5 = new ThreadPoolExecutor(10, 30, 30, TimeUnit.SECONDS, new ArrayBlockingQueue<>(30));
    }
}

回到目录…

三、Java中何时会出现线程调度？

1.CPU空闲
  1.当前运行着的CPU执行结束了  运行->结束
  2.等待外部条件  运行->阻塞
  3.主动放弃  运行->就绪
2.被调度器主动调度
  1.高优先级线程抢占
  2.时间片耗尽(这个情况最常见)

四、线程和方法调用栈

栈：当前执行流在当前时刻的状态框（方法调用的次序）。
栈帧：运行方法时所需要的一些临时数据。
每个线程都有自己独立的调用栈。

程序=指令+数据
  调用的是同一个方法:说明执行的是同一批指令，把两个数相加并返回
  栈不同(帧不同) :说明执行指令时，要处理的数据是不同
      main: 10 + 20
      sub:1+2

回到目录…

---

总结:
提示：这里对文章进行总结：
以上就是今天的学习内容，本文是Java多线程与并发的学习，介绍Java中创建并开启线程的三种方式、了解方法调用栈。之后的学习内容将持续更新！！！