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

╰+哭是因爲堅強的太久メ 2023-10-08 16:54 14阅读 0赞

#### 文章目录 ####

*   *  1、分析以下程序，有几个线程，除垃圾回收线程之外。有几个线程？
     *   *  示例代码01：
     *  2、线程创建的第一种方式：（继承Thread类）
     *   *  示例代码02:
         *  运行结果：
     *  3、线程创建的第二种方式：（Runnable接口）
     *   *  示例代码03：
         *  运行结果：
         *  示例代码04：
         *  运行结果：
     *  4、线程创建的第三种方式：（callable接口）
     *   *  示例代码：
         *  运行结果：
     *  5、线程创建的第四种方式（线程池）：

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

1个线程。（因为程序只有1个栈。）  
一个栈中，自上而下的顺序依次逐行执行！

内存图分析：

#### 示例代码01： ####

![在这里插入图片描述][0b7c822237b74023a3085d4c64af8ff6.png_pic_center]

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是平级的。  
    ![在这里插入图片描述][75273895110a4630837eb7130fa8dfc9.png_pic_center]  
    ![在这里插入图片描述][671e5d20c5564a57b339a9c4a92af276.png_pic_center]  
    ![在这里插入图片描述][524931869b6144f6bc7b080a4524880f.png_pic_center]

#### 示例代码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);
                }
            }
    
    }

#### 运行结果： ####

![在这里插入图片描述][4a1f6eb9823b400c81a8ba2ce86e7fe8.png]

### 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);
            }
        }
    }

#### 运行结果： ####

![在这里插入图片描述][ac09a233506f4b778b51e4d37ac952c2.png]

#### 示例代码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);
            }
        }
    }

#### 运行结果： ####

![在这里插入图片描述][3a527a66cb534e948dcb1d33771c93f2.png]

### 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!");
        }
    }

#### 运行结果： ####

![在这里插入图片描述][97b7bb9f1df648eaa7ee622a0a2bf8c6.png]

### 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() ：关闭连接池

[0b7c822237b74023a3085d4c64af8ff6.png_pic_center]: https://img-blog.csdnimg.cn/0b7c822237b74023a3085d4c64af8ff6.png#pic_center
[75273895110a4630837eb7130fa8dfc9.png_pic_center]: https://img-blog.csdnimg.cn/75273895110a4630837eb7130fa8dfc9.png#pic_center
[671e5d20c5564a57b339a9c4a92af276.png_pic_center]: https://img-blog.csdnimg.cn/671e5d20c5564a57b339a9c4a92af276.png#pic_center
[524931869b6144f6bc7b080a4524880f.png_pic_center]: https://img-blog.csdnimg.cn/524931869b6144f6bc7b080a4524880f.png#pic_center
[4a1f6eb9823b400c81a8ba2ce86e7fe8.png]: https://img-blog.csdnimg.cn/4a1f6eb9823b400c81a8ba2ce86e7fe8.png
[ac09a233506f4b778b51e4d37ac952c2.png]: https://img-blog.csdnimg.cn/ac09a233506f4b778b51e4d37ac952c2.png
[3a527a66cb534e948dcb1d33771c93f2.png]: https://img-blog.csdnimg.cn/3a527a66cb534e948dcb1d33771c93f2.png
[97b7bb9f1df648eaa7ee622a0a2bf8c6.png]: https://img-blog.csdnimg.cn/97b7bb9f1df648eaa7ee622a0a2bf8c6.png