多线程的使用

2年前 (2022) 程序员胖胖胖虎阿

128 0 0

1. 多线程
多任务执行,多路径执行

优点:
    1.提高性能。
    2.提高效率。

进程与线程之间的区别:

 进程 : 系统中的程序,一个进程之间可以包含1~n个线程,系统中资源分配的最小单位,每个进程都有自己的代码与数据空间,进程之间的切换开销较大。
 线程 : 程序中的顺序流,线程是cpu调度与执行的最小单位,多个线程之间共享进程的代码和数据空间,每一个线程都有自己的程序计数器运行栈,线程之间切换开销较小。
 注意：一个cpu同一时刻只能调度一个线程。

创建线程的方式 :

 1.继承Thread,重写run方法 + start开启线程。
 2.实现Runnable接口,重写run方法 + start开启线程。
 3.实现Callable接口,重写call方法 + 线程池。

实现Runnable接口,重写run方法+start开启线程：

 优点:
     1.接口多实现,类的单继承。
     2.实现资源共享。

实现Callable接口,重写call方法 + 线程池 :

实现juc包下的Callable接口,重写call方法 + 线程池
优点:
    call方法可以抛出异常,可以定义返回值,run方法不可以。

2. 线程的状态
新生状态 : new
就绪状态
运行状态 : cpu调度
阻塞状态
终止状态

 注意：
    1. 一个线程如果一旦进入终止状态,不可恢复。
    2.一个线程如果进入到阻塞状态,阻塞解除之后,不能直接恢复到运行,会直接恢复高就绪状态,等待cpu的调度。
 如何让线程进入到就绪状态:
    1.start()。
    2.阻塞解除。
    3.cpu的调度切换。
    4.yield 礼让线程。
 如何让线程进入阻塞状态:
    1.sleep()。
    2.join() 插队线程。
    3.wait() 等待。
    4.IO。
 如何让线程进入终止状态:
    1.正常执行完毕。
    2.stop() 过时--> 不推荐使用。
    3.通过标识判断。

sleep（）：
线程休眠。

 方法：
    static void sleep(long millis)              
             导致当前正在执行的线程休眠（暂时停止执行）指定的毫秒数，具体取决于系统计时器和调度程序的精度和准确性。
    static void sleep(long millis, int nanos)   
             执行ms+ns。
 注意：
    1.当一个线程调度sleep进入睡眠状态,让出cpu的资源。
    2.抱着资源睡觉: 这个资源不是cpu的资源, 值的是对象的锁资源。
 作用:
    1.放大问题出现的可能性。
    2.模拟网络延迟。

join（）：
插队线程。

 方法：
    void join() 
             等待这个线程死亡。
    void join(long millis) 
             此线程最多等待 millis毫秒。
    void join(long millis, int nanos) 
             此线程最多等待 millis毫秒加上 nanos纳秒。
 注意：
    A线程执行过程中,如果B线程插队了,A线程就会进入到阻塞状态,等待插队线程执行完毕|等待执行的时间,A线程会恢复到就绪状态。

3. void interrupt()
为线程添加一个中断标识。

 方法：
    boolean isInterrupted()
           测试此线程是否已被中断,是否曾经调用过interrupt方法添加了中断标识。
    static boolean interrupted() 
           测试当前线程是否已被中断,是否曾经调用过interrupt方法添加了中断标识,同时复位标识。
 注意: 
 当调用sleep方法线程睡眠时 : InterruptedException - 如果有任何线程中断了当前线程。 抛出此异常时，将清除当前线程的中断状态 。

4. Thread.State getState()
获取线程状态。

 Thread.State 线程状态。 
 线程可以处于以下状态之一：
    NEW : new Thread()
        尚未启动的线程处于此状态。
    RUNNABLE : 就绪|运行。
        在Java虚拟机中执行的线程处于此状态。
    BLOCKED : 等待对象锁的阻塞状态。
        被阻塞等待监视器锁定的线程处于此状态。
    WAITING : wait(),join()等。
        无限期等待另一个线程执行特定操作的线程处于此状态。
    TIMED_WAITING : 与时间相关的等待,sleep(ms),join(ms),wait(ms)...
        正在等待另一个线程执行最多指定等待时间的操作的线程处于此状态。
    TERMINATED : 终止。
        已退出的线程处于此状态。

5. 线程的优先级
放大线程优先执行的可能性。

 1~10 设置值：
    1最小 ->static int MIN_PRIORITY 线程可以拥有的最低优先级。
    10最大->static int MAX_PRIORITY 线程可以拥有的最大优先级。
    5默认值 ->static int NORM_PRIORITY 分配给线程的默认优先级。
 方法：
    int getPriority()                 返回此线程的优先级。
    void setPriority(int newPriority) 更改此线程的优先级。

6. 线程的分类

 用户线程 : 默认线程为用户线程。
 守护线程 : 守护用户线程的。
 注意：
    1.当所有的用户线程全都执行完毕,守护线程直接结束。
    2.垃圾回收机制典型守护线程。
 方法：
    void setDaemon(boolean on)    
            将此线程标记为 daemon线程或用户线程。

7. 线程安全
当多个线程同时操作同一份资源,才有可能出现线程不安全问题。

 同步锁 synchronized : 有可能出现数据不安全的代码段,让多个线程排队执行。
 同步的使用:
    同步条件 :  协调多个线程排队执行的条件  -->对象的锁。
    同步的代码 :  需要多个线程排队执行的代码。
 synchronized用法:
    修饰方法 : 同步方法。
        1.同步实例方法：
            条件 : 调用成员方法的对象。
            代码范围 : 整个方法体。
        2.同步静态方法：
            条件 : 锁类->锁的类的Class对象->一个类只有一个,加载到内存中究存在Class对象,不变,唯一。
            代码范围 : 整个方法体。
  修饰块 : 同步块
     synchronized(条件){
          排队执行的代码;
     }
  注意:
     1.同步的代码范围太大,效率太低。
     2.同步的代码范围太小,锁不住,不安全。

同步方法控制案例的数据安全：

 在方法上通过synchronized关键字修饰方法
     1.成员方法：
         锁的是调用成员方法的对象
     2.静态方法：
         锁的是类的Class对象
 优点: 简单,直接同步整个方法体。
 缺点: 代码范围太大,效率较低。

同步块 :

 格式：
    synchronized(条件){
        排队执行的代码;
    }
 条件: 类名.class | this | 资源。

 锁类: 锁类相当于锁住了这个类的所有对象,如果只想要锁当前类的某一个对象,建议锁那一个具体的对象this。
 锁this: 成员方法中this默认指代当前调用成员方法的对象。
     如果锁this,就是锁一个对象,相当于锁住了这个对象的所有资源(成员),如果指向锁一个对象的某一个资源,建议可以直接锁资源。
 锁资源: 锁对象,锁不变的内容。
     自定义引用数据类型的对象地址永远不变。

8. 线程通信

生产者消费者模式: 生产者用来生产商品,消费者就是消费产品。
方法：Object类中wait() 等待,notify() 唤醒,notifyAll() 唤醒全部。
  wait() 等待
     通过对象调用wait()方法让当前进入等待阻塞状态,会进入到调用wait方法对象的等待池中进行等待,等待被唤醒。让出cpu的资源,同时释放对象的锁。
  notify() 唤醒 
     唤醒对象等待池中正在等待的线程,被唤醒的线程进入到就绪队列,需要被cpu调度同时获取对象锁才能执行。
注意：
  wait()与notify()必须使用在同步环境下,用来协调多线程对共享数据存储的问题,否则会抛出异常 IllegalMonitorStateException - 如果当前线程不是此对象监视器的所有者。

版权声明：程序员胖胖胖虎阿发表于 2022年11月10日上午4:40。
转载请注明：多线程的使用 | 胖虎的工具箱-编程导航