一、重点知识
thread重写了tostring方法
getid()获得线程的标识符 从一开始，是唯一的，在生命周期中保持不变，线程死亡后此标识符可以被重用
main的标识符为1
通过线程标识符，可以对线程进行区分。
sleep使当前正在执行的线程进入睡眠和谁调用这个方法没有关系
sleep是醒了之后继续执行，不是重新执行一次。
反射中创建运行时类时会报编译时异常InstantiationException
守护线程（setDaemon）守护前台线程（就是我们ide控制的线程）垃圾回收机制就是个守护进程
前台线程结束，后台线程就结束了
线程死亡后会被销毁
原子性操作：代码一次性被一个线程执行完，不能被其他线程插入
方法要想执行得放在栈空间中
栈是用来执行方法的
jvm虚拟机启动后最少存在两个线程，实际情况启动了很多线程，但最少存在两个，主线程和gc垃圾回收线程
线程并不是程序开的，而是程序申请开线程，操作系统给程序开的线程，线程的管理权和监测权归操作系统所有
一个新的线程开启之后不会阻塞当前代码的执行
多线程的优势
https://blog.csdn.net/stonesing/article/details/49746661
多线程的最大意义是节省等待时间，在一个线程需要等待时可以执行其他线程
如果程序中没有等待时间，多线程将变得毫无意义
线程越多，效率越低，系统需要维护，监测管理多线程，所以会降低效率，浪费性能
就绪状态是一定存在的
自己创建的线程的run方法中还可以创建线程
新的线程是老的线程创建的
主线程与其他线程的关系
https://www.cnblogs.com/qiumingcheng/p/8202393.html
当非守护线程结束后，守护线程不是立即结束，他有一个检测过程
程序运行到什么位置会失去执行权是不固定的
最好不要让线程共享数据，是解决多线程安全问题得最优解
二、重点问题
同步监视器的选取问题
自己定义的锁记得千万不能定义到run方法中，不然每个run方法都会创建一个锁.....字面常量也可以当锁，内存中只有一份
继承实现线程的时候，锁可以在外部创造，然后在构造方法中传入锁，这样就能保证用的是一把锁
三、课堂知识
3.1、线程的两种启动方式
Thread类：JDK提供好的类，用于表示一个线程对象。实现了Runnable接口
Runnable接口：定义了唯一的一个方法：run()——>线程体
方法一：直接继承Thread类
step1：创建一个子类，来继承Thread类
step2：重写run()方法，因为这是线程体：当CPU调度执行该线程的时候，就要执行的是run()方法中的代码。
step3：创建该类的对象，表示一个线程，调用start()进而启动这个线程。意味着该线程一切准备就绪，随时可以被CPU调度执行。但是CPU并不是立即执行，要看CPU自己是否调用了这个线程。
方法二：实现Runnable接口
step1：创建一个实现类，实现Runnable接口
step2：重写run()方法
step3：先创建该实现类对象，根据实现类对象再创建Thread对象，然后启动。
Thread类的构造方法：
Thread();//创建一个线程对象，执行run()。线程的默认名：Thread-0,1,2...
Thread(Runnable target);//创建一个线程对象，指明了target，执行的run是Runnable接口中。
Thread(String name);//创建一个线程，并给起个名字
Thread(Runnable target,String name);
对比两种创建并启动线程的方式：
* 开发中：优先选择：实现Runnable接口的方式
* 原因：1. 实现的方式没类的单继承性的局限性
* 2. 实现的方式更适合来处理多个线程共享数据的情况。
* 联系：public class Thread implements Runnable
* 相同点：两种方式都需要重写run(),将线程要执行的逻辑声明在run()中。
目前两种方式，要想启动线程，都是调用的Thread类中的start()。
3.2、线程的常用方法
关于Thread类的常用方法：
1、获取当前的线程对象：由Thread类直接调用，获取当前正在被执行的那个线程
static Thread currentThread() ;//返回对当前正在执行的线程对象的引用。
2、线程的名字：当一个线程创建的时候，如果没有设置名称：构造方法设置，或者setName()设置。系统默认的：Thread-0,Thread-1,Thread-2......
String getName()
返回此线程的名称。
void setName(String name)
将此线程的名称更改为等于参数 name 。
3、线程的Id：每个线程创建的时候，由系统自动分配一个Id，long类型的数值，终身不变。从线程的出生到死亡。
该Id值，由系统自动分配，程序员无法手动操作。
long getId()
返回此线程的标识符。
4、线程的优先级：priority
System.out.println("最大优先级："+Thread.MAX_PRIORITY);//10
System.out.println("最小优先级："+Thread.MIN_PRIORITY);//1
System.out.println("正常优先级："+Thread.NORM_PRIORITY);//5
当一个线程被创建的时候，由系统自动分配一个优先级，固定都是正常优先级：5
但是程序员可以根据需求，手动调整线程的优先级。
int getPriority()
返回此线程的优先级
void setPriority(int newPriority)
更改此线程的优先级。
优先级别高，被CPU调度执行的机会就多。但是不绝对。
优先级别低，被CPU执行的机会就少，但是也不绝对。
5、线程的睡眠：
static void sleep(long millis)
使当前正在执行的线程以指定的毫秒数暂停（暂时停止执行），具体取决于系统定时器和调度程序的精度和准确性。
静态方法，应该由类直接调用，对象也可以调用，有坑：不是谁调用就谁睡，而是当前正在执行的线程进入睡眠了。和谁调用无关。
6、线程合并
在线程a中调用线程b的join(),此时线程a就进入阻塞状态，直到线程b完全执行完以后，线程a才结束阻塞状态。
等待这个线程死亡。
t1线程，t2线程，main线程
t1,t2,main--->3条线程抢占资源
某一个时刻：main线程中：t1.join()，主线程要等待t1线程死亡之后再执行
t1，t2--->2条线程抢占资源，main等
t1结束后，main线程再执行
7、守护线程
setDaemon();
为前台线程服务，如果所有的前台线程都结束了，那么守护线程也就结束了。
GC：垃圾自动回收机制。JVM启动后，创建主线程执行main()的时候。。。随之而创建并启动的还有很多后台线程，比如gc()
3.3、线程的状态
线程的生命周期：
线程new出来：新建
准备就绪，启动：start：就绪状态
如果被CPU调度执行：运行状态，run()方法
阻塞状态：-->进入就绪
出生-->就绪-->运行-->死亡
线程的生命周期
3.4、临界资源的安全问题
概念：多个线程访问共享的数据，临界资源。多个线程之间存在共享的数据。一条线程执行过程中，其他线程也可以访问，可能会修改数据的值。造成的共享数据的不安全。叫做临界资源的安全问题。
3.5、同步synchronized
同步：原子性操作。同步起来的代码，一次只能被1个线程执行完毕，这个过程中，不能被其他的线程插入执行。
同步的原理：
对象的"互斥锁"。每个对象都可以看做一个锁。有两种状态：打开(默认)，关闭。
锁对象：多条线程功能访问的同一个对象。
同步的方式一：同步代码块
* synchronized(同步监视器){
* //需要被同步的代码
* }
* 说明：1.操作共享数据的代码，即为需要被同步的代码。 -->不能包含代码多了，也不能包含代码少了。
* 2.共享数据：多个线程共同操作的变量。比如：ticket就是共享数据。
* 3.同步监视器，俗称：锁。任何一个类的对象，都可以充当锁。
* 要求：多个线程必须要共用同一把锁。
*
* 补充：在实现Runnable接口创建多线程的方式中，我们可以考虑使用this充当同步监视器。
在继承Thread类创建多线程的方式中，慎用this充当同步监视器，考虑使用当前类充当同步监视器。
* 同步的 方式二：同步方法
* 如果操作共享数据的代码完整的声明在一个方法中，我们不妨将此方法声明同步的。
* 关于同步方法的总结：
* 1. 同步方法仍然涉及到同步监视器，只是不需要我们显式的声明。
* 2. 非静态的同步方法，同步监视器是：this
* 静态的同步方法，同步监视器是：当前类本身
死锁：多个线程互相持有对象，僵持的现象。
解决死锁：
1、减少成员变量的使用。
2、加大锁的粒度。不要锁小对象，锁大对象。
注意字面常量也能充当锁，他在内存中也是唯一的
网友评论