【Java多线程编程】创建线程的基本方式

一只爱打拳的程序猿

已于 2023-05-09 09:27:00 修改

阅读量1.3k

点赞数 3

分类专栏： Java多线程编程文章标签： java jvm 开发语言多线程 java-ee

于 2023-05-07 15:34:18 首次发布

本文链接：https://blog.csdn.net/weixin_64916311/article/details/130500829

版权

Java多线程编程专栏收录该内容

13 篇文章 1 订阅

订阅专栏

大家好，我是一只爱打拳的程序猿。今天给大家带来的内容是 Java 创建线程的基本方式。

多线程的基本创建方式:

继承Thread类
实现Runnable接口
匿名内部类
使用lambda表达式

1. 继承Thread类

在 Java 中可以继承 Thread类 来进行多线程编程，Thread类是 Java 提供的一个标准库。继承 Thread 类后我们必需重写 Thread 类中的 run方法来创建该线程。

如自定义 myThread类继承 Thread类：

class myThread extends Thread {
    @Override
    public void run() {
        System.out.println("这是一个线程!");
    }
}

通过上述代码，就能创建一个线程。我所创建的线程只是一段简单的话"这是一个线程"。

1.1 Thread类启动线程

在 main方法中创建 myThread类的实例 thread 引用后，我们可以通过 thread 引用来调用 start()方法 来启动刚刚创建好的线程。

class myThread extends Thread {
    @Override
    public void run() {
        System.out.println("这是一个线程!");
    }
}
public class ThreadDemo {
    public static void main(String[] args) {
        myThread thread = new myThread();
        thread.start();//调用start方法
    }
}

运行后输出:

通过上述代码，我们可以了解到。启动线程的方式的调用 start() 方法，因此我们把调用 start() 方法叫为线程的启动，而 run() 方法叫为线程的入口。

注意，在 main 也是一个线程，因此在 main 方法中 thread引用启动的线程作为子线程，main 方法作为主线程。

重写 run() 方法并在 run() 方法覆写相关内容就是创建一个“非启动状态”线程
未调用 start() 方法，线程并未在操作系统底层创建线程

我们也可以通过循环的方式来观察线程运行的过程:

class myThread extends Thread {
    @Override
    public void run() {
        int i = 1;
        while (true) {
            System.out.println("这是myThread内的第"+i+"一个线程!");
            i++;
            if (i == 7){
                break;
            }
        }
    }
}
public class ThreadDemo {
        public static void main(String[] args) {
            myThread thread = new myThread(); //实例化myThread对象
            thread.start();//调用start方法
        }

运行后输出：

我们也可以通过 Thread类里面的一个静态方法 sleep() 来停顿每个线程，sleep 内的参数为毫秒。你想停顿1秒就设参数为1000，以此类推。

注意，调用该方式时我们必须 Alt+Enter 这个方法，来 try/catch 这个异常。这样程序才能正常的运行， try/catch 后的代码为:

            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

不必在意 catch 内的内容，我们只需要关注 sleep 内的参数是多少即可。

总结：

继承Thread类，必须重写run方法来创建线程
使用start方法来启动线程
使用Thread类中的静态方法sleep可停顿代码
由于sleep是静态方法，我们必须使用try/catch来处理sleep异常

2. 实现Runnable接口

我们可以通过使用 Runnable接口 来创建一个线程。在使用 Runnable接口后我们也要重写 run方法并在run方法里面创建一个线程。

class myThread implements Runnable {
    @Override
    public void run() {
        System.out.println("Hello World");
    }
}

通过上述代码，我们可以观察到 myThread类使用了 Runnable接口。这样我们就能在 myThread类中重写 run方法 来创建一个线程。

2.1 创建Thread类实例

与继承 Thread类来创建线程方法不同的是：如果 Runnable接口要创建 Thread 类的实例，需要调用 Thread 的构造方法时要将 Runnable 接口类型的对象作为 target 参数。如下所示:


class myThread implements Runnable {
    @Override
    public void run() {
        System.out.println("Hello World");
    }
}
public class ThreadDemo {
    public static void main(String[] args) {
        Thread thread = new Thread(new myThread());//调用Thread的构造方法
        thread.start();//调用start方法
    }
}

运行后输出:

通过上述代码以及输出结果，我们发现继承 Thread类和实现 Runnable接口除了创建 Thread类实例不同外，都调用了 start方法 来启动线程。

总结：

实现Runnable接口，必须重写run方法来创建线程
如要通过Runnable接口创建Thread类引用，实例化Thread对象的时候必须将Runnable接口类的对象作为参数来实例化Thread对象
Ruannable接口和Thread类启动线程的方式都是通过start方法

3. 变种创建方式

3.1 匿名内部类

匿名内部类创建 Thread类 子类对象:

    public static void main(String[] args) {
        Thread thread = new Thread(){
            @Override
            public void run() {
                System.out.println("这是Thread类里的一个线程");
            }
        };
        thread.start();
    }

运行后输出：

通过上述代码，我们可以观察到。创建了 Thread类子类对象也是要重写 Thread类中的 run 方法并在 run 方法里面创建线程的。

匿名内部类创建 Runnable接口 子类对象:

    public static void main(String[] args) {
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                System.out.println("这是Runnable接口下的一个线程");
            }
        };
        runnable.run();
    }

运行后输出:

创建 Runnable 接口的子类对象，也要重写 Runnable 接口底下的run方法才能创建线程。

3.2 lambda表达式

lambda 表达式的基本写法为: () -> {}。lambda表达式是通过传参的形式创建子类对象。如使用 lambda 表达式创建一个 Thread 类线程：

    public static void main(String[] args) {
        Thread thread = new Thread( () -> {
            System.out.println("这是lambda表达式下的一个线程");
        } );
        thread.start();
    }

运行后输出:

当然我们可以通过循环的方式来观察线程的运行:

    public static void main(String[] args) {
        Thread thread = new Thread( () -> {
            int i = 1;
            while(true) {
                System.out.println("这是第"+i+"个线程");
                i++;
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                if (i == 7){
                    break;
                }
            }
        });
        thread.start();
    }

运行后输出: