【大数据】学习笔记 1 Java SE 第9章多线程 9.2 另行创建和启动线程

秒速五厘米 2024-03-22 11:44 33阅读 0赞

### 【大数据】学习笔记 ###

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

*   *  【大数据】学习笔记
     *   *  1 Java SE
         *   *  第9章 多线程
             *   *  9.2 另行创建和启动线程
                 *   *  9.2.1 继承Thread类
                     *  9.2.2 实现Runnable接口
                     *  9.2.3 使用匿名内部类对象来实现线程的创建和启动

![在这里插入图片描述][7a8bd33916114ef1946fafd8657a2666.png_pic_center]

#### 1 Java SE ####

##### 第9章 多线程 #####

###### 9.2 另行创建和启动线程 ######

当运行Java程序时，其实已经有一个线程了，那就是main线程。

/**
     * @Projectname: BigDataStudy
     * @Classname: TestThread
     * @Author: Ding Jiaxiong
     * @Date:2023/4/27 15:43
     */
    
    public class TestThread {
        
    
        public static void main(String[] args) {
        
    
            System.out.println("Hello thread");
    
        }
    
    }

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

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

那么如何创建和启动main线程以外的线程呢？

###### 9.2.1 继承Thread类 ######

Java使用`java.lang.Thread`类代表**线程**，所有的线程对象都必须是Thread类或其子类的实例。每个线程的作用是完成一定的任务，实际上就是执行一段程序流即一段顺序执行的代码。Java使用线程执行体来代表这段程序流。Java中通过继承Thread类来**创建**并**启动多线程**的步骤如下：

1.  定义Thread类的子类，并重写该类的run()方法，该run()方法的方法体就代表了线程需要完成的任务,因此把run()方法称为线程执行体。
2.  创建Thread子类的实例，即创建了线程对象
3.  调用线程对象的start()方法来启动该线程

代码如下：

自定义线程类：

package com.dingjiaxiong.thread;
    
    /**
     * @Projectname: BigDataStudy
     * @Classname: MyThread
     * @Author: Ding Jiaxiong
     * @Date:2023/4/27 15:47
     */
    
    public class MyThread extends Thread {
        
        //定义指定线程名称的构造方法
        public MyThread(String name) {
        
            //调用父类的String参数的构造方法，指定线程的名称
            super(name);
        }
    
        /**
         * 重写run方法，完成该线程执行的逻辑
         */
        @Override
        public void run() {
        
            for (int i = 0; i < 10; i++) {
        
                System.out.println(getName() + "：正在执行！" + i);
            }
        }
    }

测试类：

package com.dingjiaxiong.thread;
    
    /**
     * @Projectname: BigDataStudy
     * @Classname: TestMyThread
     * @Author: Ding Jiaxiong
     * @Date:2023/4/27 15:47
     */
    
    public class TestMyThread {
        
        public static void main(String[] args) {
        
            //创建自定义线程对象
            MyThread mt = new MyThread("新的线程！");
            //开启新线程
            mt.start();
            //在主方法中执行for循环
            for (int i = 0; i < 10; i++) {
        
                System.out.println("main线程！" + i);
            }
        }
    }

![在这里插入图片描述][8071a0dba19847a69f892f04a10d9568.png_pic_center]

###### 9.2.2 实现Runnable接口 ######

Java有单继承的限制，当我们无法继承Thread类时，那么该如何做呢？在核心类库中提供了Runnable接口，我们可以实现Runnable接口，重写run()方法，然后再通过Thread类的对象代理启动和执行我们的线程体run()方法

步骤如下：

1.  定义Runnable接口的实现类，并重写该接口的run()方法，该run()方法的方法体同样是该线程的线程执行体。
2.  创建Runnable实现类的实例，并以此实例作为Thread的target来创建Thread对象，该Thread对象才是真正  
    的线程对象。
3.  调用线程对象的start()方法来启动线程。  
    代码如下：

自定义线程类：

package com.dingjiaxiong.thread;
    
    /**
     * @Projectname: BigDataStudy
     * @Classname: MyRunnable
     * @Author: Ding Jiaxiong
     * @Date:2023/4/27 15:48
     */
    
    public class MyRunnable implements Runnable {
        
        @Override
        public void run() {
        
            for (int i = 0; i < 20; i++) {
        
                System.out.println(Thread.currentThread().getName() + " " + i);
            }
        }
    }

测试类

package com.dingjiaxiong.thread;
    
    /**
     * @Projectname: BigDataStudy
     * @Classname: TestMyRunnable
     * @Author: Ding Jiaxiong
     * @Date:2023/4/27 15:49
     */
    
    public class TestMyRunnable {
        
        public static void main(String[] args) {
        
            //创建自定义类对象  线程任务对象
            MyRunnable mr = new MyRunnable();
            //创建线程对象
            Thread t = new Thread(mr, "长江");
            t.start();
            for (int i = 0; i < 20; i++) {
        
                System.out.println("黄河 " + i);
            }
        }
    }

运行结果

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

通过实现Runnable接口，使得该类有了多线程类的特征。run()方法是多线程程序的一个执行目标。所有的多线程  
代码都在run方法里面。Thread类实际上也是实现了Runnable接口的类。

在启动的多线程的时候，需要先通过Thread类的构造方法Thread(Runnable target) 构造出对象，然后调用Thread对象的start()方法来运行多线程代码。

实际上所有的多线程代码都是通过运行Thread的start()方法来运行的。因此，不管是继承Thread类还是实现  
Runnable接口来实现多线程，最终还是通过Thread的对象的API来控制线程的，熟悉Thread类的API是进行多线程编程的基础。

tips:Runnable对象仅仅作为Thread对象的target，Runnable实现类里包含的run()方法仅作为线程执行体。  
而实际的线程对象依然是Thread实例，只是该Thread线程负责执行其target的run()方法。

###### 9.2.3 使用匿名内部类对象来实现线程的创建和启动 ######

new Thread("新的线程！"){
        
            @Override
            public void run() {
        
                for (int i = 0; i < 10; i++) {
        
                    System.out.println(getName()+"：正在执行！"+i);
                }
            }
        }.start();

new Thread(new Runnable(){
        
            @Override
            public void run() {
        
                for (int i = 0; i < 10; i++) {
        
                    System.out.println(Thread.currentThread().getName()+"：" + i);
                }
            }
        }).start();

[7a8bd33916114ef1946fafd8657a2666.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/f7972a88bb0944edbf97d7cf5af179a3.png
[ae620be13d5041b7a45823470d47ff26.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/f5e93fa6a70042af8e3396c38c81920c.png
[e1679b5a6e1446799ebf2a72a7c83762.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/5971d6912cc340ac8cd7c1fe8474776f.png
[8071a0dba19847a69f892f04a10d9568.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/a090644b1ca5426394d577ac972462be.png
[aeb5c8455dbe42169e2bfef86e8fb113.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/1eb4f8e55bba49199cd3ef5607b0892c.png