多线程-基本概念

---

前言

把零零散散的知识整理一下，方便自己复习

---

一、线程是什么(百度百科)？

线程（英语：thread）是操作系统能够进行运算调度的最小单位。它被包含在进程之中，是进程中的实际运作单位。一条线程指的是进程中一个单一顺序的控制流，一个进程中可以并发多个线程，每条线程并行执行不同的任务。在Unix System V及SunOS中也被称为轻量进程（lightweight processes），但轻量进程更多指内核线程（kernel thread），而把用户线程（user thread）称为线程。

简单说：线程就是程序执行的最小单元，线程可以合理的利用多核心CPU资源，提高程序的吞吐量

二、线程创建的四种方式

1、实现Runnable接口

/**
 *实现Runnable接口创建线程
 * @author hanwei
 * @date 2021/5/15-23:11
 */
public class ImplementsRunnable implements  Runnable {
    @Override
    public void run() {
        System.out.println("实现Runnable接口创建线程");
    }

    public static void main(String[] args) {
        ImplementsRunnable implementsRunnable = new ImplementsRunnable();
        new Thread(implementsRunnable).start();
    }
}

2、继承Thread类(本质上是对Runnable接口的实现)

/**
 * 集成Thread类创建线程
 * @author hanwei
 * @date 2021/5/15-23:14
 */
public class ExtendsThread extends  Thread{
    @Override
    public void run() {
        System.out.println("继承Thread类创建线程");
    }

    public static void main(String[] args) {
        ExtendsThread thread = new ExtendsThread();
        new Thread(thread).start();
    }
}

3、实现Callable接口

/**
 * 实现Callable接口创建线程
 * @author hanwei
 * @date 2021/5/15-23:16
 */
public class ImplementsCallable implements Callable<String> {
    @Override
    public String call() throws Exception {
        return "实现Callable接口创建线程";
    }

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        Callable callable = new ImplementsCallable();
        FutureTask<String> futureTask = new FutureTask<>(callable);
        new Thread(futureTask).start();
        String returnObj = futureTask.get();
        System.out.println(returnObj);
    }
}

4、用ThreadPool线程池创建线程
后续单独对线程池进行说明

三、线程的六种状态及状态间转换

NEW:还没有调用start方法的状态(尚未启动的线程的线程状态)
RUNNABLE:已经调用start方法，处于运行状态或者等待cput时间片；(可运行线程的线程状态。可运行线程中的线程状态正在Java虚拟机中执行，但它可能正在等待来自操作系统的其他资源)
BLOCKED:未获取到对象锁，处于阻塞状态(被阻塞的线程正在等待监视器锁。处于阻塞状态的线程正在等待监视器锁进入同步块/方法或在调用后重新输入同步块/方法 )
WAITING: 等待状态 ，调用了Object.wait()、Thread.join()、LockSupport.park() 方法
TIMED_WAITING: 有时间的等待状态， Thread.sleep()、Object.wait(long)、Thread.join(long)、LockSupport.parkNanos()、LockSupport.parkUntil()
TERMINATED: 结束状态，线程已经完成任务执行(run方法已经执行完成)

线程状态代码示例：

/**
 * @author hanwei
 * @date 2021/5/10-23:36
 */
public class ThreadStatusDemo {

    public static void main(String[] args) {
        //Time Waiting 状态
        new Thread(() -> {
            while (true) {
                try {
                    TimeUnit.SECONDS.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "Time Waiting Thread").start();

        //Waiting 状态
        new Thread(() -> {
            synchronized (ThreadStatusDemo.class) {
                try {
                    ThreadStatusDemo.class.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "Waiting Thread").start();

        //Blocked 状态
        new Thread(new BlockedDemo(),"BlockedDemo1").start();
        new Thread(new BlockedDemo(), "BlockedDemo2").start();

    }

    static class BlockedDemo extends  Thread {
        @Override
        public void run() {
            synchronized (BlockedDemo.class) {
                while (true) {
                    try {
                        TimeUnit.SECONDS.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }
}

四、线程的启动和停止

线程启动：调用start()方法

其中在start方法里面， 调用了start0()方法， 这是一个本地方法

so， 线程启动其实是通过调用本地方法来启动计算机的线程， 这也是线程的启动为什么是调用start 方法
线程停止： run方法执行完成线程就停止了

五、如何中断线程

**1、中断运行中的线程：**通过interrupt()方法来终止一个正在运行中的线程(前提是线程的run 方法要对isInterrupted状态进行判断)

/**
 * @author hanwei
 * @date 2021/5/10-23:52
 */
public class InterruptDemo {

    private static int i;

    public static void main(String[] args) throws InterruptedException {
       Thread thread =  new Thread(() -> {
            while (! Thread.currentThread().isInterrupted()) {
                i++;
            }
            System.out.println("i:" + i);
        });
        thread.start();
        TimeUnit.SECONDS.sleep(1);
        thread.interrupt();
    }
}

2、中断阻塞状态或者睡眠状态的线程： 所有所有和阻塞相关的代码都会抛出这样的一个异常InterruptedException， 通过thread.interrupt()方法发出一个中断线程的信号，处于阻塞状态的线程会接收到这个信号，并抛出InterruptedException，如果需要终止线程，则在catch代码块里面终止， 如 break。

/**
 * @author hanwei
 * @date 2021/5/11-13:17
 */
public class ThreadExceptionDemo {
    private static int i;
    public static void main(String[] args) throws InterruptedException {
        Thread thread =  new Thread(() -> {
            while (true) {
                try {
                    TimeUnit.SECONDS.sleep(1);   // 中断一个处于阻塞状态的线程， 会抛出异常  ； join/wait/queue.take
                    System.out.println("i:" + i++);
                } catch (InterruptedException e) {
                    e.printStackTrace();
//                    break;
                }
            }
        });
        thread.start();
        TimeUnit.SECONDS.sleep(1);
        thread.interrupt(); //中断信号
        System.out.println(thread.isInterrupted());
    }
}

执行结果：如果在catch不主动终止， 抛出异常后 线程会一直循环执行下去

总结

1. 线程启动 start方法， 基于不同的操作系统来实现不同的线程创建线程
2. 线程的六种状态及状态间的转换
3. interrupt() 终止线程