Java初学笔记22-【线程1】

一、线程的概念

1. 程序

是为完成特定任务、用某种语言编写的一组指令的集合。简单的说:就是我们写的代码。（静态）

2. 进程

（1）进程是指运行中的程序，比如我们使用QQ，就启动了一个进程，操作系统就会为该进程分配独立的内存资源。当我们使用迅雷，又启动了一个进程，操作系统将为迅雷分配新的独立的内存资源。（动态）
（2）进程是程序的一次执行过程，或是正在运行的一个程序。是动态过程：有它自身的产生、存在和消亡的过程 。即存在生命周期。
（3）一旦启动一个进程，就会“吃掉”一定的CPU和内存

3. 线程

（1）线程由进程创建的，是进程的一个实体，是具体干活的人
（2）一个进程可以拥有多个线程
（3）通俗理解进程与线程：启动迅雷（进程），下载多个文件（线程）。
（4）线程不独立分配内存，而是共享进程的内存资源

4. 单线程

同一个时刻，只允许执行一个线程

5. 多线程

同一个时刻，可以执行多个线程，比如:一个qq进程，可以同时打开多个聊天窗口,一个迅雷进程,可以同时下载多个文件

6. 并发

同一个时刻，多个任务交替执行。但是本质上还是执行一个任务。造成一种“貌似同时”的错觉，简单的说，单核cpu实现的多任务就是并发。

7. 并行

（1）同一个时刻，多个任务同时执行。多核cpu可以实现并行。
（2）并发与并行可以同时存在

8.上下文

（1）用户线程执行的过程我们称之为用户态
（2）内核调度的状态称之为内核态
（3）每一个线程运行时产生的数据我们称之为上下文，线程的每次切换都需要进行用户态到内核态的来回切换，同时伴随着上下文的切换，是一个保存数据现场和恢复的过程，是一个比较消耗资源的操作。

二、创建线程的4种方式

1. 创建线程的4种方式

（1）继承Thread类，重写run方法
（2）实现Runnable接口,重写run方法
（3）使用Lammbda表达式
（4）有返回值的线程

2. 创建线程方法一：继承Thread类

（1）当一个类继承了 Thread 类， 该类就可以当做线程使用
（2）我们会重写 run 方法，写上自己的业务代码
（3）Thread 类 实现了 Runnable 接口的 run 方法

3. 创建线程方法二：实现Runnable接口

（1）实现Runnable接口的类A，该A类对象无法使用start()开始线程。而是先创建一个Thread类的对象b，将A类的对象放入其中，再用b.start()启动线程。

4. 创建线程方法三：使用Lammbda表达式

5. 创建线程方法四：有返回值的线程

三、继承Thread类&&多线程机制

1. 示例代码–继承Thread类

2. JConsole监控线程执行情况

（1）先Run程序
（2）点击进入Terminal

（3）在终端输入JConsole

（4）连接查看

（5）主线程与子线程并发执行

（6）主线程结束后，子线程未结束，子线程继续执行

3. 多线程示意图

4. 多线程总结

（1）进程一开始，启动主线程main，与此同时，启动子线程Thread-0；
（2）主线程main，与子线程Thread-0并发执行
（3）但主线程执行完后，若子线程还未执行完，进程不会退出。等到所有线程执行完毕，才退出。

5. 为什么执行start()，而不是直接run()

（1）如果在main方法中若是执行：cat.run()，则只有主线程，此时run只是一个普通的方法。
（2）如果在main方法中若是执行：cat.start()，则在主线程执行过程中，启动了一个新的子线程。

四、实现Runnable接口

1. 介绍

（1）java是单继承的，在某些情况下一个类可能已经继承了某个父类,这时在用继承Thread类方法来创建线程显然不可能了。
（2）java设计者们提供了另外一个方式创建线程，就是通过实现Runnable接口来创建线程。
（3）实现Runnable接口的类A，该A类对象无法使用start()开始线程。而是先创建一个Thread类的对象b，将A类的对象放入其中，再用b.start()启动线程。
（4）此处（3）用到一种设计模式–代理模式

2. 示例代码

五、静态代理模式

（1）Thread类代理完成线程的启动
（2）代码模拟Thread类的代理模式
（3）示例代码

六、继承Thread与实现Runnable接口的区别

1. java的设计来看,通过继承Thread类或者实现Runnable接口来创建线程本质上没有区别，从jdk帮助文档我们可以看到Thread类本身就实现了Runnable接口
2. 实现Runnable接口方式更加适合多个线程共享一个资源的情况，并且避免了单继承的限制.
3. 代码示例：
   
   
   03结果】

七、线程终止

1. 自然结束

当线程完成任务后，会自动退出。

2. 通知方式（使用标志位）

通过使用变量来控制run方法退出的方式停止线程，即通知方式
注意：变量能否刷主存中，保险起见，改变量使用volatile 关键字

八、线程常用方法

1. setName 设置线程名称

设置线程名称，使之与参数name相同

2. getName 返回该线程的名称

3. start 线程开始执行

使该线程开始执行，Java虚拟机底层调用该线程的 start0方法

4. run

调用线程对象 run方法;

5. setPriority 更改线程的优先级

6. getPriority 获取线程的优先级

7. sleep 线程休眠

在指定的毫秒数内让当前正在执行的线程休眠(暂停执行)。线程的静态方法。

8. interrupt 中断休眠的线程

但并没有真正的结束线程。所以一般用于中断正在休眠线程

9. join 线程的插队

（1）插队的线程一旦插队成功，则肯定先执行完插入的线程所有的任务。
（2）join方法的本意是阻塞创建了该线程的线程。主线程mian中产生了子线程joinThread，joinThread调用join方法，阻塞main线程，先继续执行joinThread线程。

10. yield 线程的礼让

让出cpu，让其他线程执行,但礼让的时间不确定，所以也不一定礼让成功。如果资源够用，也不会礼让成功。该方法是静态方法。

11. 细节

（1）start底层会创建新的线程，调用run，run 就是一个简单的方法调用，不会启动新线程
（2）线程优先级的范围

九、用户线程和守护线程

1. 用户线程

也叫工作线程，以线程的任务执行完 或 通知方式结束线程

2. 守护线程

（1）一般是为用户线程服务的，当所有的用户线程结束，守护线程自动结束。
（2）守护线程对于后台支持任务非常有用，例如垃圾收集，释放未使用对象的内存以及从缓存中删除不需要的条目。大多数JVM线程都是守护线程。在比如qq等等聊天软件,主程序是用户线程,而所有的聊天窗口是守护线程,当在聊天的过程中,直接关闭聊天应用程序时,聊天窗口也会随之关。包括word中我们在书写文字的时候，还有线程帮我们进行拼写检查，这都是守护线程。

3. 常见的守护线程：垃圾回收机制

4. 如何设置成守护线程？

只需要在线程启动前，加入：线程对象.setDaemon(true);

5. 守护进程代码举例

public static void main(String[] args) {
        Thread t1 = new Thread(() -> {
            int count = 10;
            Thread t2 = new Thread(() -> {
                while (true){
                    ThreadUtils.sleep(300);
                    System.out.println("t2是个守护线程！");
                }
            });
            t2.setDaemon(true);
            t2.start();

            while (count >= 0){
                ThreadUtils.sleep(200);
                System.out.println("t1是用户线程！");
                count--;
            }
            System.out.println("t1用户线程结束-------------------");
        });
        t1.start();
    }

十、线程的生命周期

1. 线程状态

Thread类中有一个内部枚举类，这个State就可以表示一个线程的生命周期：

2. 线程6个状态之间的关系

3. 进入Runnable状态不代表程序可以立马执行，具体什么时候执行还得看内核态的调度。
4. 新创建一个线程，此时为NEW状态；当线程start()后，此时为Runnable状态；线程执行完后，此时为Teminated状态。
5. 在Runnable状态下，当执行sleep(),wat(),join()等等，会进入TimeWaiting状态，即超时等待状态，时间结束之后，又会进入Runnable状态。

十一、线程同步机制

1. 什么是同步？

（1）在多线程编程中，一些敏感数据不允许被多个线程同时访问，此时就使用同步访问技术，保证数据在任何时刻，最多有一个线程访问，以保证数据的完整性。
（2）也可以这样理解：线程同步，即当有一个线程在对内存进行操作时，其他线程都不可以对这个内存地址进行操作，直到该线程完成操作，其他线程才能对该内存地址进行操作。

2. 怎么样同步？用Synchronized

（1）同步代码块
得到对象的锁，才能操作同步代码

synchronized(对象){      
    需要被同步代码;
}

（2）synchronized还可以放在方法声明中，表示整个方法为同步方法

public synchronized void m (String name){
    需要被同步的代码;
}

（3）通俗理解：
就好像某个人上厕所前先把门关上(上锁)，完事后再出来(解锁)，那么其它人就可再使用厕所了。

（4）代码示例：

【1】售票问题


【2】售票问题（改进）

3. 同步原理分析图

十二（1）synchronized互斥锁：用synchronized关键字

1. 介绍

（1）Java语言中，引入了对象互斥锁的概念，来保证共享数据操作的完整性。
（2）每个对象都对应于一个可称为“互斥锁”的标记，这个标记用来保证在任一时刻，只能有一个线程访问该对象。
（3）关键字synchronized来与对象的互斥锁联系。当某个对象用synchronized修饰时，表明该对象在任一时刻只能由一个线程访问
（4）同步的局限性：导致程序的执行效率要降低
（5）同步方法(非静态的)的锁可以是this,也可以是其他对象(要求是同一个对象)。即，非静态的同步方法，锁是在对象上面。
（6）同步方法(静态的)的锁为当前类本身。即，静态的同步方法，锁是在类上面.

举例1.
静态同步方法的锁为当前类本身, 锁是加在 exercise03.class

    public synchronized static void m1() {
    }

举例2.
在静态方法中，实现一个同步代码块.

    public static void m2() {
        synchronized (exercise03.class) {
            System.out.println("m2");
        }
    }

举例3.
非静态同步方法, 在同一时刻， 只能有一个线程来执行 sell 方法

    public synchronized void sell1() {
    }

举例4.
在非静态方法中，实现一个同步代码块,这时锁在 this 对象，或者object对象

    Object object = new Object();
    public void sell2() {
        synchronized (object 或者 this) {
            if (ticketNum <= 0) {
                System.out.println("售票结束...");
                loop = false;
                return;
            }
        }
    }

2. 注意细节

（1）同步方法如果没有使用static修饰：默认锁对象为this
（2）如果方法使用static修饰，默认锁对象：当前类.class
（3）实现的步骤，需要先分析上锁的代码，选择同步代码块或同步方法【优先选择同步代码块，因为范围小，效率高】要求多个线程的锁对象为同一个

十二（2）synchronized原理分析

1. 字节码层面看

先运行下面代码，在终端查看字节码文件内容


线程当看到，有monitorenter（监视器进入），里面若有执行的线程，则该线程等待，直到里面的线程完成执行monitorexit（监视器退出），才可以进入

十二（3）四把锁的升级

1. 无锁

不加锁。

eg。当从头至尾只有甲在使用厕所时候，厕所不上锁

2.偏向锁

不锁，只有一个线程争夺时，偏心某一个线程，这个线程来了不加锁。

eg。如果来了乙，和甲一起共用厕所，但是之后甲再也不用厕所了，测试厕所只有乙在使用，厕所偏向于乙，以后当乙再来的时候，厕所是不会上锁的。

3. 轻量级锁

少量线程，先尝试自旋，不挂起线程。因为 自旋的消耗 < 挂起的消耗

eg。如果有20个人要是用这个厕所，当厕所被其中一个人使用时，其他19个人不会回家（线程挂起），而是会隔一段时间敲一次门（自旋），看看能不能进去。

4. 重量级锁

大量线程，挂起线程。因为 自旋的消耗 > 挂起的消耗

eg。当有1000个人来使用厕所时候，其他999个人只能先回家（线程挂起），因为999个人一直等着敲门（自旋），有的人第二天也等不到

十二（4）Lock锁

1. Lock接口

// 获取锁  
void lock()   

// 仅在调用时锁为空闲状态才获取该锁，可以响应中断  
boolean tryLock()   

// 如果锁在给定的等待时间内空闲，并且当前线程未被中断，则获取锁  
boolean tryLock(long time, TimeUnit unit)   

// 释放锁  
void unlock()  

获取锁，两种写法：

Lock lock = ...;
lock.lock();
try{
    //处理任务
}catch(Exception ex){

}finally{
    lock.unlock();   //释放锁
}

Lock lock = ...;
if(lock.tryLock()) {
     try{
         //处理任务
     }catch(Exception ex){

     }finally{
         lock.unlock();   //释放锁
     } 
}else {
    //如果不能获取锁，则直接做其他事情
}

2. Lock接口实现类 ReentrantLock类

十二（5）synchronized和ReentrantLock的区别

1. 区别
   Lock是一个接口，synchronized是Java中的关键字，synchronized是内置的语言实现；
   synchronized发生异常时，会自动释放线程占用的锁，故不会发生死锁现象。Lock发生异常，若没有主动释放，极有可能造成死锁，故需要在finally中调用unLock方法释放锁；
   Lock可以让等待锁的线程响应中断，使用synchronized只会让等待的线程一直等待下去，不能响应中断
   Lock可以提高多个线程进行读操作的效率

十二（6）ReentrantReadWriteLock类

对于一个应用而言，一般情况读操作是远远要多于写操作的，如果仅仅是读操作的情况下数据又是线程安全的，读写锁给我们提供了一种锁，读的时候可以很多线程同时读，但是不能有线程写，写的时候是独占的，其他线程既不能写也不能读。在某些场景下能极大的提升效率。

举例

其中在ReentrantReadWriteLock类中有内部类ReadLock类和WriteLock类，这两个类都实现了Lock接口，且重写了lock方法和unclock方法。

十二（7）lock锁的原理cas和aqs

1. CAS

（1）compare and swap的缩写，中文翻译成比较并交换
（2）思路很简单，就是给一个元素赋值的时候，先看看内存里的那个值到底变没变，如果没变我就修改，变了我就不改了，其实这是一种无锁操作，不需要挂起线程，无锁的思路就是先尝试，如果失败了，进行补偿，也可以继续尝试。

2. AQS

（1）抽象队列同步器，用来解决线程同步执行的问题

（2）AQS中维护了一个双向队列。其中一个节点表示一个线程，它保存着线程的引用（thread）、状态（waitStatus）、前驱节点（prev）、后继节点（next）等信息。

十三（1）线程死锁

1. 介绍

多个线程都占用了对方需要的锁资源，但不肯相让，导致了死锁，在编程中是一定要避免死锁的发生。

2. 避免方法

尽量避免在一个代码块去抢夺两个锁

3. 死锁演示

十三（2）线程重入

线程重入是指任意线程在获取到锁之后，再次获取该锁而不会被该锁所阻塞。synchronized是可重入锁

public class Test {
    private static final Object M1 = new Object();
    private static final Object M2 = new Object();

    public static void main(String[] args) {
        new Thread(() -> {
            synchronized (M1){
                synchronized (M2){
                    synchronized (M1){
                        synchronized (M2){
                            System.out.println("hello lock");
                        }
                    }
                }
            }
        }).start();
    }
}

十三（3）锁的wait方法和notify方法

十四、释放锁

1. 会释放锁的操作

（1）当前线程的同步方法、同步代码块执行结束。

案例: 上厕所，完事出来

（2）当前线程在同步代码块、同步方法中遇到break、return。

案例：没有正常的完事，经理叫他修改bug,不得已出来

（3）当前线程在同步代码块、同步方法中出现了未处理的Error或Exception,导致异常结束。

案例: 没有正常的完事，发现忘带纸，不得已出来

（4）当前线程在同步代码块、同步方法中执行了线程对象的wait()方法，当前线程暂停，并释放锁。

案例：没有正常完事，觉得需要酝酿下，所以出来等会再进去

2. 不会释放锁的操作

（1）线程执行同步代码块或同步方法时，程序调用Thread.sleep()、Thread.yield()方法暂停当前线程的执行，不会释放锁。

案例:上厕所，太困了，在坑位上眯了一会

（2）线程执行同步代码块时，其他线程调用了该线程的suspend()方法将该线程挂起，该线程不会释放锁。

提示:应尽量避免使用suspend()和resume()来控制线程，方法不再推荐使用

十五、LockSupport 线程阻塞工具类

1. 常用方法 park unpark

public static void park(Object blocker); // 暂停当前线程
public static void parkNanos(Object blocker, long nanos); // 暂停当前线程，不过有超时时间的限制
public static void parkUntil(Object blocker, long deadline); // 暂停当前线程，直到某个时间
public static void park(); // 无期限暂停当前线程
public static void parkNanos(long nanos); // 暂停当前线程，不过有超时时间的限制
public static void parkUntil(long deadline); // 暂停当前线程，直到某个时间
public static void unpark(Thread thread); // 恢复当前线程
public static Object getBlocker(Thread t);

2. 举例

调用park方法，也可以传入信息，再用getBlocker获取信息

十六、练习题

部分资料参考：元动力 JAVA多线程入门