Java 多线程编程（入门）_java多线程写法-优快云博客

本文链接：https://blog.youkuaiyun.com/weixin_53564801/article/details/127163316

一、简单介绍 Thread类

【1】Thread类中一些常用的方法

【2】编写一个简单多线程程序（入门）

二、Java中创建多线程的方法（重点面试题）

1.继承 Thread 类

2.实现 Runnable 接口，重写 run

3.使用匿名内部类，实现创建 Thread 子类的方式

4.使用匿名内部类，实现 Runnable 接口的方法

5.lambda 表达式【推荐】

三、简单分析多线程编程提升效率

一、简单介绍 Thread类

线程是操作系统的概念。操作系统给线程的一些相关操作，提供了一系列的API让用户使用（例如 Linux 的 pthread 库）。

这些系统原生的 API 是用 C语言编写的，而Java 为了能够方便使用这些 API，就把这些 API 给封装成 Java 风格的类。

这个类就是 Java标准库中的 Thread 类

Thread 类可以视为是对操作系统提供的 API 进行了进一步的封装和抽象

【1】Thread类中一些常用的方法

🌑start 方法

调用 start() 方法用来启动一个线程。当我们创建一个线程后，只有调用 start() 方法才能启动，并执行一些任务。

🌒run 方法

run() 方法是不需要用户调用的。run() 方法相当于线程他的本质工作，当线程通过 start() 启动后，线程会自动执行 run() 内的任务。

注意：继承Thread类时，必须重写run方法，在run方法内自定义要执行的任务

🌓sleep 方法

sleep(long ms) //参数为毫秒
sleep(long ms,int nanoseconds)//第一个参数为毫秒，第二个参数为纳秒

sleep() 方法相当于让线程休眠

注意：使用 sleep方法是要处理一下异常！

【2】编写一个简单多线程程序（入门）

如果我们想创建一个线程并让它不断打印 “hello world”的任务。

首先：我们可以自己创建一个线程类（MyThread）继承 Thread 类

第二步：重写 run() 方法，把我们想要线程执行的任务写入 run() 方法内部，如下

class MyThread extends Thread{
    @Override
    public void run() {
        System.out.println("hello thread!");
    }
}

第三步：在 main函数中创建名为 MyThread的线程，并调用 start() 方法启动该线程

public class Demo1 {
    public static void main(String[] args){
        MyThread myThread = new MyThread();
        myThread.start();
    }
}

这样我们就创建了一个线程啦。

在 Java 中，一个 Java 程序相当于一个进程，而 main函数相当于主线程。我们创建的线程和主线程都是属于进程！！

每个线程都是一个独立的执行流
多个线程之间是 “并发” 执行的

为了方便观察多线程的执行法过程，我们在 main函数中也写上打印任务，并分别调用 sleep 方法，方便我们观察。

package threading;

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) throws InterruptedException {
        MyThread myThread = new MyThread();
        myThread.start();

        while(true){
            System.out.println("hello main");
            Thread.sleep(1000);
        }
    }
}

结果如下：

我们会发现 main主线程和我们创建的线程是并发执行的（并发+并行），并不是串行执行的。

我们还可以使用 jconsole 命令观察线程

jconsole 命令查找可以查看：使用 jconsole 命令观察线程

二、Java中创建多线程的方法（重点面试题）

1.继承 Thread 类

上述给大家演示的代码就是继承 Thread 类创建线程的方法，这里就不再赘述了。

2.实现 Runnable 接口，重写 run

先创建一个实现 Runnable 接口的类，实例化后作为参数传递给 Thread 构造方法。

class MyRunnable implements Runnable{
    @Override
    public void run() {
        while(true){
            ...
        }
    }
}
public class Demo2 {
    public static void main(String[] args) {
        MyRunnable runnable = new MyRunnable();
        Thread t = new Thread(runnable);
        t.start();

        while(true){
            System.out.println("hello main");
        }
    }
}

这种方式把线程要干的活和线程本身分开！把任务提取出来，并使用 Runnable 来专门表示“ 线程要完成的工作 ”

把任务提取出来，目的仍然是为了解耦合！

前面继承Thread 协防，就把线程要完成的工作，和线程本身，耦合在一起了

假设未来要对这个代码进程调整（不用多线程了，用其他方式），代码改动就比较大

而 Runnable 这种写法，就只是需要把 Runnable 传给其他的实体即可！！

3.使用匿名内部类，实现创建 Thread 子类的方式

package threading;

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

4.使用匿名内部类，实现 Runnable 接口的方法

在 Thread 的构造方法的参数里面就地创建了一个匿名内部类

public class Demo4 {
    public static void main(String[] args) {
        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 表达式【推荐】

lambda 本质上是一个 “匿名函数”

语法格式如下：

Thread t = new Thread(()->{
   //... 
});

():内代表函数的形参 {}:代表函数体

-> 特殊语法，表示它是一个 lambda

public class Demo5 {
    public static void main(String[] args) {
        Thread t = new Thread(() -> {
            while(true){
                System.out.println("hello thread");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        });
    }
}

注意：创建线程并不知道以上五种方式，不过大家知道这些就已经足够了

三、简单分析多线程编程提升效率

观察多线程在一些场合下，并行执行提升的代码运行速度的效率

System.currentTimeMillis()：获取当前的时间戳。

serial 串行的完成一下运算，concurrency 使用两个线程并行执行相同操作。

package threading;

public class Demo6 {
    public static final long COUNT = 10_0000_0000L;

    public static void main(String[] args) throws InterruptedException {
        serial();
        concurrency();
    }

    // 串行执行任务
    public static void serial(){
        // 记录 ms 级别的时间戳
        long beg = System.currentTimeMillis();

        long a = 0;
        for(long i = 0;i < COUNT;i++){
            a++;
        }

        a= 0;
        for (int i = 0; i < COUNT; i++) {
            a++;
        }

        long end = System.currentTimeMillis();
        System.out.println("执行的时间间隔" + (end - beg) + " ms");
    }

    // 并发执行任务
    public static void concurrency() throws InterruptedException {
        long beg = System.currentTimeMillis();

        Thread t1 = new Thread(() -> {
            long a = 0;
            for (int i = 0; i < COUNT; i++) {
                a++;
            }
        });

        Thread t2 = new Thread(() -> {
            long a = 0;
            for (int i = 0; i < COUNT; i++) {
                a++;
            }
        });

        t1.start();
        t2.start();

        t1.join();
        t2.join();

        long end = System.currentTimeMillis();
        System.out.println("执行的时间间隔" + (end - beg) + " ms");
    }
}