目录

一、进程和线程

1.进程

2.线程

3.进程和线程的关系和区别

二、线程的创建方式

1.继承Thread类

2.实现Runnable接口

3.实现Callable接口

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

三、线程的生命周期

四、线程的常用方法

一、进程和线程

1.进程

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

2.线程

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

3.进程和线程的关系和区别

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

二、线程的创建方式

1.继承Thread类

1. 继承Thread类
2. 重写run方法
3. 创建Thread对象
4. 启动线程

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

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

2.实现Runnable接口

1. 实现Runnable接口
2. 重写run方法
3. 创建Thread对象，传入Runnable对象
4. 启动线程

class MyRunnable implements Runnable{
    // 实现run方法
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName() + "线程执行了" + i + "次");
        }
    }
}

public class RunnableDemo{
    public static void main(String[] args) {
        // 创建Thread对象，传入Runnable对象
        Thread thread = new Thread(new MyRunnable());
        // 启动线程
        thread.start();

        // Lambda表达式创建
        new Thread(() -> {
            for (int i = 0; i < 100; i++) {
                System.out.println(Thread.currentThread().getName() + "线程执行了" + i + "次");
            }
        }).start();
    }
}

3.实现Callable接口

1. 实现Callable接口
2. 创建Callable对象，传入FutureTask对象
3. 创建Thread对象，FutureTas对象
4. 启动线程

class MyCallable implements Callable {
    // 实现call方法
    @Override
    public Long call() throws Exception {
        long sum = 0;
        for (int i = 0; i < 1000000000; i++) {
            sum += i;
        }
        return sum;
    }
}

public class CallableDemo {
    public static void main(String[] args) {
        // 创建Callable对象，传入FutureTask对象
        FutureTask task = new FutureTask<>(new MyCallable());
        // 创建Thread对象，传入FutureTask对象
        Thread thread = new Thread(task);
        // 启动线程
        thread.start();
        // 获得返回值
        try {
            System.out.println(task.get());
        }catch (Exception e) {
            e.printStackTrace();
        }
    }
}

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

class MyRunnable1 implements Runnable{
    @Override
    public void run()
    {
        System.out.println("线程名" + Thread.currentThread().getName());

    }
}

public class ThreadPollDemo {

    // 线程池数量
    private static int threadPoolNum = 10;

    public static void main(String[] args) {
        ExecutorService executorService = Executors.newFixedThreadPool(5);
        for(int i = 0; i < threadPoolNum; i ++)
        {
            //创建线程对象
            MyRunnable thread = new MyRunnable();
            executorService.execute(thread);
        }
    }
}

三、线程的生命周期

1.新建（NEW）：创建Thread类的实例时，线程进入新建状态。

2.就绪（RUNNABLE）：调用线程对象的start()方法后，等待被分配给CPU时间片、谁先抢到CPU资源，谁开始执行。

3.运行（RUNNING）：当就绪的线程被调并获得度CPU资源时，进入运行状态，执行run()方法中的功能。

4.堵塞（BLOCKED）：线程运行时出现某些原因导致正在运行的线程进入堵塞状态。

5.死亡（DEAD）：线程执行完毕或被强行终止。

四、线程的常用方法

方法	介绍
start()	启动线程
stop()	停止（禁用，可能导致线程死锁等问题），停止线程可以让run执行结束
String getName()	获得线程的名字
setName(String)	设置线程名字
sleep(long)	进入睡眠，毫秒
setPriority(int)	设置线程的优先级（1~10从低到高）越高抢CPU几率更高
setDaemon(boolean)	设置为后台线程 true ,后台线程是为其它线程服务的，如果没有其它线程存在，就自动死亡；使用案例：GC就是一种后台线程
join()	线程的加入（合并）让其它线程先执行完，再执行自己的指令