Java中如何实现多线程，创建并开启新的线程-Toy模板网

这篇具有很好参考价值的文章主要介绍了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来实现）。

步骤：

创建Callable接口的实现类，并实现call()方法，然后创建该类的实例
使用FutureTask类来包装Callable对象。该FutureTask对象封装了Callable对象的call()方法的返回值
使用FutureTask对象作为Thread对象的target创建并启动线程（因为FutureTask实现了Runnable接口并在重写的run方法中执行call方法）
调用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