Java 中创建线程(Thread)的五种方法

向右看齐 2024-05-06 21:26 79阅读 0赞

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

#### Java中创建线程/Thread的五种方法 ####

*   *  方法1 继承 Thread 类，重写 run 方法
     *  方法2 实现 Runnable 接口
     *  方法3 匿名内部类创建 Thread 子类对象
     *  方法4 匿名内部类针对 Runnable 子类对象
     *  方法5 lambda 表达式创建 Runnable 子类对象

--------------------

### 方法1 继承 Thread 类，重写 run 方法 ###

`run`：描述了线程要执行什么任务，后续调用 start 创建线程的时候，线程就会自动的把 run 进行执行

**示例：** `MyThread` 线程循环打印 `hello thread`，`main` 线程循环打印`hello main`为例

**1)继承 Thread 来创建MyThread线程，并重写 run 方法**

class MyThread extends Thread {
        
        @Override
        public void run() {
        
            // 这里写的代码，就是该线程要完成的工作
            while (true){
        
                System.out.println("hello thread");
                try {
        
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
        
                    throw new RuntimeException(e);
                }
            }
        }
    }

**2)创建 MyThread 类的实例**

Thread t = new MyThread();

**3)调用 start 方法启动线程**

t.start(); // 线程开始运行

完整代码

package Thread;
    
    class MyThread extends Thread {
        
        @Override
        public void run() {
        
            // 这里写的代码，就是该线程要完成的工作
            while (true) {
        
                System.out.println("hello thread");
                try {
        
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
        
                    throw new RuntimeException(e);
                }
            }
        }
    }
    
    public class Demo1 {
        
        public static void main(String[] args) {
        
            Thread t = new MyThread();
            t.start();
            while (true) {
        
                System.out.println("hello main");
                try {
        
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
        
                    throw new RuntimeException(e);
                }
            }
        }
    }

注： `Thread.sleep(1000);` 让当前线程会暂停1000毫秒（1秒），然后再继续执行后面的代码

运行结果  
![在这里插入图片描述][386ec9ce87c14156a827d69395987770.png]

--------------------

### 方法2 实现 Runnable 接口 ###

实现`Runnable`接口，重写 `run` 方法，把 Runnable 实例作为参数传入到 Thread 的构造方法中  
注：使用 Runnable来表示线程任务的具体情况（有利于解耦合）

**示例：** `MyThread` 线程循环打印 `hello thread`，`main` 线程循环打印`hello main`为例

**1)实现 Runnable 接口**

class MyRunnable implements  Runnable {
        
        @Override
        public void run() {
        
            while (true) {
        
                System.out.println("hello thread");
                try {
        
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
        
                    throw new RuntimeException(e);
                }
            }
        }
    }

**2)创建 Thread 类实例, 调用 Thread 的构造方法时将 Runnable 对象作为 target 参数**

Thread t = new Thread(new MyRunnable());

**3)调用 start 方法**

t.start();

完整代码

package Thread;
    
    class MyRunnable implements  Runnable {
        
        @Override
        public void run() {
        
            while (true) {
        
                System.out.println("hello thread");
                try {
        
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
        
                    throw new RuntimeException(e);
                }
            }
        }
    }
    public class Demo2 {
        
        public static void main(String[] args) {
        
            Thread t = new Thread(new MyRunnable());
            t.start();
            while (true) {
        
                System.out.println("hello main");
                try {
        
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
        
                    throw new RuntimeException(e);
                }
            }
        }
    }

运行结果

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

--------------------

### 方法3 匿名内部类创建 Thread 子类对象 ###

**针对方法1的变形，使用匿名内部类，继承 Thread 并重写 run**

![在这里插入图片描述][c6a7505b79d844afbac2c384aefc7adb.png]  
**代码如下**

Thread t = new Thread(){
        
        @Override	
        public void run() {
        
           while (true) {
        
               System.out.println("hello world");
               try {
        
                   Thread.sleep(1000);
               } catch (InterruptedException e) {
        
                   throw new RuntimeException(e);
               }
           }
         }
    };
    t.start();

--------------------

### 方法4 匿名内部类针对 Runnable 子类对象 ###

![在这里插入图片描述][470cd0aaf9b14580a6c1b2fc6ea84d98.png]  
**代码如下**

Thread t = new Thread(new Runnable() {
        
        @Override
        public void run() {
        
            while (true) {
        
                System.out.println("hello thread");
                try {
        
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
        
                    throw new RuntimeException(e);
                }
            }
        }
    });
    t.start();

--------------------

### 方法5 lambda 表达式创建 Runnable 子类对象 ###

lambda 本质上就是针对匿名内部类的平替，很多编程语言都有lambda 表达式，Java 也是后来才引入的.  
lambda本质上就是一个"匿名函数" ，一次性的函数，用完就丢  
注：此处的lambda就是要代替刚才重写的run .

Thread t = new Thread(() -> {
        
        System.out.println("hello thread");
    });
    t.start();

[07eb8dd97fd64d5d85eb6dc449cf4f95.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/05/06/55470e8bb2f94ac79c0924506d45c492.png
[386ec9ce87c14156a827d69395987770.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/05/06/fad2b02ae2f249db8dcd649a039d7c63.png
[bb080e55b29444e6ac21e6b357cb861d.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/05/06/f80149579a244453b7ca558b68a5812e.png
[c6a7505b79d844afbac2c384aefc7adb.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/05/06/05caee25dc2547c29c3887cd22fe4fe8.png
[470cd0aaf9b14580a6c1b2fc6ea84d98.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/05/06/0af84a6e86744437b9987998beb1aa62.png