多线程

1、基本概念：程序、进程、线程

程序（program）：是为完成特定任务、用某种语言编写的一组指令的集合。即指一段静态的代码，静态对象。

进程（process）：是程序的一次执行过程，或是正在运行的一个程序。是一个动态的过程：有它自身的产生、存在和消亡的过程。------生命周期

  如：运行中的QQ，运行中的MP3播放器
​
     程序是静态的，进程是动态的.

进程作为资源分配的单位，系统在运行时会为每个进程分配不同的内存区域.（进程和进程之间的内存是独立的）

线程（thread）：进程可进一步细化为线程，是一个程序内部的一条执行路径。若一个进程同一时间并行执行多个线程，就是支持多线程的。

线程作为调度和执行的单位，每个线程拥有独立的运行栈和程序计数器（pc）,线程切换的开销小.

一个进程中的多个线程共享相同的内存单元/内存地址空间→它们从同一堆中分配对象，可以访问相同的变量和对象。这就使得线程间通信更简便、高效。但多个线程操作共享的系统资源可能就会带来安全的隐患。

 

单核CPU和多核CPU的理解

  1. 单核CPU，其实是一种假的多线程，因为在一个时间单元内，也只能执行一个线程的任务。例如：虽然有多车道，但是收费站只有一个工作人员在收费，只有收了费才能通过，那么CPU就好比收费人员。如果有某个人不想交钱，那么收费人员可以把他“挂起”（晾着他，等他想通了，准备好了钱，再去收费）。但是因为CPU时间单元特别短，因此感觉不出来。

  2. 如果是多核的话，才能更好的发挥多线程的效率。（现在的服务器都是多核的）

  3. 一个Java应用程序java.exe，其实至少有三个线程：main()主线程，gc() 垃圾回收线程，异常处理线程。当然如果发生异常，会影响主线程。

并行与并发

  1. 并行：多个CPU同时执行多个任务。比如：多个人同时做不同的事。

  2. 并发：一个CPU(采用时间片)同时执行多个任务。比如：秒杀、多个人做同一件事。

 

使用线程的优点

背景：以单核CPU为例，只使用单个线程先后完成多个任务（调用多个方法），肯定比用多个线程来完成用的时间更短，为何仍需多线程呢？

多线程程序的优点：

  1. 提高应用程序的响应。对图形化界面更有意义，可增强用户体验。

  2. 提高计算机系统CPU的利用率。

  3. 改善程序结构。将既长又复杂的进程分为多个线程，独立运行，利于理解和修改。

 

多线程有什么作用

多线程不是为了提高执行速度,而是提高应用程序的使用率。线程和线程共享“堆内存和方法区内存”,栈内存是独立的,一个线程一个栈。可以给现实世界中的人类一种错觉: 感觉多个线程在同时并发执行。

 

何时需要多线程

  1. 程序需要同时执行两个或多个任务。

  2. 程序需要实现一些需要等待的任务时，操作、网络操作、搜索等。

  3. 需要一些后台运行的程序时。

 

2、多线程的创建方式----->四种方式

第一种、继承于Thread类

  1. 创建一个继承于Thread类的子类

  2. 重写Thread类的run() →将此线程执行的操作声明在run()中

  3. （在测试类）创建Thread类的子类的对象

  4. 通过此对象调用start() →start()方法的两个作用：①启动当前线程、②调用当前线程的run()

注意点：①要想创建多个线程，就去new多个线程对象；

              ②要想启动这个线程，只能启动start()，不能直接去调用run()

 

第二种、实现Runnable接口

  1. 创建一个实现Runnable接口的类

    2）实现类去实现Runnable中的抽象方法：run()

  2. 创建实现类的对象

  3. 将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象

  4. 通过Thread类的对象调用start()：①启动线程、②调用当前线程的run()--->调用了Runnable类型的target的run()

比较以上两种创建线程的方式：

开发中，优先选择→实现Runnable接口的方式

原因：①实现的方式没有类的单继承性的局限性

           ②实现的方式更适合来处理多个线程有共有数据的情况。

联系：public class Thread implements Runnable

相同点：两种方式都需要重写run()，将线程要执行的操作声明在run()中。

              目前两种方式，要想启动线程，都是调用的Thread类中的start()。

 

第三种、实现Callable接口 ---->JDK5.0新增

  1. 创建一个实现Callable的实现类

  2. 实现call()方法，将此线程需要执行的操作声明在call()中

  3. 创建Callable接口实现类的对象

  4. 将此Callable接口实现类的对象作为参数传递到FutureTask构造器中，创建FutureTask的对象

  5. 将FutureTask的对象作为参数传递到Thread类的构造器中 ，创建Thread对象，并调用start()方法

  6. .获取Callable中call方法的返回值

 

【补充】如何理解实现Callable接口的方式创建多线程比实现Runnable接口创建多线程方式强大？

  1. call()可以有返回值的。

  2. call()可以抛出异常，被外面的操作捕获，获取异常的信息

  3. Callable是支持泛型的

 

第四种、使用线程池 ---->JDK5.0新增

  1. 提供指定线程数量的线程池

  2. 执行指定的线程的操作。需要提供实现Runnable接口或Callable接口实现类的对象

  1. 关闭连接池。

 使用线程池创建多线程的好处：

　　 1、提高响应速度（减少了创建新线程的时间） 

　　 2、降低资源消耗（重复利用线程池中的线程，不需要每次都创建） 

　　 3、便于线程管理： 

                                     corePoolSize：核心池的大小 

                                     maximumPoolSize：最大线程数

                                     KeepAliveTime：线程没有任务时最多保持多长时间后会终止

 

Thread类的常用方法

1、start()：启动当前线程；调用当前线程的run()

2、run()：线程在被调度时执行的操作。通常需要重写Thread类中的此方法，将创建的线程要执行的操作声明在此方法中

3、getName()：获取当前线程的名称

4、setName(String name)：设置当前线程的名称

5、static Thread currentThread()：返回当前线程。在Thread子类中就是this，通常用于主线程和Runnable实现类

6、yield()：线程让步。释放当前CPU的执行权

7、join()：在线程A中调用线程B的join()，此时线程A就进入阻塞状态，直到线程B完全执行完以后，线程A才结束阻塞状态（低优先级的线程也可以获得执行）

8、sleep(long millitime)：（指定时间：毫秒），令当前活动线程在指定时间段内放弃对CPU控制，使其他线程有机会被执行，时间到后重排队

9、stop()：已过时。当执行此方法时，强制结束当前线程

10、isAlive()：返回boolean，判断线程是否还活着

 

 

修改线程名字的两种方式

  1. 通过setName()方法，传值修改；

  2. 通过构造方法传参的方式。

 

线程的优先级

  1. 线程的优先级分为：MAX_PRIORITY：10

                                             MIN _PRIORITY：1

                                             NORM_PRIORITY：5 --->默认优先级

  1. 如何获取和设置当前线程的优先级：getPriority()：获取线程的优先级

                                                              setPriority(int p)：设置线程的优先级

    说明：高优先级的线程要抢占低优先级线程cpu的执行权。但是只是从概率上讲，高优先级的线程高概率的情况下被执行。并不意味着只有当高优先级的线程执行完以后，低优先级的线程才执行。

 

线程的分类

Java中的线程分为两类：一种是守护线程、一种是用户线程。

  • 它们在几乎每个方面都是相同的，唯一的区别是判断 JVM何时离开。

  • 守护线程是用来服务用户线程的，通过在start()方法前调用thread.setDaemon(true)可以把一个用户线程变成一个守护线程。

  • Java垃圾回收就是一个典型的守护线程。

  • 若 JVM中都是守护线程，当前 JVM将退出。

 

 

3、线程的生命周期

  1. 线程的生命周期一共分为五个状态:新建、就绪、运行、阻塞、消亡。

  2. 原理(非常重要): 线程新建之后调用start()方法进入就绪状态，在就绪状态的线程表示有权利去获取CPU的时间片。当在就绪状态中的线程抢到CPU时间片后通过调用run()方法执行程序（这个时候就代表进入了运行状态），当抢夺到的CPU时间片用完后再次进入到就绪状态，重新等待抢夺CPU时间片。当抢到CPU时间片后再次进入运行状态通过run()方法继续执行未完成的程序，如果线程中途遇到阻塞事件(如等待键盘的输入等)则线程就进入到阻塞状态，当阻塞解除后，线程再次回到就绪状态以等待抢夺CPU时间片，如此循环，直到该线程抢到的时间片够把整个程序运行完，然后run()方法结束，该线程就会进入消亡状态。

  3. 线程的生命周期图：

 

 

 

  1. 线程的状态转换图：

     

     

     

4、线程的安全问题

1、在Java中，我们通过同步机制，来解决线程的安全问题。

方式一：同步代码块 ​

             synchronized(同步监视器){

                   ​ //需要被同步的代码 ​

              } ​

说明：①操作共享数据的代码，即为需要被同步的代码。--->不能包含代码多了，也不能包含代码少了 ​

           ②共享数据：多个线程共同操作的变量。比如：ticket就是共享数据。 ​

           ③同步监视器，俗称：锁。任何一个类的对象，都可以充当锁。 要求：多个线程必须要共用同一把锁。

补充：在实现Runnable接口创建多线程的方式中，我们可以考虑使用this

           在继承Thread类创建多线程的方式中，慎用this充当同步监听器，可以考虑使用当前类充当监听器。

方式二：同步方法，在方法上加锁synchronized

              关于同步方法的总结：

                    1、同步方法仍然涉及到同步监视器，只是不需要我们显示的声明。

                     2、非静态的同步方法，同步监视器是：this

                           静态的同步方法，同步监视器是：当前类本身

2、同步的方式，解决了线程的安全问题。----->好处 操作同步代码时，只能有一个线程参与，其他线程等待。相当于是一个单线程的过程，效率低。---->局限性

方式三：lock锁---->JDK5.0新增

               lock需要手动的启动同步（lock()）,同时结束同步也需要手动的实现（unlock()）

 

 

5、线程的死锁问题

1、死锁的理解：不同的线程分别占用对方需要的同步资源不放弃，都在等待对方放弃自己需要的同步资源，就形成了线程的死锁。

2、说明：

              1).出现死锁后，不会出现异常，不会出现提示，只是所有的线程都处于阻塞状态，无法继续。

              2).我们使用同步时，要避免出现死锁。

3、 解决办法

  • 专门的算法、原则

  • 尽量减少同步资源的定义

  • 尽量避免嵌套同步

 

6、线程的通信

涉及到三个方法：

          wait()：一旦执行此方法，当前线程就进入阻塞状态，并释放同步监视器。

          notify()：一旦执行此方法，就会唤醒被wait的一个线程。如果有多个线程被wait，就唤醒优先级高的那个。

          notifyAll()：一旦执行此方法，就会所有被wait的线程。

说明：

        1、wait()、notify()、notifyAll()，三个方法必须使用在同步代码块或同步方法中。

        2、wait()、notify()、notifyAll()，三个方法的调用者必须是同步代码块或同步方法中的同步监视器。

                                                           否则，会出现IllegalMonitorStateException异常。

        3、wait()、notify()、notifyAll()，三个方法是定义在java.lang.Object类中。

 

 

 

posted @ 2021-07-24 21:27  -亾䢋-  阅读(73)  评论(0)    收藏  举报