Java基础进阶多线程-四种创建方式

1、分析以下程序,有几个线程,除垃圾回收线程之外。有几个线程?

1个线程。(因为程序只有1个栈。)
一个栈中,自上而下的顺序依次逐行执行!

内存图分析:

示例代码01:

在这里插入图片描述

public class ThreadTest01 {
    public static void main(String[] args) {
        System.out.println("main begin");
        m1();
        System.out.println("main over");
    }

    private static void m1() {
        System.out.println("m1 begin");
        m2();
        System.out.println("m1 over");
    }

    private static void m2() {
        System.out.println("m2 begin");
        m3();
        System.out.println("m2 over");
    }

    private static void m3() {
        System.out.println("m3 execute!");
    }
}
运行结果:
main begin
m1 begin
m2 begin
m3 execute!
m2 over
m1 over
main over

2、线程创建的第一种方式:(继承Thread类)

编写一个类,直接继承java.lang.Thread,重写run方法。

怎么创建线程对象? new就行了。
怎么启动线程呢? 调用线程对象的start()方法。

run()方法的作用是:

  • 调用run方法不会开启分支线程,不会开辟新的分配栈(相当于单线程)

start()方法的作用是:

  • 启动一个分支线程,在JVM中开辟一个新的栈空间,这段代码任务完成之后,瞬间就结束了。

  • 调用start方法开启一个新的栈空间,只要新的栈空间开出来,start()方法就结束了。线程就启动成功

  • 启动成功的线程会自动调用run方法,并且run方法在分支栈的栈底部(压栈)。

  • run方法在分支栈的栈底部,main方法在主栈的栈底部。run和main是平级的。
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

示例代码02:

public class ThreadTest02 {
    public static void main(String[] args) {

        // 这里是main方法,这里的代码属于主线程,在主栈中运行。
        //创建分支线程对象
        MyThread myThread = new MyThread();

        //开启分支线程
        // 启动线程
        //myThread.run(); // 不会启动线程,不会分配新的分支栈。(这种方式就是单线程。)
        // start()方法的作用是:启动一个分支线程,在JVM中开辟一个新的栈空间,这段代码任务完成之后,瞬间就结束了。
        // 这段代码的任务只是为了开启一个新的栈空间,只要新的栈空间开出来,start()方法就结束了。线程就启动成功了。
        // 启动成功的线程会自动调用run方法,并且run方法在分支栈的栈底部(压栈)。
        // run方法在分支栈的栈底部,main方法在主栈的栈底部。run和main是平级的。
        myThread.start();//立马结束,开始执行线程内容

        //运行主线程// 这里的代码还是运行在主线程中。
        for(int i=0;i<100;i++){
            System.out.println("主线程: " + i);
        }
    }
}

class MyThread extends Thread {

    @Override
    public void run() {
        // 编写程序,这段程序运行在分支线程中(分支栈)。
            for(int i=0;i<100;i++){
                System.out.println("分支线程: " + i);
            }
        }

}

运行结果:

在这里插入图片描述

3、线程创建的第二种方式:(Runnable接口)

  • 编写一个类,实现java.lang.Runnable接口,实现run方法。

  • 采用匿名内部类的方式创建多线程,创建线程对象,以匿名内部类的方式创建多线程

示例代码03:

public class ThreadTest03 {

    public static void main(String[] args) {

        //创建MyRunnable对象// 创建一个可运行的对象
        //MyRunnable m = new MyRunnable();

        //创建线程类,把MyRunnable类传到Thread类的构造器中// 将可运行的对象封装成一个线程对象
        //Thread t = new Thread(m);

        //合并代码
        Thread t = new Thread(new MyRunnable());

        //启动线程
        t.start();

        //执行主线程任务
        for(int i=0;i<100;i++){
            System.out.println("主线程: " + i);
        }

    }
}

// 这并不是一个线程类,是一个可运行的类。它还不是一个线程。
class MyRunnable implements Runnable{

    @Override
    public void run() {
        for(int i=0;i<100;i++){
            System.out.println("分支线程: " + i);
        }
    }
}

运行结果:

在这里插入图片描述

示例代码04:

/*
* 采用匿名内部类的方式创建多线程
* */
public class ThreadTest04 {
    public static void main(String[] args) {

        //创建线程对象,以匿名内部类的方式创建多线程
        // 这是通过一个没有名字的类,new出来的对象。
        Thread t = new Thread(new Runnable() {
            @Override
            public void run() {
                //执行分支线程任务
                for(int i=0;i<100;i++){
                    System.out.println("分支线程: " + i);
                }
            }
        });

        //启动线程
        t.start();

        //执行主线程任务
        for(int i=0;i<100;i++){
            System.out.println("主线程: " + i);
        }
    }
}

运行结果:

在这里插入图片描述

4、线程创建的第三种方式:(callable接口)

  • 实现Callable接口
  • 这种方式的优点:可以获取到线程的执行结果。
  • 这种方式的缺点:效率比较低,在获取t线程执行结果的时候,当前线程受阻塞,效率较低。

示例代码:

public class ThreadTest15 {
    public static void main(String[] args) {

        //创建一个”未来任务类对象“
        // 第一步:创建一个“未来任务类”对象。
        // 参数非常重要,需要给一个Callable接口实现类对象。
        FutureTask f = new FutureTask(new Callable() {
            @Override
            public Object call() throws Exception {// call()方法就相当于run方法。只不过这个有返回值
                // 线程执行一个任务,执行之后可能会有一个执行结果
                // 模拟执行
                System.out.println("call method begin!");
                Thread.sleep(1000 * 10);
                System.out.println("call method over!");
                int a = 30;
                int b = 20;
                return a - b;//自动装箱(300结果变成Integer)
            }
        });

        //创建线程对象
        Thread t = new Thread(f);

        //启动线程
        t.start();

        //获取分支线程的名字
        Object name = null;
        try {
            // 这里是main方法,这是在主线程中。
            // 在主线程中,怎么获取t线程的返回结果?
            // get()方法的执行会导致“当前线程阻塞”
            name = f.get();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
        System.out.println(name);

        // main方法这里的程序要想执行必须等待get()方法的结束
        // 而get()方法可能需要很久。因为get()方法是为了拿另一个线程的执行结果
        // 另一个线程执行是需要时间的。
        System.out.println("HelloWorld!");
    }
}

运行结果:

在这里插入图片描述

5、线程创建的第四种方式(线程池):

JDK5.0 新增线程创建方式,使用线程池

  • 背景:经常创建和销毁、使用量特别大的资源,比如并发情况下的线程, 对性能影响很大。

  • 思路:提前创建好多个线程,放入线程池中,使用时直接获取,使用完 放回池中。可以避免频繁创建销毁、实现重复利用。类似生活中的公共交 通工具。

  • 好处:提高响应速度(减少了创建新线程的时间)

  • 降低资源消耗(重复利用线程池中线程,不需要每次都创建)

  • 便于线程管理

    • corePoolSize:核心池的大小
    • maximumPoolSize:最大线程数
    • keepAliveTime:线程没有任务时最多保持多长时间后会终止

线程池相关API

  • JDK 5.0起提供了线程池相关API:ExecutorService 和 Executors

  • ExecutorService:真正的线程池接口。常见子类ThreadPoolExecutor

    • void execute(Runnable command) :执行任务/命令,没有返回值,一般用来执行 Runnable
    • Future submit(Callable task):执行任务,有返回值,一般又来执行 Callable
    • void shutdown() :关闭连接池
  • 1
    点赞
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

五度鱼学Java

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值