目录

一、概念

1、 线程是什么

2、为啥要有线程？

 3、进程和线程的区别

4、Java 的线程 和 操作系统线程 的关系  

二、第⼀个多线程程序  

三、创建线程

⽅法1：继承 Thread 类  

⽅法2：实现 Runnable 接⼝

对⽐上⾯两种⽅法:  

其他变形 

四、多线程的优势-增加运行速度 

---

引言：

        在Java编程中，线程（Thread）是一项重要的概念，它使得程序能够同时执行多个任务，提高了程序的效率和响应速度。本文将介绍Java线程的基本概念、创建方式以及多线程的优势。

一、概念

1、 线程是什么

2、为啥要有线程？

• 单核 CPU 的发展遇到了瓶颈. 要想提⾼算⼒, 就需要多核 CPU. ⽽并发编程能更充分利⽤多核 CPU 资源.
• 有些任务场景需要 "等待 IO", 为了让等待 IO 的时间能够去做⼀些其他的⼯作, 也需要⽤到并发编程.

 最后, 线程虽然⽐进程轻量, 但是⼈们还不满⾜, 于是⼜有了 "线程池"(ThreadPool) 和 "协程" (Coroutine)

 3、进程和线程的区别

• 进程是包含线程的. 每个进程⾄少有⼀个线程存在，即主线程。
• 进程和进程之间不共享内存空间. 同⼀个进程的线程之间共享同⼀个内存空间。
• 进程是系统分配资源的最⼩单位，线程是系统调度的最⼩单位。  
• ⼀个进程挂了⼀般不会影响到其他进程. 但是⼀个线程挂了, 可能把同进程内的其他线程⼀起带⾛(整个进程崩溃).

4、Java 的线程 和 操作系统线程 的关系  

二、第⼀个多线程程序  

• 每个线程都是⼀个独⽴的执⾏流
• 多个线程之间是 "并发" 执⾏的.

import java.util.Random;
public class ThreadDemo {
    private static class MyThread extends Thread {
        @Override
        public void run() {
            Random random = new Random();
            while (true) {
                // 打印线程名称
                System.out.println(Thread.currentThread().getName());
                try {
                    // 随机停⽌运⾏ 0-9 秒
                    Thread.sleep(random.nextInt(10));
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
    public static void main(String[] args) {
        MyThread t1 = new MyThread();
        t1.start();
        Random random = new Random();
        while (true) {
            // 打印线程名称
            System.out.println(Thread.currentThread().getName());
            try {
                Thread.sleep(random.nextInt(10));
            } catch (InterruptedException e) {
                // 随机停⽌运⾏ 0-9 秒
                e.printStackTrace();
            }
        }
    }
}

三、创建线程

⽅法1：继承 Thread 类  

class MyThread extends Thread {
        @Override
        public void run() {
            System.out.println("这⾥是线程运⾏的代码");
        }
    }

 （2）创建 MyThread 类的实例

MyThread t = new MyThread();

t.start();

（1）实现 Runnable 接⼝

class MyRunnable implements Runnable {
        @Override
        public void run() {
            System.out.println("这⾥是线程运⾏的代码");
        }
    }

 （2）创建 Thread 类实例, 调⽤ Thread 的构造⽅法时将 Runnable 对象作为 target 参数

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

（3）调⽤ start ⽅法 

t.start();

对⽐上⾯两种⽅法:  

• 继承 Thread 类, 直接使⽤ this 就表⽰当前线程对象的引⽤.
• 实现 Runnable 接⼝, this 表⽰的是 MyRunnable 的引⽤. 需要使⽤ Thread.currentThread（）方法

其他变形 

匿名内部类创建 Thread ⼦类对象

// 使⽤匿名类创建 Thread ⼦类对象
    Thread t1 = new Thread() {
        @Override
        public void run() {
            System.out.println("使⽤匿名类创建 Thread ⼦类对象");
        }
    };

匿名内部类创建 Runnable ⼦类对象  

// 使⽤匿名类创建 Runnable ⼦类对象
    Thread t2 = new Thread(new Runnable() {
        @Override
        public void run() {
            System.out.println("使⽤匿名类创建 Runnable ⼦类对象");
        }
    });

lambda 表达式创建 Runnable ⼦类对象

// 使⽤ lambda 表达式创建 Runnable ⼦类对象
    Thread t3 = new Thread(() -> System.out.println("使⽤匿名类创建 Thread ⼦类对象"));
    Thread t4 = new Thread(() -> {
        System.out.println("使⽤匿名类创建 Thread ⼦类对象");
    });

四、多线程的优势-增加运行速度 

 可以观察多线程在⼀些场合下是可以提⾼程序的整体运⾏效率的。

• 使⽤ System.nanoTime() 可以记录当前系统的 纳秒 级时间戳.
• serial 串⾏的完成⼀系列运算. concurrency 使⽤两个线程并⾏的完成同样的运算.

public class ThreadAdvantage {
        // 多线程并不⼀定就能提⾼速度，可以观察，count 不同，实际的运⾏效果也是不同的
        private static final long count = 10_0000_0000;
        public static void main(String[] args) throws InterruptedException {
            // 使⽤并发⽅式
            concurrency();
            // 使⽤串⾏⽅式
            serial();
        }
        private static void concurrency() throws InterruptedException {
            long begin = System.nanoTime();

            // 利⽤⼀个线程计算 a 的值
            Thread thread = new Thread(new Runnable() {
                @Override
                public void run() {
                    int a = 0;
                    for (long i = 0; i < count; i++) {
                        a--;
                    }
                }
            });
            thread.start();
            // 主线程内计算 b 的值
            int b = 0;
            for (long i = 0; i < count; i++) {
                b--;
            }
            // 等待 thread 线程运⾏结束
            thread.join();

            // 统计耗时
            long end = System.nanoTime();
            double ms = (end - begin) * 1.0 / 1000 / 1000;
            System.out.printf("并发: %f 毫秒%n", ms);
        }
        private static void serial() {
            // 全部在主线程内计算 a、b 的值
            long begin = System.nanoTime();
            int a = 0;
            for (long i = 0; i < count; i++) {
                a--;
            }
            int b = 0;
            for (long i = 0; i < count; i++) {
                b--;
            }
            long end = System.nanoTime();
            double ms = (end - begin) * 1.0 / 1000 / 1000;
            System.out.printf("串⾏: %f 毫秒%n", ms);
        }
    }