多线程的知识补充

只羡鸳鸯不羡仙仙

已于 2022-07-14 15:11:43 修改

阅读量226

点赞数

分类专栏：多线程单例模式阻塞队列文章标签： java

于 2022-07-04 15:47:06 首次发布

本文链接：https://blog.csdn.net/m0_68989458/article/details/125468219

版权

多线程同时被 3 个专栏收录

5 篇文章 0 订阅

订阅专栏

单例模式

1 篇文章 0 订阅

订阅专栏

阻塞队列

1 篇文章 0 订阅

订阅专栏

4、ThreadPoolExecutor子类的核心构造方法参数

5、定时器线程池

6、线程池的关闭

六、相关代码

一·、线程的等待与唤醒机制

线程得物等待与唤醒，wait与notify方法(都是Object类提供的方法)，用于线程的等待和唤醒操作，必须搭配synchronized锁来使用，在多线程并发的场景下，有时候需要某些线程先执行，这些线程执行结束后其他线程接着继续执行。

1、等待方法

痴汉方法，死等，线程进入阻塞态(WAITING),直到有其他线程调用notiofy方法唤醒

等待一段时间，若该时间内线程被唤醒，则继续执行，若超过对应的时间还没有被其他线程唤醒此线程，此线程就不在等待，恢复执行

2、唤醒方法

随机唤醒一个正在等待状态的线程

唤醒所有处在等待状态的线程

3、代码演示

package Thread.wait_notiofy;

/**
 * 线程的等待方法
 */
public class WaitDemo1 {
    private static class WaitTesk implements Runnable{
        private Object lock;
        public WaitTesk(Object lock){
            this.lock=lock;
        }
        @Override
        public void run() {
            synchronized (lock){
                System.out.println(Thread.currentThread().getName()+"准备进入等待状态~~");
                //此线程在等到lock对象的notify方法唤醒
                try {
                    lock.wait();
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                System.out.println(Thread.currentThread().getName()+"等待结束，线程机组执行~~");
            }
        }
    }
    private static class NotifyTask implements Runnable{
        private Object lock;
        public NotifyTask(Object lock){
            this.lock=lock;
        }
        @Override
        public void run() {
           synchronized (lock){
               System.out.println(Thread.currentThread().getName()+"准备唤醒~~");
               //随机唤醒一个处在lock对象上等待的线程
               lock.notify();
               System.out.println(Thread.currentThread().getName()+"唤醒成功~~");
           }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        Object lock=new Object();
        //创建3个等待线程
        Thread t1=new Thread(new WaitTesk(lock),"t1");
        Thread t2=new Thread(new WaitTesk(lock),"t2");
        Thread t3=new Thread(new WaitTesk(lock),"t3");
        //创建一个唤醒线程
        Thread notify=new Thread(new NotifyTask(lock),"notify线程");
        t1.start();
        t2.start();
        t3.start();
        Thread.sleep(1000);
        notify.start();
    }
}

（1）调用wait和notify方法必须要在代码同步块中使用，不然就会直接报错

（2）调用wait方法的情况

3、调用notify方法的情况

4、阻塞和等待队列

对于wait和notify方法来说，其实有一个阻塞队列和等待队列

阻塞队列表示同一时间只有一个线程能获取到锁，其他线程进入阻塞队列

等待队列表示调用wait(首先此线程要获取到锁，进入等待队列，释放锁)

调用wait方法的前提是获得锁(synchronized锁)，调用wait方法会释放锁，本线程进入等待队列等待被唤醒，当多个线程被唤醒之后不是立即恢复执行，而是再次进入阻塞队列去竞争锁

5、wait和sleep方法的区别

比如说：

①wait方法是Object类提供的方法，需要搭配synchronized锁来使用，调用wait方法会释放锁，线程进入WAITING状态，等待被其他线程唤醒或者自动超时唤醒，当多个线程被唤醒后需要再次进入阻塞队列再次竞争synchronized锁才能执行

② sleep方法是Thread方法提供的方法，调用sleep方法的线程就会进入TIMED_WAITING状态，不释放锁，时间到了就会自动醒来

二、单例模式

1、单例模式的使用

所谓的单例模式就是保证每个类在程序中有且只有一个对象，那么如何控制某个类只有一个对象呢？

①如何控制某个类的对象，要创建类的对象，可以通过构造方法来产生对象，当构造方法是public权限时，对于类的外部而言，就可以随意的创建对象，就无法控制对象的个数，此时就应该将构造方法私有化，这样类的外部就彻底没法产生对象了

②当构造方法私有化之后，对于类的外部而言就一个对象也没有了，所以要想创建唯一的一个对象，就需要在当前类中只调用一次构造方法

2、饿汉式单例模式

这个类一加载(加载到JVM中)，这个唯一的对象就产生了

 public class singletest {
    //唯一的一个对象，必须是静态对象
    private static singletest single=new singletest();
    private singletest(){}

    public static singletest getSingletest() {
        return single;
    }
}

class singletest1Main{
    public static void main(String[] args) {
        singletest s1= singletest.getSingletest();
        singletest s2= singletest.getSingletest();
        singletest s3= singletest.getSingletest();
        System.out.println(s1==s2);
        System.out.println(s1==s3);
    }
}

3、懒汉单例模式

系统初始化时，外部不需要这个对象，就先不产生，只有当外部需要时才产生实例化对象，可以加快初始化时间

public class Singletest2 {
    private static Singletest2 singletest2;
    private Singletest2(){};

    public static Singletest2 getSingle() {
        if (singletest2==null){
            singletest2=new Singletest2();
        }
        return singletest2;
    }
}

class Singletest2Main{
    public static void main(String[] args) {
      Singletest2 s1=Singletest2.getSingle();
      Singletest2 s2=Singletest2.getSingle();
      Singletest2 s3=Singletest2.getSingle();
        System.out.println(s1==s2);
        System.out.println(s1==s3);
    }
}

3、懒加载的简单介绍

（1）懒加载的概念

懒加载(Load On Demand)是一种独特而又强大的数据获取方法,它能够在用户滚动页面的时候自动获取更多的数据,而新得到的数据不会影响原有数据的显示,同时最大程度上减少服务器端的资源耗用。

（2）懒加载的应用案列

考虑这样一个例子：海尔电器是一个非常大的组织机构，它下有1万多个组织单元。由于组织单元的复杂性，组织单元间也存在着上下级关系。现在的问题是：用户想加入海尔电器的某个组织单元，他该怎么选择到这个组织单元呢？
很容易想到的一个解决方法是：查询数据库，把海尔电器的所有组织单元放到一个下拉列表中，让用户选择即可。这样的确是解决问题了，但是，测试发现，浏览器在显示组织单元数据时就直接假死了。看来，这样做性能太差，可以不采纳。

另一个解决方法就是利用懒加载技术。由于组织单元间存在着上下级关系，那么组织单元的排列就可以当作一棵树来处理。在显示数据时只显示父节点，点击父节点时，就能显示父节点下的子节点。用户要选择某个组织单元，只需点击该组织单元的父亲节点就能找到该组织单元。

可以看出，懒加载提高了系统响应时间，提升了系统性能，非常具有利用价值。

（3）懒加载和急加载的理解

FetchType.LAZY：懒加载，加载一个实体时，定义懒加载的属性不会马上从数据库中加载。

FetchType.EAGER：急加载，加载一个实体时，定义急加载的属性会立即从数据库中加载。

比方User类有两个属性，name跟address，就像百度知道，登录后用户名是需要显示出来的，此属性用到的几率极大，要马上到数据库查，用急加载；而用户地址大多数情况下不需要显示出来，只有在查看用户资料是才需要显示，需要用了才查数据库，用懒加载就好了。所以，并不是一登录就把用户的所有资料都加载到对象中，于是有了这两种加载模式。

（4）单列模式的懒加载

在系统初始化时，外部不需要这个单列对象，就先不产生该对象，只有当外部需要时才会实例化对象，这里就体现了懒加载的思想。

对于饿汉单列模式来说，它天生就是线程安全的，因为在系统初始化JVM加载类时就创建了这个唯一的对象，所以在多线程场景下是安全的。而对于懒汉式单例来说，是在第一次调用getSingle方法时才会实例化对象，但如果此时多个线程并发执行，同时调用getSingle方法就会产生问题。

解决懒汉单例模式的线程安全问题

①直接在静态方法上加锁，此时锁的力度太大，不推荐这种方法

②

此时如果只在同步代码块添加锁，分析一下

当t1进入同步代码块之后，t2和t3就会卡在获取锁的位置，t1产生对象并且释放锁之后，t2和t3还是从获取锁的位置继续执行，此时t2和t3就会再次new对象，就怒视只有唯一的一个对象

所以，需要在同步代码块中添加一个判断条件，当第一个线程进去时，此时还没有产生对象，就会在此时产生唯一的对象，当其他线程进入之后，由于已经产生了唯一的对象，就不会再产生对象了。在同步代码块中合格添加判断条件就是为了防止其他线程恢复执行后多次创建单例对象。

③双重加锁，使用volatile关键字保证单例对象不会被中断

三、阻塞队列

1、阻塞队列的介绍

阻塞队列是一种特殊的队列，遵守“先进先出”的原则

阻塞队列是一种线程安全的数据结构，并且具有一下特性：

● 当队列满的时候，继续入队列就会阻塞，直到其他线程从队列中取走元素

● 当队列空的时候，继续出队列也会阻塞，直到其他线程往队列中插入元素

阻塞队列得一个典型应用场景就是“生产者消费模型”，这是一种非常典型的开发模型

2、java标准库中的阻塞队列

在 Java 标准库中内置了阻塞队列. 如果我们需要在一些程序中使用阻塞队列, 直接使用标准库中的即可.

● BlockingQueue 是一个接口. 真正实现的类是ArrayBlockingQueue

和 LinkedBlockingQueue.

● put 方法用于阻塞式的入队列, take 用于阻塞式的出队列.

● BlockingQueue 也有 offer, poll, peek 等方法, 但是这些方法不带有阻塞特性.

import java.util.Random;
import java.util.concurrent.BlockingDeque;
import java.util.concurrent.LinkedBlockingDeque;

/**
 * 使用阻塞队列实现一个简单的生产消费模型
 */
public class test {
    public static void main(String[] args) throws InterruptedException {
        BlockingDeque<Integer> blockingDeque=new LinkedBlockingDeque<>();
        Thread customer=new Thread(()->{
            while (true){
                try{
                    int val=blockingDeque.take();
                    System.out.println("消费元素："+val);
                    Thread.sleep(1000);
                }catch (InterruptedException e){
                    throw new RuntimeException(e);
                }
            }
        },"消费者");
        Random random=new Random();
        Thread producer=new Thread(()->{
            while (true){
                try {
                    int val= random.nextInt(100);
                    blockingDeque.put(val);
                    System.out.println("生产者元素："+val);
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        },"生产者");
        customer.start();
        producer.start();
    }
}

3、阻塞队列的简单实现

●通过 "循环队列" 的方式来实现.

●使用 synchronized 进行加锁控制.

●put 插入元素的时候, 判定如果队列满了, 就进行 wait. (注意, 要在循环中进行 wait. 被唤醒时不一定队列就不满了, 因为同时可能是唤醒了多个线程).

●take 取出元素的时候, 判定如果队列为空, 就进行 wait. (也是循环 wait)

/**
 * 简单实现一个阻塞队列
 */
public class BlockingQueue {
    private int[] items = new int[1000];
    private volatile int size = 0;
    private int head = 0;
    private int tail = 0;
    public void put(int value) throws InterruptedException {
        synchronized (this) {
            // 此处最好使用 while.
            // 否则 notifyAll 的时候, 该线程从 wait 中被唤醒,
            // 但是紧接着并未抢占到锁. 当锁被抢占的时候, 可能又已经队列满了
            // 就只能继续等待
            while (size == items.length) {
                wait();
            }
            items[tail] = value;
            tail = (tail + 1) % items.length;
            size++;
            notifyAll();
        }
    }
    public int take() throws InterruptedException {
        int ret = 0;
        synchronized (this) {
            while (size == 0) {
                wait();
            }
            ret = items[head];
            head = (head + 1) % items.length;
            size--;
            notifyAll();
        }
        return ret;
    }
    public synchronized int size() {
        return size;
    }

四、定时器

1、定时器的简单介绍

定时器也是软件开发中的一个重要组件. 类似于一个 "闹钟". 达到一个设定的时间之后, 就执行某个指定好的代码.

2、java中的定时器

●标准库中提供了一个 Timer 类. Timer 类的核心方法为 schedule .

●schedule 包含两个参数. 第一个参数指定即将要执行的任务代码, 第二个参数指定多长时间之后执行 (单位为毫秒).

/**
 * java中定时器的简单认识
 */
public class TimerTest {
    public static void main(String[] args) {
        Timer timer=new Timer();
        //表示3秒之后执行此任务
        timer.schedule(new TimerTask() {
            @Override
            public void run() {
                System.out.println("hello~~~");
            }
        },3000);
    }
}

第三个参数是在延迟3秒启动任务之后，每隔一秒就会再次执行该任务

3、定时器的简单实现

定时器的构成: 一个带优先级的阻塞队列为啥要带优先级呢? 因为阻塞队列中的任务都有各自的执行时刻 (delay).

最先执行的任务一定是 delay 最小的. 使用带优先级的队列就可以高效的把这个 delay 最小的任务找出来.

队列中的每个元素是一个 Task 对象.

Task 中带有一个时间属性, 队首元素就是即将同时有一个 worker 线程一直扫描队首元素, 看队首元素是否需要执行

五、线程池

1、线程池的简单介绍

虽然线程的创建和销毁的开销是比较小的(和进程相比)，但是当系统中的线程数量比较多的时候，这个开销就不可忽视了。线程池最大的好处就是减少每次启动、销毁线程的损耗。

2、java中的线程池

●使用 Executors.newFixedThreadPool(10) 能创建出固定包含 10 个线程的线程池.

●返回值类型为 ExecutorService

●通过 ExecutorService.submit 可以注册一个任务到线程池中.

ExecutorService pool = Executors.newFixedThreadPool(10);
pool.submit(new Runnable() {
    @Override
    public void run() {
        System.out.println("hello");
   }
});

Executors 本质上是 ThreadPoolExecutor 类的封装.

ThreadPoolExecutor 提供了更多的可选参数，是描述线程最常用的一个子类, 可以进一步细化线程池行为的设定。

3、线程的常用方法

线程池的父接口是ExecutorService接口，ThreadPoolExecutor是描述线程最常用的一个子类

Executors 创建线程池的几种方式：

●newFixedThreadPool: 创建固定线程数的线程池

●newCachedThreadPool: 创建线程数目动态增长的线程 .

●newSingleThreadExecutor: 创建只包含单个线程的线程池.

●newScheduledThreadPool: 设定延迟时间后执行命令，或者定期执行命令. 是进阶版的 Timer.

   public static void main(String[] args) {
        //固定大小的线程池
        ExecutorService pool1= Executors.newFixedThreadPool(10);
        //数量动态变化的线程池
        ExecutorService pool2=Executors.newCachedThreadPool();
        //只包含一个线程的单线程池
        ExecutorService pool3=Executors.newSingleThreadExecutor();
        //定期线程池，可以设置任务的延时启动时间
        ExecutorService pool4=Executors.newScheduledThreadPool(10);
    }

public class test {
    public static void main(String[] args) {
        ExecutorService pool1 = Executors.newFixedThreadPool(10);
        pool1.submit(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 5; i++) {
                    System.out.println(Thread.currentThread().getName() + "hello~" + i);
                }
            }
        });
        ExecutorService pool2 = Executors.newCachedThreadPool();
        pool2.submit(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 5; i++) {
                    System.out.println(Thread.currentThread().getName() + "hello~" + i);
                }
            }
        });
        ExecutorService pool3 = Executors.newSingleThreadExecutor();
        pool3.submit(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 5; i++) {
                    System.out.println(Thread.currentThread().getName() + "hello~" + i);
                }
            }
        });
        ScheduledExecutorService pool4=Executors.newScheduledThreadPool(10);
        pool4.schedule(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"3秒后执行次任务~~~");
            }
        },3, TimeUnit.SECONDS);
    }
}

4、ThreadPoolExecutor子类的核心构造方法参数

5、定时器线程池

延迟一段时间后开始执行command任务

以unit为单位延迟delay时间之后开始执行任务，每隔period时间就执行一次任务

6、线程池的关闭

shutdown():关闭线程池中的所有线程，若线程还在执行任务，就等任务执行完毕在关闭

shutdownNow():关闭当前线程池中的所有线程，若线程还在执行，直接中断任务

public class Shutdown {
    public static void main(String[] args) throws InterruptedException {
        ExecutorService pool1=new ThreadPoolExecutor(3,6,10,
                TimeUnit.SECONDS,new LinkedBlockingQueue<>(3),new ThreadPoolExecutor.AbortPolicy());
        for (int i = 0; i <6 ; i++) {
            pool1.submit(()->{
                while (true){
                    System.out.println(Thread.currentThread().getName()+"正在运行~~");
                    Thread.sleep(1000);
                }
            });
        }
        //主线程休眠6秒后关闭线程池
        Thread.sleep(6000);
//        pool1.shutdown();
        pool1.shutdownNow();
        if (pool1.isShutdown()){
            System.out.println("线程池已经关闭~");
        }
    }
}