三.什么是线程？如何创建线程？

目录

一、进程和线程

1.进程

2.线程

二、线程的创建方式

1.继承Thread类

2.实现Runnable接口

3.实现Callable接口

4.通过线程池实现多线程

三、线程的生命周期

通常线程生命周期（概念上）：

java线程生命周期（代码有写明状态）：

---

一、进程和线程

1.进程

进程（Process）是程序进行资源（CPU、内存、磁盘等）分配和调度的基本单位，是正在运行的程序的实例，一个程序可以包含一个或多个进程。

2.线程

线程是操作系统能够进行运算和调度的最小单位。它被包含在进程之中，是进程中的实际运作单位。一条线程指的是进程中一个单一顺序的控制流，一个进程中可以并发多个线程，每条线程并行执行不同的任务。
3.进程和线程的关系和区别

一个操作系统中可以有多个进程,一个进程中可以包含一个线程或多个线程。
每个线程能共享同一个进程中的内存，线程也有独立的空间（栈、程序计数器）。
线程需要的资源更少，可以看做是一种轻量级的进程，相互通信更加方便。

二、线程的创建方式

1.继承Thread类

• 继承Thread类
• 重写run方法
• 创建Thread对象
• 启动线程

public class MyThread extends Thread{
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName() + "线程执行了" + i + "次");
        }

    }
}
class test{
    public static void main(String[] args) {
        // 创建Thread对象
        MyThread thread1 = new MyThread();
        MyThread thread2 = new MyThread();
        // 启动线程
        thread1.start();
        thread2.start();
    }
}

执行结果：

2.实现Runnable接口

• 实现Runnable接口
• 重写run方法
• 创建Thread对象，传入Runnable对象
• 启动线程

class MyThread2 implements Runnable{

    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName() + "线程执行了" + i + "次");
        }
    }
}
class test{
    public static void main(String[] args) {
//        // 创建Thread对象
//        MyThread thread1 = new MyThread();
//        MyThread thread2 = new MyThread();
//        // 启动线程
//        thread1.start();
//        thread2.start();
        MyThread2 runnableThread1 = new MyThread2();
        MyThread2 runnableThread2 = new MyThread2();
        Thread thread1 = new Thread(runnableThread1);
        Thread thread2 = new Thread(runnableThread2);

        thread1.start();
        thread2.start();

    }
}

运行结果：

3.实现Callable接口

• 实现Callable接口
• 创建Callable对象，传入FutureTask对象
• 创建Thread对象，FutureTas对象
• 启动线程

class MyThread3 implements Callable {

    @Override
    public Long call() throws Exception {
        long sum = 0;
        for (int i = 0; i < 10; i++) {
            sum += i;
            System.out.println(Thread.currentThread().getName() + "线程执行了" + i + "次");
        }
        return sum;
    }
}
class test{
    public static void main(String[] args) {
//        // 创建Thread对象
//        MyThread thread1 = new MyThread();
//        MyThread thread2 = new MyThread();
//        // 启动线程
//        thread1.start();
//        thread2.start();

//        MyThread2 runnableThread1 = new MyThread2();
//        MyThread2 runnableThread2 = new MyThread2();
//        Thread thread1 = new Thread(runnableThread1);
//        Thread thread2 = new Thread(runnableThread2);
//        // 启动线程
//        thread1.start();
//        thread2.start();
        FutureTask<Long> futureTask = new FutureTask<>(new MyThread3());
        FutureTask<Long> futureTask2 = new FutureTask<>(new MyThread3());
        Thread thread = new Thread(futureTask);
        Thread thread2 = new Thread(futureTask2);
        thread.start();
        thread2.start();
        // 获得返回值
        try {
            System.out.println(futureTask.get());
            System.out.println(futureTask2.get());
        }catch (Exception e) {
            e.printStackTrace();
        }

    }
}

运行结果：

4.通过线程池实现多线程

class test{
    public static void main(String[] args) {
//        // 创建Thread对象
//        MyThread thread1 = new MyThread();
//        MyThread thread2 = new MyThread();
//        // 启动线程
//        thread1.start();
//        thread2.start();

//        MyThread2 runnableThread1 = new MyThread2();
//        MyThread2 runnableThread2 = new MyThread2();
//        Thread thread1 = new Thread(runnableThread1);
//        Thread thread2 = new Thread(runnableThread2);
//        // 启动线程
//        thread1.start();
//        thread2.start();
//        FutureTask<Long> futureTask = new FutureTask<>(new MyThread3());
//        FutureTask<Long> futureTask2 = new FutureTask<>(new MyThread3());
//        Thread thread = new Thread(futureTask);
//        Thread thread2 = new Thread(futureTask2);
//        thread.start();
//        thread2.start();
//        // 获得返回值
//        try {
//            System.out.println(futureTask.get());
//            System.out.println(futureTask2.get());
//        }catch (Exception e) {
//            e.printStackTrace();
//        }
        ExecutorService executorService = Executors.newFixedThreadPool(5);
        for (int i = 0; i < 10; i++) {
            executorService.execute(new MyThread());
        }
        
    }
}

执行结果：

三、线程的生命周期

通常线程生命周期（概念上）：

1.新建（NEW）：创建Thread类的实例时，线程进入新建状态。
2.就绪（RUNNABLE）：调用线程对象的start()方法后，等待被分配给CPU时间片、谁先抢到CPU资源，谁开始执行。
3.运行（RUNNING）：当就绪的线程被调并获得度CPU资源时，进入运行状态，执行run()方法中的功能。
4.堵塞（BLOCKED）：线程运行时出现某些原因导致正在运行的线程进入堵塞状态。
5.死亡（DEAD）：线程执行完毕或被强行终止。
 

java线程生命周期（代码有写明状态）：

1. NEW 初始状态

2. RUNNABLE 可运行状态/运行状态

3. BLOCKED 阻塞状态

4. WAITING 无时限等待

5. TIMED_WAITING 有时限等待

6. TERMINATED 终止状态