Javase多线程

外部类$内部类.class
外部类$1.class

设计模式
简单工厂模式：
将对象的创建过程，设计成一个静态的方法，该方法所属的类，就叫工厂类。
单例模式：
一个类限于对象的数量仅有一个。
step1：私有的构造函数。限于本类中创建。
step2：本类中提供一个静态的对象。
step3：提供一个静态的方法，返回对象。


懒汉式，饿汉式。
多线程
进程：一个正在执行的程序


线程：进程中一条执行路径。




主函数所在的线程，叫做主线程：由JVM创建并启动。
主线程：指的UI线程。


创建并启动的线程，子线程，也叫工作线程。



Thread类：
run()--->Runnable
start()--->启动
getName(),setName()
getId()
sleep()-->当前正在执行的线程进入睡眠。。。
currentThread-->Thread对象，正在执行的线程对象。。



方法一：
1.子类，继承Thread类
2.重写run()-->线程体，并发执行的内容，写在run中
3.启动：start()
方法二：
1.实现Runnable接口
2.重写run
3.启动：通过实现类的对象，创建Thread类对象，再执行start.




线程的优先级：
如果一个线程的优先级别高，被执行的机会多。优先级别低，别执行的机会少。但是都不绝对。








守护线程：一般是为前台线程提供服务的。当所有的前台线程都结束，那么守护线程自动结束。。。












线程的加入：join()
t1,t2,main
main:t1.join()
t1,t2
main,t2








线程的打断：interrupt()
A：睡眠
interrupt--->打断睡眠，让线程苏醒，继续执行。。。
B：正在执行
interrupt--->flase--->true

每一条线程，只要被创建，身上都贴了一个标签：
boolean flag--->是否被中断
默认：没有被中断




interrupted()--->获取当前正在执行的线程的标签值：是否被中断
大多数：false
如果一个线程被执行了interrupt()，那么该返回值就是true。


true--->立刻擦除该值：--->false



多个线程，访问共同的数据，那么会存在该数据的不安全性。线程的临界资源问题。
1.多条线程
2.共享数据






如何解决？




对象：创建，默认身上都有一个锁头。
开：默认
关：


同步的原理：利用对象的互斥锁：每个对象都有一个锁头。默认是开的。当有线程访问同步代码块的时候，那么锁关闭的，其他的线程不能够访问。直到锁被打开。




对象：
A：可以是任意对象
B：必须是所有的线程共享的一个对象。








使用同步，来解决线程之间的数据不安全问题


概念：让代码原子性操作，每次只允许一个线程访问。


语法：
synchronized关键字


同步代码块：
//t1,t2,t3,t4
synchronized(对象){//t1--->锁关闭，t2-->关闭
//被同步的代码
一次只能够被一个线程执行。。。
}//锁打开


同步方法：
整个方法，每次只能够被一个线程执行。
非静态的方法：锁定的对象：固定的就是this。
静态的方法：锁定的对象：固定的就是类名.class








同步的优缺点：
优点：可以解决多线程之间的数据安全问题。
缺点：效率低。容易死锁。
扩大锁的粒度。








t1-->o1,o2
t2-->o2,o3
t3-->o3,o4
t4-->o4,o5
t5-->o5,o1


早餐：牛奶，面包


张三：
牛奶
面包
李四：
面包
牛奶








StringBuffer：线程安全
StringBuilder：线程不安全






线程：后宫选秀


皇帝：CPU


主线程：main，皇后


t1,t2,t3,t4.....秀女

start()-->准备就绪


优先级：线程级别的高低


t1：贵妃
t2：才人
t3：。。。。。。






线程的生命周期：每一个线程对象，只有一生：状态：从新建--就绪--运行--死亡。每一个线程，只能够被启动一次。

新建：
new出来，创建完毕--->start()


就绪：
已经准备好了，随时可以被执行。可运行状态：Runnable


运行：
正在被执行--->Running


阻塞：
暂停执行
解除了阻塞-->进入就绪




死亡：





线程池：

每一个线程：
创建--->执行--->死亡销毁





任务：20
创建20个线程对象--->20个任务--->销毁，死亡




5个线程：事先创建好--->容器中
t1，t2，t3，t4，t5--->等着

3个任务：
t1,t,2,t4




200个任务：
t1,t2,t3,t4,t5




线程：5
带缓存的线程池：每个线程如果60s内不执行任务。。。
单线程：池子：1个
定时：







总结和作业：
线程：
1.概念：（重点）
进程中的一条执行路径。
进程：一个正在执行的程序

先有进程，才能有线程。进程如果销毁，线程也随之销毁。如果线程没有，进程不一定销毁。




2.线程的创建和启动（重点）
A：方法一：继承类
step1：创建子类，继承Thread类
step2：重写run()方法，线程体：并发执行的代码，写入run中。
step3：启动：start()-->通过cpu，线程已经就绪，随时可以被执行。


B：方法二：实现接口
step1：创建实现类，实现Runnalbe接口
step2：重写run()
step3：启动：
创建实现类对象：mt
再根据mt，创建Thread类对象：Thread t = new Thread(mt)
t启动线程：start()




对比：
A：如果是继承(因为受到单继承的局限)，不能够再有父类了。而实现接口的方式，可以再继承其他的类。
B：如果是实现接口的方式，那么通过同一个实现类对象，创建的线程对象，可以实现成员变量数据的共享。



3.线程中常用方法：（了解）
A：ID：每一个线程的唯一标识。由系统自动分配。代码中无法更改。
getId()-->long


B：线程名称：
默认：
JVM创建并启动：
主线程main,Android中(UI线程：不允许被阻塞)
main
自己创建并启动线程：
子线程：也叫做工作线程(WorkThread)
Thread-0,1,2,3.....




设置线程名称；
通过setName()
通过父类的构造函数：Thread(name)


C：获取当前线程：
Thread.currentThread()-->获取当前正在执行的线程。




D：优先级：Priority
线程的级别：
最大级别：10
最小级别：1
默认：5


setPriority();
getPriority();


E：join()-->合并，强制，插入。。。
t1,t2,t3--->
t1-->t3.join()--->t2,t3
t1,t2


F：睡眠：Thread.sleep(time)-->当前正在执行的线程进入睡眠，与谁调用无关。关键看写在哪个线程中。


G：打断：
线程对象.interrupt()-->void
1)睡眠中，打断睡眠了，线程继续执行
2)正在执行的线程：修改线程对象的标志：是否被中断boolean flag：false


Thread.interruped()-->boolean
false：
true：被中断，擦除这个状态--->false


H：守护线程
setDaemon()-->服务于前台线程。


4.线程的生命周期：每个线程只能够允许启动一次。（知道）
A：新建状态
new出来，执行了start()-->
B：就绪状态
等待cpu的执行，此时也叫做可运行状态：Runnable
C：运行状态
正在被执行--->Runnging
D：阻塞状态
暂时放弃执行，
解除阻塞，进入到就绪状态


E：死亡状态
线程执行完毕


5.线程间的数据安全问题（看懂）
产生：多个线程，共同访问同一个变量。


解决：使用同步


关键字：synchronized


同步：让代码原子性操作。每次只允许一个线程执行，中间不能被其他线程插入执行。




同步的原理：利用对象的互斥锁。每个对象都有一个互斥锁，默认打开状态。当有线程来访问，那么将锁关闭。其他线程无法进入执行。
语法：
同步代码块
synchronized（对象）{
被同步的代码
}
同步方法
整个方法是同步的

静态方法：锁定类名.class
非静态：this






注意事项：
1.多个线程
2.锁定所有线程的共同访问的对象。




优缺点：
优点：解决线程的安全问题
缺点：效率低，容易死锁


死锁：多个线程互相持有资源，僵持的现象。解决办法：扩大锁对象的粒度。


6.线程池：（了解）
预先创建线程对象，然后为线程对象分配任务。线程存入在容器中，就叫线程池。
线程池对象：ExecutorService接口
操作类：Executors，用于创建线程对象的。
A：线程池中只有一个线程对象：
newSingleThreadExecutor()
任务是一个接着一个执行。。。
B：线程池中有固定数量的线程对象：
newFixedThreadPool(count)


C：线程池中的线程数量，可以改变。
newCachedThreadPool()


D：计划：ScheduledExecutorService
schedule(任务(Runnable),delay,单位);