总结多线程阶段性学习（1）

目录

一、认识线程

二、线程的创建

三、Thread类的常见方法

四、线程的属性

五、线程的状态

---

一、认识线程

（1）线程的概念 ：线程是调度执行的基本单位。每个线程都有属于自己的状态、优先级、上下文、记账信息等。

（2）线程与进程的区别：进程包含多个线程（也就是包含多个PBC）。线程是调度执行的基本单位；进程是资源分配的基本单位。调度执行建立在资源分配之后。因此线程比进程更轻量，除第一个线程需要和进程一同申请资源之外，建立其他的线程则不需进行重复步骤。多个线程之间可能会相互影响，多个进程之间一般不会相互影响。

（3）线程与进程的关系：一个进程里面有一个线程，可以包含多个线程，但是不能没有线程。同一个进程里面的线程之间，共用一份系统资源，其中“内存资源”就是代码中定义的变量/对象。

（4）以上我们理解了浅显的线程，但对于程序开发来说，线程并不是越多越好。如果线程过多，超过了CPU的核心数之后就会抢占CPU，反而会降低效率。

二、线程的创建

（1）继承Thread类：重写run，通过Thread实例start出新线程。

class  MyThread extends Thread{
    @Override
    public void run(){
        while(true){
            System.out.println("hello Thread");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

    }
}
public class Demo1 {
    public static void main(String[] args) throws InterruptedException {

        MyThread t = new MyThread();
        t.start();
        while(true){
            System.out.println("hello main");
            Thread.sleep(1000);
        }
    }
}

（2）实现Runnable接口：重写Runnable接口里面的run方法，通过Thread实例，把Runnable接口的实例传入之后start出新线程。

​class MyThread2 implements Runnable{
    @Override
    public void run() {
        for (int i=0; i<3;i++){
            System.out.println("实现Ruannable线程");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
public class Demo2 {
    public static void main(String[] args) throws InterruptedException {
        MyThread2 t = new MyThread();//Runnable接口实例化
        Thread thread = new Thread(t);
        thread.start();
        for (int i = 0; i <3 ; i++) {
            System.out.println("main线程");
            Thread.sleep(1000);
        }
    }
}

​

（3）内部类Thread：

public class Demo3 {
    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(){
            @Override
            public void run() {
                for (int i = 0; i <3 ; i++) {
                    System.out.println("内部类Thread线程");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        };
        thread.start();
        for (int i = 0; i <3 ; i++) {
            System.out.println("main线程");
            Thread.sleep(1000);
        }
    }
}

（4）内部Runnable：

public class Demo4 {
    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i <3 ; i++) {
                    System.out.println("内部类线程");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        });
        t.start();
        for (int i = 0; i <3 ; i++) {
            System.out.println("main线程");
            Thread.sleep(1000);
        }
    }
}

（5）lambda表达式创建线程

public class Demo5 {
    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(() -> {
            for (int i = 0; i <3; i++) {
                System.out.println("lambda线程");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        t.start();
        for (int i = 0; i <3 ; i++) {
            System.out.println("main线程");
            Thread.sleep(1000);
        }
    }
}

        lambda表达式本质上是一个“函数式接口”产生的“匿名内部类”，而内部类访问外部类成员则可以进一步修改成员变量。lambda表达式有一个特殊语法叫做“变量捕获”，Java会自动捕获lambda同作用域的所有变量，但是需要这个变量是final/事实变量，后者则是在同一个作用域被唯一赋值。

（6）run和start的区别

        run是一个方法，描述线程执行的任务，也可以叫做线程的“入口”’，线程执行后系统自动调用run方法。start调用系统函数，在系统内核中创建线程。

三、Thread类的常见方法

（1）启动：start的执行速度快，执行之后新线程创建，同时也会继续执行main线程，调用start可以是其他新创建的线程。一个Thread对象只能调用一次，也就是一个Thread对象。只能对应系统中的一个线程。

（2）终止：

public void interrupt()	设置线程中断标志为true
public static boolean interrupted()	检测当前线程是否被中断，是返回true，否返回false，如果被中断了，返回true的同时会清除中断标志（即重置中断标志为false）。
public boolean isinterrupted()	检测当前线程是否被中断，如果是返回true，否返回false。

        <1>当线程A运行时，线程B可以调用A.interrupt()方法，来设置线程A的中断标志为true，然后线程B立即返回，A的中断标志被设置，thread可以通过Thread.currentThread().isInterrupted()，判断指定线程的中断标志被设置，不清除中断标志。

        <2>如果A线程因为调⽤wait/join/sleep等⽅法⽽阻塞挂起，则以InterruptedException异常的形式通 知，清除中断标志 。当出现InterruptedException的时候,要不要结束线程取决于catch中代码的写法.可以选择忽 略这个异常,也可以跳出循环结束线程.。

（3）等待：有时，我们需要等待⼀个线程完成它的⼯作后，才能进⾏⾃⼰的下⼀步⼯作

public void join()	等待线程结束
public void join(long millis)	等待线程结束，最多等millis毫秒
public void join(long millis，int nanos)	同理，更高精准度

        

（4）获得引用：

public static Thread currentThread()

返回当前线程对象的引用

public class ThreadDemo {
    public static void main(String[] args) {
        Thread thread = Thread.currentThread();
        System.out.println(thread.getName());
    }
}

（5）休眠：可以通过Thread.sleep()来休眠。线程的调度是不可控的，这个⽅法只能保证 实际休眠时间是⼤于等于参数设置的休眠时间的。

四、线程的属性

（1）线程的属性：

（2）前台线程和后台线程的关系：一个进程可以拥有多个前台线程和后台线程，后台线程的结束不能让进程结束，只有前台线程一起结束，进程才能结束。

五、线程的状态

（1）NEW：安排了⼯作,还未开始⾏动。

（2）TERMINATED：⼯作完成了，

（3）RUNNABLE：可⼯作的。⼜可以分成正在⼯作中和即将开始⼯作。

（4）TIMED_WAITING：线程在等待唤醒，设置了时限。

（5）WAITING：线程在⽆限等待唤醒。

（6）BLOCK：等待获取锁，WAITING和TIMED_WAITING表⽰等待其他线程发来通知。

        指令是cpu执行的基本单位，存在线程只执行一个单位就被调度走的情况且无法预测，所以就会造成线程安全问题。