多线程

发表于 | 分类于
字数统计: 2.6k word | 阅读时长 ≈ 9 min
一些基础概念
  • 程序（program）：是为完成特定任务、用某种语言编写的一组指令的集合。即指一段静态的代码，静态对象
  • 进程（process）：是程序的一次执行过程，或是正在运行的一个程序。是一个动态的过程：有它自身的产生、存在和消亡的过程。——生命周期
    • 进程作为资源分配的单位，系统在运行时会为每个进程分配不同的内存区域
  • 线程（thread）:进程可进一步细化为线程，是一个程序内部的一条执行路径.若一个进程同一时间 并行执行多个线程，就是支持多线程的.
    • 线程作为调度和执行的单位，每个线程拥有独立的运行栈和程序计数器(pc)
  • 并行与并发
    • 并行：多个CPU同时执行多个任务
    • 并发：一个CPU（采用时间片）同时执行多个任务
Thread类
构造器
  • Thread() ：创建新的Thread对象
  • Thread(String threadname)： 创建线程并指定线程实例名
  • Thread(Runnable target) ：指定创建线程的目标对象，它实现了Runnable接
    口中的run方法
  • Thread(Runnable target, String name) ：创建新的Thread对象
特性
  • 1.每个线程都是通过某个特定Thread对象的run()方法来完成操作的，经常把run()方法的主体称为 线程体
  • 通过该Thread对象的start()方法来启动这个线程，而非直接调用run()
有关方法
  • void start(): 启动线程，并执行对象的run()方法
  • run(): 线程在被调度时执行的操作
  • String getName(): 返回线程的名称
  • void setName(String name):设置该线程名称
  • static Thread currentThread(): 返回当前线程。在Thread子类中就是this，通常用于主线程和Runnable实现类
  • static void yield()： 线程让步，暂停当前正在执行的线程，把执行机会让给优先级相同或更高的线程，若队列中没有同优先级的线程，忽略此方法
  • join() ： 当某个程序执行流中调用其他线程的 join() 方法时，调用线程将
    被阻塞，直到 join() 方法加入的 join 线程执行完为止，低优先级的线程也可以获得执行
  • static void sleep(long millis) ：(指定时间:毫秒)，令当前活动线程在指定时间段内放弃对CPU控制,使其他线程有机会被执行,时间到后重排队。抛出InterruptedException异常
  • stop(): 强制线程生命期结束，不推荐使用
  • boolean isAlive()： 返回boolean，判断线程是否还活着
创建线程的两种方式
继承Thread类

  • 用法：

    • 1.定义子类继承Thread类
    • 2.子类中重写Thread类中的run方法
    • 3.创建Thread子类对象，即创建了线程对象
    • 4.调用线程对象start方法：启动线程，调用run方法

  • 说明：

    • 1.如果自己手动调用run()方法，那么就只是普通方法，没有启动多线程模式

    • 2.run()方法由JVM调用，什么时候调用，执行的过程控制都有操作系统的CPU
      调度决定

    • 3.想要启动多线程，必须调用start方法

    • 4.一个线程对象只能调用一次start()方法启动，如果重复调用了，则将抛出以上
      的异常IllegalThreadStateException

实现Runnable接口
  • 用法：
    • 1.定义子类，实现Runnable接口
    • 2.子类中重写Runnable接口中的run方法
    • 3.通过Thread类含参构造器创建线程对象
    • 4.将Runnable接口的子类对象作为实际参数传递给Thread类的构造器中
    • 5.调用Thread类的start方法：开启线程，调用Runnable子类的run方法
  • 好处
    • 1.避免了单继承的局限性
    • 2.多个线程可以共享同一个接口实现类的对象，非常适合多个相同的线程来处理同一份资源
线程的调度
调度策略
  • 时间片
  • 抢占式：高优先级的线程抢占CPU
Java的调度方法
  • 同优先级线程组成先进先出队列（先到先服务），使用时间片策略
  • 对高优先级，使用优先调度的抢占式策略
线程的优先级
线程的优先级等级
  • MAX_PRIORITY ：10
  • MIN _PRIORITY ：1
  • NORM_PRIORITY ：5
涉及方法
  • getPriority() ：返回线程优先值
  • setPriority(int newPriority) ： 改变线程的优先级
说明
  • 线程创建时继承父线程的优先级
  • 低优先级只是获得调度的概率低，并非一定是在高优先级线程之后才被调用
线程分类
  • Java中的线程分为两类：一种是 守护线程，一种是 用户线程
  • 守护线程是用来服务用户线程的，通过在start()方法前调用
    thread.setDaemon(true)可以把一个用户线程变成一个守护线程
  • Java垃圾回收就是一个典型的守护线程
  • 它们在几乎每个方面都是相同的，唯一的区别是判断JVM何时离开
  • 若JVM中都是守护线程，当前JVM将退出
线程的生命周期
概述

JDK 中用Thread.State 类定义了 线程的几种状态

  • 新建： 当一个Thread类或其子类的对象被声明并创建时，新生的线程对象处于新建
    状态
  • 就绪：处于新建状态的线程被start()后，将进入线程队列等待CPU时间片，此时它已
    具备了运行的条件，只是没分配到CPU资源
  • 运行：当就绪的线程被调度并获得CPU资源时,便进入运行状态， run()方法定义了线
    程的操作和功能
  • 阻塞：在某种特殊情况下，被人为挂起或执行输入输出操作时，让出 CPU 并临时中
    止自己的执行，进入阻塞状态
  • 死亡：线程完成了它的全部工作或线程被提前强制性地中止或出现异常导致结束
看图

线程的同步
出现的安全问题
  • 当多条语句在操作同一个线程共享数据时，一个线程对多条语句只执行了一部分，还没有
    执行完，另一个线程参与进来执行。导致共享数据的错误
  • 解决方案：对多条操作共享数据的语句，只能让一个线程都执行完，在执行过程中，其他线程不可以参与执行
同步机制 Synchronized

  • Java 对于多线程的安全问题提供了专业的解决 方式 ： 同步 机制

  • 用法：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    //同步代码块 ：

    synchronized ( 对象 ){
    		//  需要被同步的代码；
    }

    // synchronized 还可以放在方法声明中，表示整个方法为同步方法
    public synchronized void show (String name){
    	….
    }
Synchronized锁
1
2
3
4
5
6
7
8
9
/**

在《Thinking in Java》中，是这么说的：对于并发工作，你需要某种方式来防
止两个任务访问相同的资源（其实就是共享资源竞争）。 防止这种冲突的方法
就是当资源被一个任务使用时，在其上加锁。第一个访问某项资源的任务必须
锁定这项资源，使其他任务在其被解锁之前，就无法访问它了，而在其被解锁
之时，另一个任务就可以锁定并使用它了

*/
  • 哪些操作会释放锁？
    • 1.当前线程的同步方法、同步代码块执行结束
    • 2.当前线程在同步代码块、同步方法中遇到break、return终止了该代码块、
      该方法的继续执行
    • 3.当前线程在同步代码块、同步方法中出现了未处理的Error或Exception，导
      致异常结束
    • 4.当前线程在同步代码块、同步方法中执行了线程对象的wait()方法，当前线
      程暂停，并释放锁
  • 哪些操作不会释放锁？
    • 1.线程执行同步代码块或同步方法时，程序调用Thread.sleep()、
      Thread. Yield()方法暂停当前线程的执行
    • 2.线程执行同步代码块时，其他线程调用了该线程的suspend()方法将该线程
      挂起，该线程不会释放锁（同步监视器），应尽量避免使用suspend()和resume()来控制线程
死锁
  • 含义：不同的线程分别占用对方需要的同步资源不放弃，都在等待对方放弃自己需要的同步资源，就形成了线程的死锁
Lock(锁)

  • 含义： 从JDK 5.0开始，Java提供了更强大的线程同步机制——通过显式定义同
    步锁对象来实现同步。同步锁使用Lock对象充当

    1
    2
    3
    4
    5
    6
    7
    java.util.concurrent.locks.Lock接口是控制多个线程对共享资源进行访问的
    工具。锁提供了对共享资源的独占访问，每次只能有一个线程对Lock对象
    加锁，线程开始访问共享资源之前应先获得Lock对象

    ReentrantLock 类实现了 Lock ，它拥有与 synchronized 相同的并发性和
    内存语义，在实现线程安全的控制中，比较常用的是ReentrantLock，可以
    显式加锁、释放锁

  • 如图

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    class A{
        private final ReentrantLock lock = new ReenTrantLock();
            public void m(){
                lock.lock();
                try{
                    // 保证线程安全的代码;
                }
                finally{
                		lock.unlock();
            		}
        }
    }
synchronized 与 Lock 的对比

  • 1.Lock是显式锁（手动开启和关闭锁，别忘记关闭锁），synchronized是
    隐式锁，出了作用域自动释放

  • 2.Lock只有代码块锁，synchronized有代码块锁和方法锁

  • 3.使用Lock锁，JVM将花费较少的时间来调度线程，性能更好。并且具有
    更好的扩展性（提供更多的子类）
进程的通信
wait() 与 notify() 和 notifyAll()
  • wait():令当前线程挂起并放弃CPU、同步资源并等待，使别的线程可访问并修改共享资源，而当前线程排队等候其他线程调用notify()或notifyAll()方法唤醒，唤醒后等待重新获得对监视器的所有权后才能继续执行
  • notify(): 唤醒正在排队等待同步资源的线程中优先级最高者结束等待
  • notifyAll ()：唤醒正在排队等待资源的所有线程结束等待
  • 说明：这三个方法只有在synchronized方法或synchronized代码块中才能使用，否则会报java.lang.IllegalMonitorStateException异常
0%