本章需要学习的单词

producer        consumer        bak          run        thread        start        daemon        futuretask

生产                消费                消费        跑          线程          启动            守护           未来任务

override          overload        transient            serializa                deserializa        seriaversionUID

覆盖                重载           不参与序列化        序列化                    反序列化          序列化版本号

runnable        current           interruput            priority                task                       safe

可运行的         当前               打断                   优先级                任务                      安全

balance          deadlock       callable                 wait                notify

余额                死锁             可调用的                等待                通知

开始正题

注意：JAVA只支持单继承，但是JAVA的接口支持多实现。

                        线程的生命周期

新建状态        就绪状态        运行状态        阻塞状态        死亡状态 

阻塞状态

用户输入Scanner和睡眠方法sleep都会使当前线程进入阻塞状态

怎么唤醒正在睡眠的线程呢？

sleep方法是Thread类的静态方法，参数是毫秒。

Thread类的interrupt方法,打断睡眠。

stop类似于断电，可能会丢失数据。

合理的中断一个线程的执行

合理的方法是：打布尔标记。

关于线程的调度

抢占式模型和均分式模型

JAVA采用的是抢占式模型，哪个线程的优先级高，哪个线程抢到的Cpu时间片的概率就高一些

priority有十个等级，最低是一级，最高是十级，JAVA默认的等级是五。

                        开辟多线程的三种方式

前两种不返回线程的返回值，后一种可以获得线程的返回值

第一种、

编写自己的一个类myThread1去继承Thread类，重写Thread类的无返回值的run方法，将myThread1类创建出来,调用myThread对象的start方法启动线程。

myThread1 m=new myThread1();//创建线程对象

m.start();//启动线程

//继承

Class myThread1 extents Thread{

public void run(){

        }

}

第二种、

编程自己的一个类myThread2去实现Runnable接口，实现run方法，在新建myThread2对象，然后新建Thread对象，将myThread02对象传入到Thread对象的构造方法中，在调用Thread对象的start方法启动线程。

myThread2 m2=new myThread2();//创建myThread2对象

Thread t=new Thread(m2);//将m2传入Thread构造方法中，参数是Runnable类型

t.start();//启动线程

//实现接口

class myThread2 implements    Runnable{

        public void run(){

        }

}        

第三种、

//三层套娃

myThread3 m=new myThread3（);//新建Callable对象

FutureTask ft=new FutureTask(m);//新建FutureTask对象

Thread t=new Thread(ft);//新建Thread对象

t.statr();//启动线程

Object obj=ft.get();//获取线程的返回值，返回的类型是Object类型

//实现接口

class myThread3 implements Callable{

        public Object call(){

return null;

        }

}

注意：获取线程的返回值，可能会使当前线程进入阻塞状态，当前线程需要等待

其他线程的执完之后，返回来的执行结果。

缺点：浪费的时间可能比较多一些。

优点：可以获取线程的返回值。

                        关于线程名字的一些操作

Thread类的一个静态方法currentThread()方法返回一个Thread类型的对象，这个对象就是

当前线程对象，可以对他进行修改和获取名字。Thread.currentThread().getName();

有点像this,代码是固定的，永远都可以拿到当前线程。

获取当前线程的名字

Thread.currentThread().getName();

修改当前线程的名字

Thread.currentThread().setName();

多线程最重要的就是多线程安全，数据在什么情况下会有多线程安全问题呢？

1、多线程并发

2、多线程数据的共享

3、多线程数据的修改

如何解决多线程安全问题呢？

解决线程安全的问题就是多线程排队执行，不能并发，这种机制被称为线程同步机制。

两个线程模型的专业术语

线程同步模型，线程异步模型

同步：排队执行，能保证线程安全，效率低。

异步：线程各自执行各自的，不排队，虽然效率高，但是存在线程安全问题。

保证线程安全的关键字

synchronized(){

格式就是一个小括号加一个大括号，小括号里面的内容非常关键，必须是多线程共享的数据

想要哪几个线程排队，就需要填写哪几个线程的共享的对象，才能达到多线程排队。

}

JAVAd对象都有一把锁，synchronized就是这个原理。

JAVA三大变量中，堆区存储实例变量，方法区存储静态变量，栈区存储局部变量

堆区和方法区的资源共享，但是栈区的空间不共享，一个线程一个栈，所以局部

变量不会出现多线程安全问题。

synchronized可以写在实例方法上，并且一定共享的是this，代码节简了。

synchronized有两种方法，一种是同步代码块，还有一种是修饰方法。

类锁和对象锁，一个对象一把对象锁，一个类一个类锁，一百个对象一百把对象锁

但是一百个类绝对是一百把类锁。

                        守护线程

JAVA中线程分两种，守护线程(后台线程)，用户线程

守护线程就是一个死循环，所有用户线程结束后，守护线程自动结束。

垃圾回收线程就是守护线程

将用户线程设置为守护线程调用setDaemon(true);

                        定时器

在特定的时间，执行特定的代码，程序。

sleep()是最原始的定时器

JAVA类库中有定时器类，java.util.timer；

定时器timer是一个线程，实现了Runnable接口。

SimpleDataFormat对象有一个parse方法，将字符串转换成日期，返回值是Date对象，

要精确到年，月，日，时，分。

例如

String time="2021-09-16 10:40";

SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

Date date=sdf.parse(time);

myTimer mt=new myTimer();

/*第一个参数是定时器对象run方法中要执行的特定代码，第二个参数是第一次开始执行的时间

第三个参数是每次间隔的时间，单位是毫秒*/

timer.schedule(mt,date,1000*10);

class myTimer extents TimerTask{

        public void run(){

        }

}

                        wait和notify

不是线程对象的方法，是根父类自带的方法，Object中的原始方法

wait()方法，让当前线程进入等待状态，无期限等待，知道被唤醒为止，释放掉当前占有的对象锁

notify()方法,唤醒当前线程。

notifyAll()方法，唤醒所有线程

生产者和消费者模式，最重要的是供求关系要平衡。