一、上节课回顾
1、多线程的创建和启动
方法一：通过继承Thread类
classMyThreadextendsThread{
@Override
publicvoidrun(){
//此处的代码，并发的执行。。
}
}
publicstaticvoidmain(String[]args){
MyThreadt1=newMyThread();//创建线程对象
t1.start();//启动线程——>准备就绪，就等着被CPU调度执行
}
方法二：通过实现Runnable接口
classMyThread2implementsRunnable{
private....//成员变量
publicvoidrun(){
}
}
publicstaticvoidmain(String[]args){
MyThread2mt=newMyThread2();
Threadt2=newThread(mt);
Threadt3=newThread(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...-->默认的优先级：
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
3、线程的生命周期
线程的生命周期：线程这"一辈子"
从创建一个线程对象开始，直到该线程结束，死亡。一个线程只有一辈子，只能被启动一次。
新建：线程对象创建出来了
Thread t1 = new Thread();//"刚出生"
就绪：执行start()方法，万事准备完毕
随时可以被CPU调度执行
运行：自动执行run()方法
死亡：线程结束了
阻塞：
暂时不能执行：
等待：
有期限：sleep(time)
无期限：join()
4、多线程之间的共享数据安全问题(临界资源问题)
多个线程访问共享的数据，可能存在数据的不安全。
t1线程访问数据：中途被其他线程抢跑了，它还修改了。。。t1再抢回来，数据已经被改了，就是不安全。
5、如何解决临界资源的问题
同步：原子性操作：(化学中表示最小颗粒，不可再分)
计算机中用于表示一次性执行完毕。
同步：一次性执行完毕。
语法：关键字synchronized
用法一：同步代码块：一次只能被一个线程执行，中间不允许其他线程插入执行的。
//t1,t2,t3,t4
synchronized(锁对象){//开始给对象上锁,t1
}//打开对象的锁
特征：
A：synchronized小括号里的对象，是锁对象，并要求多线程的情况下，锁对象必须是同一个对象。
B：synchronized大括号里的代码，就是同步执行的代码。或者说是加了锁的代码。意味着每次只能被一个线程执行。
C：同步的代码越少越好，在保证安全的情况下，提高性能。
D：锁对象：理论上谁都可以，只要是多个线程访问的共同对象即可。
this关键字，外面创建对象传入，类名.class，"abc"，
用法二：同步方法：一个方法就是同步，只能被一个线程来执行，中间不允许其他线程来打断执行
publicsynchronizedvoidtest(){
}
StringBuffer,StringBuilder，
同步的原理：对象的"互斥锁"
锁：打开的状态
锁：关闭的状态
Java中的任意对象，身上都有互斥锁。默认就是打开状态
多线程同步上锁锁不住？
多线程存在共享的数据安全
锁对象，是否是多个线程能够访问的共同的对象。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()
代码分析：
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()，释放
三、总结
同步方法，同步代码块
synchronized(锁对象){
}
publicsynchronizedvoidtest(){
}
注意点：
同步代码块：自己指定锁对象。
同步方法：锁对象是固定的。
普通的同步方法：锁对象：this
静态的同步方法：锁对象：类名.class
线程之间的通信：生产者消费者模型
