多线程学习笔记

简介

程序，进程，线程

• 系统值运行的程序就是一个进程，一个进程中可以有多个线程，比如看视频时有画面还有音乐

普通方法与多线程

• 普通方法是一条线到底，主方法开始，之间的其他方法执行完在接着执行主方法
• 而多线程是主方法与其他方法同时进行

Process与Thread

• 进程就是执行程序的过程，它是一个动态的概念，是系统资源分配的单位
• 通常在进程中可以包含多个线程，一个进程至少有一个线程，不然没有存在的意义，线程是cpu调度和执行的单位

核心概念

• 线程就是独立的执行路径
• 在程序运行时，即使没有自己创建线程，后台也会有对多个线程，比如主线程，gc线程
• main（）称之为主线程，是程序的入口，用于执行整个程序
• 线程的运行是由调度器安排调度的，调度器与系统密切相关，线程执行的先后顺序是不能人为干预的
• 对同一份资源进行操作时，会出现资源抢夺的问题，需要加入并发控制
• 线程会带来额外的开销，如CPU调度时间，并发控制开销
• 每个线程只能在自己的工作内存交互，内存控制不当会造成数据不一致

线程创建

• 线程创建主要有三种方法
  • 继承Thread类（主要）
  • 实现Runnable接口（主要）
  • 实现Callable接口（先做了解）

Thread

• 自定义线程类继承Thread类
• 重写run（）方法，编写线程执行体
• 创建线程对象，调用start()方法启动线程

package com.taidou;

//继承Thread类
public class TestThread extends Thread{
    //重写run方法
    @Override
    public void run() {
        for (int i = 0; i < 200; i++) {
            System.out.println("Thread线程"+i);
        }
    }

    //main线程,主线程
    public static void main(String[] args) {
        //创建线程对象，调用start方法启动线程
        TestThread thread = new TestThread();
        thread.start();

        //main方法体
        for (int i = 0; i < 200; i++) {
            System.out.println("main线程"+i);
        }
    }
}

Runnable

• 自定义线程类实现Runnable类
• 重写run（）方法，编写线程执行体
• 创建线程对象，调用start()方法启动线程

package com.taidou;

//继承Thread类
public class TestThread2 implements Runnable{
    //重写run方法
    @Override
    public void run() {
        for (int i = 0; i < 200; i++) {
            System.out.println("Thread线程"+i);
        }
    }

    //main线程,主线程
    public static void main(String[] args) {
        //创建Runnable接口的实现类对象
        TestThread2 thread2 = new TestThread2();
        //创建线程对象，调用start方法启动线程,代理
        //Thread thread = new Thread(thread2);
        //thread.start();
        new Thread(thread2).start();

        //main方法体
        for (int i = 0; i < 200; i++) {
            System.out.println("main线程"+i);
        }
    }
}

Thread与Runnable

• Thread
  • 子类继承Thread类具备多线程能力
  • 启动线程：子类对象.start()
  • 不建议使用：避免OOP的单继承局限
• Runnable
  • 实现接口Runnable具有多线程能力
  • 启动线程：传入目标对象+Thread对象.start() new Thread（传入目标对象）.start()
  • 推荐使用：避免了单继承局限性，灵活方便，方便同一个对象被多个线程使用

package com.taidou;


//多个线程操作同一对象
//买票
public class TestThread3 implements Runnable{
    //票数
    private int tickeNums =10;

    @Override
    public void run() {
        buy();
    }


    //买票的方法
    private void buy() {
        while (true){
            if (tickeNums<=0){
                break;
            }
            //模拟延时
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"买到了倒数第" + tickeNums-- + "张票");
        }
    }



    //main线程,主线程
    public static void main(String[] args) {
        TestThread3 ticke = new TestThread3();

        new Thread(ticke,"小明").start();
        new Thread(ticke,"小红").start();
        new Thread(ticke,"小刚").start();


    }


}

• 多个线程操作同一资源的情况下出现问题，出现了线程不安全的情况

Callable（了解）

• 实现Callable接口，需要返回值类型
• 重写call方法，需要抛出异常
• 创建目标对象
• 创建执行服务：ExecutorService ser = Executor.newFixedThreadPool(1);
• 提交执行：Future resurt1 = ser.submit(t1);
• 获取结果：Boolean r1 =resurt1.get()
• 关闭服务：ser.shutdownNow();

线程状态

• 创建状态：线程创建之后就进入了创建状态
• 就绪状态：线程调用start方法后，接收调度运行前就是就绪状态
• 运行状态：线程接收调度开始运行
• 阻塞状态：调用了方法或其他让线程进入了休眠状态
• 死亡状态：线程运行结束
• 线程方法
  • setPriority(int newPriority)更改线程优先级
  • sleep(long millis)让线程休眠指定时间
  • join()其他线程等待该线程结束
  • yield()暂停正在执行的线程
  • interrupt()中断线程
  • isAlive()测试线程是否处于活动状态

停止线程

• 不推荐使用JDK提供的方法停止线程

• 推荐让线程自己停下来

• 建议使用一个标志位终止线程运行

  boolean flag  = true;
  public void run() {
    while (flag){
         //线程方法
    }
  }
  public void stop(){
          flag = false;
  }

线程休眠

• sleep（时间）指定当前线程阻塞的毫秒数
• sleep存在异常，需要处理
• sleep时间结束后线程进入就绪状态，等待调度
• sleep可以模拟网络延迟，倒计时
• 每一个对象都有一个锁，sleep不会释放锁

线程礼让

• yield线程礼让方法
• 让正在执行的线程暂停退出运行状态回到就绪状态
• CPU重新调度，礼让不一定成功，看CPU心情

join

• 让其他线程停止，等待本线程结束后才能继续执行
• 就是插队，别人要等我结束，才能继续

线程状态观测

• Thread.State方法，返回一个线程的状态
  • NEW：尚未启动的线程
  • RUNNABLE：正在执行的线程状态
  • WAITING：等待另一线程线程执行的状态
  • TIMED_WAITING：等待另一线程线程执行，到达指定等待时间的线程状态
  • TERMINATED：已退出的线程状态

线程优先级

• java提供了一个线程调度器来监控使用进入就绪状态的线程，并提供线程优先级来决定哪个线程先执行
• 线程优先级要数字表示1~10，java还定义了一些常量
  • Thread.MIN_PRINRITY = 1
  • Thread.NORM_PRINRITY = 5
  • Thread.MAX_PRINRITY = 10
• 使用getPrinrity()方法查看优先级
• 使用setPrinrity()方法更改优先级，如果小于1或超过10，会报错
• 优先级设置建议在start之前
• 优先级高的大概率先执行，但不一定

守护（daemon）线程

• 线程分为用户线程与守护线程
• 虚拟机必须确保用户线程执行完毕
• 虚拟机不用等待守护线程执行完毕
• 主要用户线程执行完毕虚拟机就会停止程序
• 守护线程的作用：后台记录操作日志，监控内存，垃圾回收等等
• 使用setDaemon()方法把线程设置为守护线程

线程同步

• 并发：同一个对象被多个线程同时操作
• 现实中也经常遇到这种问题，比如食堂打饭，解决问题的方法就是排队
• 处理多线程问题时，多个线程访问一个对象，并想要修改这个对象时我们就需要线程同步，线程同步就是一种等待机制，多个想要访问这个对象的线程进入线程等待池形成队列，等待前面的线程使用完毕，下一个再使用

队列和锁

• 由于同一进程的多个线程共享一块存储空间，在带来方便的同时也带来了访问冲突问题，为了保证数据在方法中被访问时的正确性，在访问时加入了锁机制（synchronized），当一个线程获得对象的排他锁，独占资源，其他线程必须等待其使用后释放锁，下一个获得锁的线程才能操作
• 锁机制存在以下问题
  • 一个线程持有锁必然导致其他需要锁的线程挂起，在线程多的情况下，加锁，释放锁会导致比较多的上下文切换和调度延时，引起性能问题
  • 如果一个优先级高的线程等待一个优先级低的线程，会导致优先级倒置，引起性能问题（性能倒置）

线程不安全的例子

• 买票

package com.taidou;


//多个线程操作同一对象
//买票
public class TestThread3 implements Runnable{
    //票数
    private int tickeNums =10;

    @Override
    public void run() {
        buy();
    }


    //买票的方法
    private void buy() {
        while (true){
            if (tickeNums<=0){
                break;
            }
            //模拟延时
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"买到了倒数第" + tickeNums-- + "张票");
        }
    }



    //main线程,主线程
    public static void main(String[] args) {
        TestThread3 ticke = new TestThread3();

        new Thread(ticke,"小明").start();
        new Thread(ticke,"小红").start();
        new Thread(ticke,"小刚").start();


    }


}

同步方法

• 更改加入锁机制，在买票的方法上加入synchronized关键字

• 只有加入关键字，就能解决线程不安全的问题

package com.taidou;


//多个线程操作同一对象
//买票
public class TestThread4 implements Runnable{
    //票数
    private int tickeNums =10;

    @Override
    public void run() {
        buy();
    }


    //买票的方法
    private synchronized void buy() {
        while (true){
            if (tickeNums<=0){
                break;
            }
            //模拟延时
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"买到了倒数第" + tickeNums-- + "张票");
        }
    }



    //main线程,主线程
    public static void main(String[] args) {
        TestThread4 ticke = new TestThread4();

        new Thread(ticke,"小明").start();
        new Thread(ticke,"小红").start();
        new Thread(ticke,"小刚").start();


    }


}

同步块

• 同步块：synchronized (Obj){}
• Obj被称为同步监视器
  • Obj可以是任何对象，但是推荐使用共享资源作为同步监视器
  • 同步方法无需指定同步监视器,因为同步方法的同步监视器就是this，就是这个对象本身
• 同步监视器的执行过程
  • 第一个线程访问，锁定同步监视器，执行代码
  • 第二个线程访问，发现同步监视器被锁定，无法访问
  • 第一个线程访问完毕，解锁同步监视器
  • 第二个线程访问，发现同步监视器没有锁，然后锁定并访问

死锁

• 多个线程各自占用一些资源，并且互相等待其他线程占用的资源才能运行，而导致两个或者多个线程在等待对方释放资源，都停止执行的情况。某一个同步块同时拥有两个以上对象的锁时，就可能会发生死锁问题
• 产生死锁的四个必要条件
  • 互斥条件：一个资源名称只能被一个进程使用
  • 请求与保持条件：一个线程因为请求资源而阻塞时，对已持有的资源保持不放
  • 不剥夺条件：线程已获得的资源，在未使用完之前，不能强行剥夺
  • 循环等待条件：若干线程之间形成一种头尾相接的循环等待资源关系
• 以上四个条件只有想办法破除其中一条或多条就可以避免死锁的问题

Lock（锁）

• JDK5开始，java提供了更强大的线程同步机制，通过显式定义同步锁对象来实现同步，同步锁对象使用Lock
• java.util.concurrent.locks.Lock接口是多个线程对共享资源进行操作的工具。
• ReentrantLock类实现了Lock，他拥有与synchronized相同的并发性和内存语义，在线程安全的控制中，比较常用的是ReentrantLock，可以显式的加锁、释放锁

synchronized与Lock

• Lock是显式锁，需要手动开关，synchronized是隐式锁，出了作用域自动释放
• Lock只有代码块锁，synchronized有代码块锁和方法锁
• 使用Lock锁，JVM将花费较少的时间来调度线程，性能更好，并且具有更好的扩展性（更多的子类）
• 优先使用顺序：Lock>同步代码块>同步方法

线程协作

生产者消费者模式

• 应用场景
  • 假设仓库只能放一件产品，生产者生产放入，消费者取走
  • 仓库没有产品，生产者生产放入，然后等待，直到消费者取走
  • 仓库有产品，消费者取走消费，否则就等待，直到有产品就再取走消费
• 这是一个线程同步的问题，生产者与消费者共享一个资源，并且生产者和消费者之间互相依赖，互为条件
  • 对于生产者，没有产品，要通知消费者等待，生产了产品，要通知消费者消费
  • 对于消费者，消费后要通知想、生产者生产
  • 在此模式中，仅有synchronized是不够的
    • synchronized可以阻止并发更新一个共享资源，实现同步
    • synchronized不能用来实现不同线程之间的消息传递

线程通信

• java提供了几个方法解决线程之间的通信问题
  • wait()：表示线程一直等到直到其他线程通知，会释放锁
  • wait(long timeout)：指定等待的毫秒数
  • notify()：唤醒一个处于等待的线程
  • notifyAll()：唤醒同一对象上所有调用wait方法的线程，优先级高的先调度
• 这些方法都是object类方法，都只能在同步方法和同步代码块中使用，否则会抛出异常

解决方法

• 管程法
  • 生产者将生产好的数据放入缓冲器，消费者从缓冲器拿出数据
  • 在缓冲区满时生产者停止生产，通知消费者消费，等待消费者消费
  • 消费者消费之后，通知生产者生产
• 信号灯法
  • 设置一个标志位flag
  • 设置turn时生产者生产，消费者等待
  • 反之消费者消费，生产者等待

线程池

• 背景：经常创建和销毁、使用量特别大的资源，比如并发情况下的线程，对性能影响很大
• 思路：提前创建好线程，用时取，不用时放回，可以避免频繁销毁，实现复用
• 好处
  • 提高响应速度
  • 降低资源消耗
  • 便于线程管理
• JDK5提供了线程池相关的api：ExecutorService和Executors
• ExecutorService：真正的线程池接口。常见子类ThreatPoolExecutor
• execute(Runnable r)方法：执行任务，没有返回值，用于执行Runnable
• submit(Callable c)方法：执行任务，有返回值，用于执行Callable
• shutdown()方法：关闭线程池
• Executors：工具类、线程池的工厂类，用于创建并返回不同类型的线程池

原文：https://www.cnblogs.com/taidou-hth/p/12358187.html