【Java高级】多线程

线程相关概念

程序：完成特定任务，用某种语言编写的一组指令的集合，就是代码

进程：指运行中的程序，比如QQ，进行是程序的一次执行过程，是一个动态过程

线程：由进程创建，是进程的一个实体

单线程：同一个时刻，只允许执行一个线程

多线程：同一个时刻，可以执行多个线程

并发：同一时刻，多个任务交替执行，造成一种同时运行的感觉

并行：同一时刻，多个任务同时执行，多核CPU可以执行并行

线程的基本使用

创建线程的两种方式

1. 继承Thread，实现run方法
2. 实现Runnable，实现run方法

继承Thread

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

        //创建Cat对象，可以当做线程使用
        Cat cat = new Cat();

        cat.start();//启动线程-> 最终会执行cat的run方法
//当main线程启动一个子线程时，主线程并不会继续阻塞，会继续执行

    }
}

//1. 当一个类继承了 Thread 类， 该类就可以当做线程使用
//2. 我们会重写 run方法，写上自己的业务代码
//3. run Thread 类 实现了 Runnable 接口的run方法


class Cat extends Thread {

    int times = 0;
    @Override
    public void run() {//重写run方法，写上自己的业务逻辑

        while (true) {
            //该线程每隔1秒。在控制台输出 “喵喵, 我是小猫咪”
            System.out.println("喵喵, 我是小猫咪" + (++times) + " 线程名=" + Thread.currentThread().getName());
            //让该线程休眠1秒 ctrl+alt+t
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if(times == 80) {
                break;//当times 到80, 退出while, 这时线程也就退出..
            }
        }
    }
}

当main线程启动一个子线程时，主线程并不会继续阻塞，会继续执行

主线程结束不一定进程结束，只要有线程执行进程就继续

如果直接运行run，而不是start的话，并没有启动一个子线程，并不是多线程

实现Runnable接口

不能直接调用start，下面是例子

Thread thread = new Thread(dog); 底层使用了代理模式的设计模式
thread.start();

public class Thread02 {
    public static void main(String[] args) {
        Dog dog = new Dog();
        //dog.start(); 这里不能调用start
        //创建了Thread对象，把 dog对象(实现Runnable),放入Thread
        Thread thread = new Thread(dog);
        thread.start();

//        Tiger tiger = new Tiger();//实现了 Runnable
//        ThreadProxy threadProxy = new ThreadProxy(tiger);
//        threadProxy.start();
    }
}

class Animal {
}

class Tiger extends Animal implements Runnable {

    @Override
    public void run() {
        System.out.println("老虎嗷嗷叫....");
    }
}

//线程代理类 , 模拟了一个极简的Thread类
class ThreadProxy implements Runnable {//你可以把Proxy类当做 ThreadProxy

    private Runnable target = null;//属性，类型是 Runnable

    @Override
    public void run() {
        if (target != null) {
            target.run();//动态绑定（运行类型Tiger）
        }
    }

    public ThreadProxy(Runnable target) {
        this.target = target;
    }

    public void start() {
        start0();//这个方法时真正实现多线程方法
    }

    public void start0() {
        run();
    }
}


class Dog implements Runnable { //通过实现Runnable接口，开发线程

    int count = 0;

    @Override
    public void run() { //普通方法
        while (true) {
            System.out.println("小狗汪汪叫..hi" + (++count) + Thread.currentThread().getName());

            //休眠1秒
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            if (count == 10) {
                break;
            }
        }
    }
}

Thread vs Runnable

本质上没有区别

实现Runable接口的方式更加适合多个线程共享一个资源的情况，

Thread thread01 = new Thread(t3);
THread thread02 = new Thread(t3);
thread01.start();
thread02.start();
两个线程共享t3一个对象

同时也避免了单继承的限制

线程常用方法

1. setName 设置线程名称

2. getName 返回该线程的名称

3. start 使该线程开始执行

4. run 调用线程对象的run方法

5. setPriority 更改线程的优先级 1-10

6. getPriority 获取线程的优先级

7. sleep 在指定的毫秒数内让当前正在执行的线程休眠

8. interrupt 中断线程，中断休眠

9. yield 让出CPU，让其他线程执行，但礼让的时间不确定，也不一定礼让成功

10. join 线程插队，插队的线程一旦插队成功，则肯定先执行完插入的线程的所有任务

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

        T2 t2 = new T2();
        t2.start();

        for(int i = 1; i <= 20; i++) {
            Thread.sleep(1000);
            System.out.println("主线程(小弟) 吃了 " + i  + " 包子");
            if(i == 5) {
                System.out.println("主线程(小弟) 让 子线程(老大) 先吃");
                //join, 线程插队
                //t2.join();// 这里相当于让t2 线程先执行完毕
                Thread.yield();//礼让，不一定成功..
                System.out.println("线程(老大) 吃完了 主线程(小弟) 接着吃..");
            }

        }
    }
}

class T2 extends Thread {
    @Override
    public void run() {
        for (int i = 1; i <= 20; i++) {
            try {
                Thread.sleep(1000);//休眠1秒
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("子线程(老大) 吃了 " + i +  " 包子");
        }
    }
}

用户线程和守护线程

用户线程：也叫工作线程，当线程的任务执行完或者通知方式结束

守护线程：一般是为工作线程服务的，当所有的用户线程结束，守护线程自动结束

线程.setDaemon(true);

线程的生命周期

**1.初始(NEW)😗*刚被创建,还没运行(未执行线程的start()方法)

**2.就绪状态(READY)😗*线程在可运行线程池中,但未获得CPU执行权,和RUNNING并称运行

**3.运行中状态(RUNNING)😗*线程执行并获得CPU执行权,和READY并称运行

**4.阻塞(BLOCK)😗*等待其他线程释放锁的状态

**5.等待(WAITING)😗*需要其他线程做出一些约定好的动作,或被唤醒(通知或中断)

**6.超时等待(TIME_WAITING)😗*和等待的不同点在于可以在指定的时间自行醒来

**7.终止(TERMENATED)😗*线程已经执行完毕

线程同步机制

当有一个线程在对内存进行操作时，其他线程都不可以对这个内存地址进行操作，直到该线程完成操作，其他线程才能对该内存地址进行操作

实现方法

Synchronized

1. 同步代码块（尽量选择，因为范围越小效率越高）

   synchronized(this){//多个线程的锁要是一个对象
   	...
   }
   
   如果在静态方法中，要实现一个静态代码块要用class
   synchronized(当前类.class){
   	...
   }
   

2. 方法声明中

   public synchronized void sell(){
   	...
   }
   

线程死锁

多个线程因竞争资源，相互持有不肯相让

释放锁

释放锁的情况

1. 当前线程的同步方法执行结束
2. 当前线程在同步方法遇到break、return
3. 当前线程在同步方法中遇到Error、Exception，导致异常结束
4. 当前线程在同步代码块执行了wait()方法，当前线程暂停，并释放锁

不会释放锁的情况

1. 同步方法中调用sleep、yield方法，不会释放锁

2. 执行同步方法块时，线程调用了该线程的suspend()方法将线程挂起，不会释放锁

   suspend会使running变成ready状态，不建议使用suspend