Java初学笔记22

• 一、线程的概念
• • 1. 程序
  • 2. 进程
  • 3. 线程
  • 4. 单线程
  • 5. 多线程
  • 6. 并发
  • 7. 并行
• 二、创建线程的方式
• • 1. 创建线程的两种方式
  • 2. 创建线程方法一：继承Thread类
  • 3. 创建线程方法二：实现Runnable接口
• 三、继承Thread类&&多线程机制
• • 1. 示例代码--继承Thread类
  • 2. JConsole监控线程执行情况
  • 3. 多线程示意图
  • 4. 多线程总结
  • 5. 为什么执行start()，而不是直接run()
• 四、实现Runnable接口
• • 1. 介绍
  • 2. 示例代码
• 五、静态代理模式
• 六、继承Thread与实现Runnable接口的区别
• 七、进程终止
• 八、线程常用方法
• • 1. setName
  • 2. getName
  • 3. start
  • 4. run
  • 5. setPriority
  • 6. getPriority
  • 7. sleep
  • 8. interrupt
  • 9. join
  • 10. yield
  • 11. 细节
• 九、用户线程和守护线程
• • 1. 用户线程
  • 2. 守护线程
  • 3. 常见的守护线程：垃圾回收机制
  • 4. 如何设置成守护线程？
• 十、线程的生命周期
• • 1. 线程状态
  • 2. 线程6个状态之间的关系
• 十一、线程同步机制
• • 1. 什么是同步？
  • 2. 怎么样同步？用Synchronized
  • • 【1】售票问题
    • 【2】售票问题（改进）
  • 3. 同步原理分析图
• 十二、互斥锁
• • 1. 介绍
  • 2. 注意细节
• 十三、线程死锁
• • 1. 介绍
  • 2. 避免方法
• 十四、释放锁
• • 1. 会释放锁的操作
  • 2. 不会释放锁的操作
• 十五、练习题

一、线程的概念

1. 程序

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

2. 进程

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

3. 线程

（1）线程由进程创建的，是进程的一个实体
（2）一个进程可以拥有多个线程
（3）通俗理解进程与线程：启动迅雷（进程），下载多个文件（线程）。

4. 单线程

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

5. 多线程

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

6. 并发

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

7. 并行

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

二、创建线程的方式

1. 创建线程的两种方式

（1）继承Thread类，重写run方法
（2）实现Runnable接口,重写run方法

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

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

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

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

三、继承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方法退出的方式停止线程，即通知方式

八、线程常用方法

1. setName

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

2. getName

返回该线程的名称

3. start

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

4. run

调用线程对象 run方法;

5. setPriority

更改线程的优先级

6. getPriority

获取线程的优先级

7. sleep

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

8. interrupt

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

9. join

线程的插队。插队的线程一旦插队成功，则肯定先执行完插入的线程所有的任务

10. yield

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

11. 细节

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

九、用户线程和守护线程

1. 用户线程

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

2. 守护线程

一般是为用户线程服务的，当所有的用户线程结束，守护线程自动结束

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

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

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

十、线程的生命周期

1. 线程状态

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. 介绍

（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）实现的步骤，需要先分析上锁的代码，选择同步代码块或同步方法【优先选择同步代码块，因为范围小，效率高】要求多个线程的锁对象为同一个

十三、线程死锁

1. 介绍

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

2. 避免方法

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

十四、释放锁

1. 会释放锁的操作

（1）当前线程的同步方法、同步代码块执行结束。
案例: 上厕所，完事出来
（2）当前线程在同步代码块、同步方法中遇到break、return。案例：没有正常的完事，经理叫他修改bug,不得已出来
（3）当前线程在同步代码块、同步方法中出现了未处理的Error或Exception,导致异常结束。案例: 没有正常的完事，发现忘带纸，不得已出来
（4）当前线程在同步代码块、同步方法中执行了线程对象的wait()方法，当前线程暂停，并释放锁。案例：没有正常完事，觉得需要酝酿下，所以出来等会再进去

2. 不会释放锁的操作

（1）线程执行同步代码块或同步方法时，程序调用Thread.sleep()、Thread.yield()方法暂停当前线程的执行，不会释放锁。
案例:上厕所，太困了，在坑位上眯了一会
（2）线程执行同步代码块时，其他线程调用了该线程的suspend()方法将该线程挂起，该线程不会释放锁。
提示:应尽量避免使用suspend()和resume()来控制线程，方法不再推荐使用

十五、练习题