day33——多线程

一、上节课回顾

1、多线程的创建和启动

方法一：通过继承Thread类
class MyThread extends Thread{
    @Override
    public void run(){
        //此处的代码，并发的执行。。
    }
}
public static void main(String[] args){
    MyThread t1 = new MyThread();//创建线程对象
    t1.start();//启动线程——>准备就绪，就等着被CPU调度执行
}
方法二：通过实现Runnable接口
class MyThread2 implements Runnable{
    private ....//成员变量
    public void run(){
        
    }
}
public static void main(String[] args){
    MyThread2 mt = new MyThread2();
    Thread t2 = new Thread(mt);
    Thread t3 = new Thread(mt);
    t2.start();
    t3.start();
}
区别：
    1、一种通过继承的方式，不能再有其他的父类。而通过实现接口，可以再继承其他的父类。
    2、通过Runnable接口的方式，可以很方便的实现多个线程之间的数据共享。

2、线程的常用方法：

A：线程的Id，线程的唯一标识：long的整数，终身不变。
    由系统自动编号，程序员只能获取getId()，不能更改
B：线程的Name：线程的名称
    设置和获取
    setName()
    getName()
    构造方法：提供名称
        Thread类构造方法：Thread(String name);
C：获取当前的线程对象：静态的方法
    Thread.currentThread()--->Thread对象
    谁正在被执行，就获取哪个线程对象——>获取当前的对象
        理解为：该方法在哪个线程中调用，就是获取哪个线程对象。
D：线程的Priority，优先级
    int整数：
        MAX_PRIORITY:10
        MIN_PRIORITY:1
        NORM_PRIORITY:5
        
        t1,t2,t3..main...-->默认的优先级：5
        
    setPriority(),getPriority()
    优先级高，执行的机会多。优先级低，执行的机会少。
    不绝对。
E：线程的睡眠：sleep，静态的方法
    Thread.sleep(time)
    当前正在执行的线程，进入了睡眠，放弃了CPU的执行。和哪个线程对象来调用无关。
        理解为：该方法写在哪个线程中调用，就是哪个线程进入睡眠。
F：线程的合并：join
    t1，t2，main线程
        main线程中：执行了t1.join()
    等待线程死亡——>在main线程中，要等待t1线程结束后，main线程才能执行。
    
G：守护线程：daemon
    setDaemon(true)-->设置为守护线程，为前台线程提供服务，如果所有的前台线程都结束了，那么守护线程就结束了。
    isDaemon()-->boolean
H：其他的方法

        

3、线程的生命周期

线程的生命周期：线程这"一辈子"
从创建一个线程对象开始，直到该线程结束，死亡。一个线程只有一辈子，只能被启动一次。

新建：线程对象创建出来了
    Thread t1 = new Thread();//"刚出生"

就绪：执行start()方法，万事准备完毕
    随时可以被CPU调度执行
    
运行：自动执行run()方法

死亡：线程结束了

阻塞：
    暂时不能执行：
    等待：
        有期限：sleep(time)
        无期限：join()
锁阻塞：
t1,t2,t3,t4

同步代码块：锁对象：t1，上锁

线程的状态2.png

4、多线程之间的共享数据安全问题(临界资源问题)

多个线程访问共享的数据，可能存在数据的不安全。

t1线程访问数据：中途被其他线程抢跑了，它还修改了。。。t1再抢回来，数据已经被改了，就是不安全。

"物是人非"

5、如何解决临界资源的问题

同步：原子性操作：(化学中表示最小颗粒，不可再分)

​ 计算机中用于表示一次性执行完毕。

同步：一次性执行完毕。

语法：关键字synchronized

用法一：同步代码块：一次只能被一个线程执行，中间不允许其他线程插入执行的。

//t1,t2,t3,t4
synchronized(锁对象){//开始给对象上锁,t1

}//打开对象的锁
特征：
    A：synchronized小括号里的对象，是锁对象，并要求多线程的情况下，锁对象必须是同一个对象。
    B：synchronized大括号里的代码，就是同步执行的代码。或者说是加了锁的代码。意味着每次只能被一个线程执行。
    C：同步的代码越少越好，在保证安全的情况下，提高性能。
    D：锁对象：理论上谁都可以，只要是多个线程访问的共同对象即可。
        this关键字，外面创建对象传入，类名.class，"abc"，

用法二：同步方法：一个方法就是同步，只能被一个线程来执行，中间不允许其他线程来打断执行

public synchronized void test(){

}
StringBuffer,StringBuilder，

同步的原理：对象的"互斥锁"

​ 锁：打开的状态

​ 锁：关闭的状态

Java中的任意对象，身上都有互斥锁。默认就是打开状态

上厕所：

​ 小A，小B，小C

​ 第一动作：关门上锁

​ 当结束后：打开门开锁，然后其他的线程才能够来执行

多线程同步上锁锁不住？

• 多线程存在共享的数据安全
• 锁对象，是否是多个线程能够访问的共同的对象。99%

Class类的对象：类编译后的字节码文件对应的对象。

Object类：

​ 对象.getClass()-->Class

Person：

​ 1.对象.getClass()-->Class

​ p1.getClass()-->Class ---->Person.class

​ 2.类名.class-->Class

​ Person.class

​ 3.Class类中有一个静态的方法：forName("类名")

​ Class.forName("com.qf.demo01.Person");-->Class

同步的优缺点：

好处：解决了数据安全的问题

缺点：降低了效率，可能会死锁

二、本节课内容

2.1、同步方法

同步代码块：使用synchronized关键字包裹了一块代码，让这块代码同步执行。就是每次只能一个线程来执行。

同步方法：使用synchronized关键字修饰一个方法，这个方法同步执行。就是每次只能一个线程来执行。

• 普通的方法：对象调用。锁定的对象，就是this对象。
• 静态的方法：类调用。锁定的对象，就是类名.class

同步的原理：利用对象的互斥锁。

​ 每个线程来访问，只能有一个线程进入执行，第一个动作锁对象(上锁)。来保证其他线程不能进入执行。等到该线程结束这个同步代码块或者同步方法，释放锁对象(开锁)，才允许其他的线程来访问。

线程安全的类：

StringBuffer

Vector

HashTable

Collections，集合的工具类

2.2、线程之间的通信

线程之间的通信：wait()，notify()，notifyAll()

wait()——>让线程进入阻塞状态，暂停执行。一直阻塞

notify()——>唤醒线程，wait()住的线程，被唤醒。如果多个线程wait()了，唤醒其中的一个。

notifyAll()——>唤醒所有。

语法要求：必须在同步中，由同步的锁对象来调用。否则java.lang.IllegalMonitorStateException异常。

生产者消费者模型：

生产者(线程t1)负责生产产品，存入容器中(固定容量)，消费者(线程t2)从容器中获取产品消费掉。
容器：
    生产者：持有资源，生产产品，存入容器中
    消费者：持有资源，消费掉产品。

容器满了：最多装8个鸡蛋
    生产者：持有资源，暂停执行——直到容器还能继续装。
        锁对象.wait()——>会让线程进入阻塞状态。暂停执行。notify()，notifyAll()
    消费者：持有资源，直接消费。。
    
容器空了：最少0个。
    生产者：持有资源，生产，存入。。
    消费者：持有资源，暂停执行——直到容器中有产品
        锁对象.wait()——>会让线程进入阻塞状态。暂停执行。notify()，notifyAll()
        
        

生产者消费者模型.png

代码分析：

1、产品类：Egg()-->id
2、产生者：线程
    cpu执行，run()-->生产鸡蛋，装入容器
3、消费者：线程
    cpu执行，run()-->从容器中获取鸡蛋，吃掉(打印。。)

容器对象：

​ Class实现容器

​ 数组： Egg[] arr = new Egg[8];

​ 集合：栈，后进先出

同步的代码：

​ 锁的是容器对象：

wait()和sleep()方法的区别：

• 出处不同：
  • sleep()方法是Thread类中定义的。
  • wait()方法是Object类中定义的。
• 解除阻塞的方式不同
  • sleep()是时间到，自己醒。
  • wait()方法等待被唤醒：notify()，或者是notifyAll()
• 对锁资源的释放情况
  • sleep()，不释放，抱着不撒手
  • wait()，释放

等待和唤醒.png

2.3、线程池

线程宝贵的资源，线程对象。都是我们自己new来的线程对象。单个线程对象大概占1M左右的内存空间。
线程对象创建出来：生命周期
    从创建到死亡：run()执行线程体
    
假如说，我们需要大量的线程，来执行任务。频繁的创建线程，销毁线程。。。是一种资源的浪费，造成程序性能的下降。

线程池：理解为一个容器，装线程的。里面可以事先创建好一些线程。。
    如果有任务要执行，从线程池中获取线程对象，干活。。。归还给线程池，等待下次的任务
    降低频繁的创建和销毁线程的过程

客服：
    4个客服：
            13个用户：9个等一下
    客服A：用户1
        接收下一个任务。。用户5.。
    客服B：用户2
    客服C：用户3
    客服D：用户4