Java多线程(单例模式,堵塞队列,定时器)详解_Java教程

一、单例模式

单例模式是一种设计模式，针对一些特定的场景，研究出对应的解决方案，。有些对象在代码中只应该有一个实例，单例模式就是强制某个类只能有一个实例。

单例模式的实现，主要依托于static关键字（被static 修饰的成员，静态成员，把当前的成员变成类属性而不是实例属性~）每个类对象只有一份

单例模式实现有两种，饿汉模式和懒汉模式

饿汉模式

饿汉模式实现：实例创建出现在“类加载”阶段（第一次使用到这个类的时候，就会把这个类.class加载到内存里），线程安全

public class TestSinger {
    //实现单例模式
    static class Singleton{
        //创建一个成员，保存唯一的一个Singleton实例
        private static Singleton instance=new Singleton();
        //提供方法获取实例
        public static Singleton getInstance(){
            return instance;
        }
        private Singleton(){
        }
    }
    public static void main(String[] args) {
        //获取到一个实例 ，只能通过 getInstance 无法通过new 的方式来创建新的Singleton
        Singleton s=Singleton.getInstance();
    }
}

懒汉模式

第一次调用getInstance 方法创建实例（线程不安全）

public class TestSingleton {
    //懒汉模式
    //创建实例的时机是第一次调用时创建，比饿汉模式更迟
    static class Singleton{
        private static Singleton instance=null;
        public static Singleton getInstance(){
            if(instance==null){
                instance=new Singleton();
            }
            return instance;
        }
        private Singleton(){
        }
    }
    public static void main(String[] args) {
        Singleton s=new Singleton();
    }
}

一般来说懒汉模式更好（但不绝对），懒汉模式更高效，但是饿汉模式是线程安全的，懒汉模式是存在线程不安全的状况，因为懒汉模式有创建线程实例操作，此操作不是原子性，

  public static Singleton getInstance(){
            if(instance==null){
                instance=new Singleton();
            }
            return instance;
        }

懒汉模式这里操作先进行读操作（LOAD）,之后进行比较CMP 之后NEW SAVE（写入内存），如果这里有两个线程执行，会发生抢占式,因为这里操作不是原子性的，所有会发生创建多个实例的情况，出现了BUG，

Java多线程(单例模式,堵塞队列,定时器)详解

这里我们通过加锁操作来使得操作变为原子性，使得懒汉模式变为线程安全的，可以把锁加到方法上，这时候是针对CMP,NEW 和 SAVE 操作都进行了加锁，三个操作都是串行的，但是这种效率太低了，我们应该把锁作用范围更小一点，针对CMP（判断）和NEW 操作进行加锁，SAVE 只是读操作，并没有修改，不需要加锁，提高效率。

public static Singleton getInstance(){
       synchronized (Singleton.class){
           if(instance==null){
                instance=new Singleton();
             }
        }
     return instance;
	}

但是这样的代码，符出的代价太大了，因为每次调用都会进行加锁，我们只是需要instance未初始化之前，才涉及到线程安全问题，后续已经初始化了，就每次要每次都执行加锁，而是只是进行判断就好了，所以又修改了代码，改为双if判断

public static Singleton getInstance(){
           if(instance==null){
               synchronized (Singleton.class){
                   if(instance==null){
                       instance=new Singleton();
                   }
               }
           }
            return instance;
        }

但是这样写还是会有瑕疵，因为在多线程的情况下，可能多个线程进行读操作，由于编译器优化，可能在寄存器读取，而这时候执行操作还没有执行完，还是null的状态，所以我们也要在获取实例时候加上锁

懒汉模式

保证线程安全：

1.加锁，把if判断和new操作加锁

2.双重if循环

3.volatile 关键字

    //懒汉模式
    static class Singleton{
        volatile  private static Singleton instance=null;
        public static Singleton getInstance(){
           if(instance==null){
               synchronized (Singleton.class){
                   if(instance==null){
                       instance=new Singleton();
                   }
               }
           }
            return instance;
        }
        private Singleton(){
        }
    }
    public static void main(String[] args) {
        Singleton s=new Singleton();
    }

针对单例模式的线程安全要点：

1）加锁（在合适的位置加锁，CMP（判断）和NEW（创建）时加锁，同时加锁的范围也不能太大，避免降低效率）

2）双重判断（保证需要加锁时候才加锁，一旦初始化完毕了，就不用创建实例，都为读操作，就没必要加锁了）

3）volatile 保证外层 if 读操作，读到的数值都是最新的，不会出现一个正在创建实例，而读取时是NULL 进入IF判断的情况

二、堵塞队列

堵塞队列是什么？一种线程安全的队列，

1.首先堵塞队列是线程安全的（内部实现了加锁控制），
2.当队列满的时候，此时就会堵塞，一直到堵塞队列不满的情况下才会完成插入，当队列为空时，从队列中取元素时，也会发生堵塞。

堵塞队列的作用：

帮助我们完成“生产者消费者模型”，作用于服务器开发

生产者和消费者模型通过某种交易场所（某数据结构）来进行交互，堵塞队列就是其中的一种数据结构，能够很好的协调生产者和消费者之间的关系，

实际案例（服务器请求）：

一个服务器，同一时刻可能收到很多请求，但是服务器处理能力是有限的，如果同一时间服务器收到的请求太多了，服务器可能就挂了…，针对这样的场景，使用生产者和消费者模式来进行“削峰”，削弱请求峰值对服务器的冲击力，如果服务器面对请求太多了，实际上先把请求放入堵塞队列中，应用程序按照固定的结构从堵塞队列中取出，这些请求冲击的是堵塞队列本身，请求在这里耗着，不会消耗太多的CPU资源，缓解服务器压力

消息队列，是堵塞队列的上级

1.消息队列中数据是有类型的（topic），按照topic进行分类，把相同topic的数据放到不同的队伍中，分别进行排队，一个消息队列，可以支撑多个业务的多组数据~~

2.消息队列往往是单独的服务器/服务器集群，通过网络通信的方式，进行生产者和消费者模型

3.还支持持久化存储（数据存储在磁盘上）

4.消费的时候支持多种消费模式

a)指定位置消费（不一定只是取出队首元素）

b)镜像模式消费（一个数据可以被取多次，不是取一次直接删除）

实现堵塞队列：

public static void main(String[] args) {
        //BlockingDeque 本身是一个interface 不能去new
        BlockingDeque<String> blockingDeque=new LinkedBlockingDeque<>();
        try {
            //put 和 take 都有堵塞功能
            //堵塞队列也有普通方法但是没有堵塞功能。
            blockingDeque.put("hello");
            String elem=blockingDeque.take();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

实现一个生产者和消费者模型

import java.util.concurrent.BlockingDeque;
import java.util.concurrent.LinkedBlockingDeque;
public class Demo2 {
    //实现生产者和消费者模型
    public static void main(String[] args) {
        BlockingDeque<String> queue=new LinkedBlockingDeque();
        //创建生产者线程
        Thread producer=new Thread(){
            @Override
            public void run() {
                for(int i=0;i<10000;i++){
                    try {
                        System.out.println("producer 生成 str"+i);
                        queue.put("str "+i);
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        };
        producer.start();
        //消费者线程
        Thread customer=new Thread(){
            @Override
            public void run() {
                while(true){
                    try {
                        String elem=queue.take();
                        System.out.println("customer 获取到" + elem);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        };
        customer.start();
        try {
            producer.join();
            customer.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

这里实现的是生产者每一秒生成一个，生产者比消费者慢

Java多线程(单例模式,堵塞队列,定时器)详解

可以借助堵塞队列的最大长度来设置一个生产者比消费者快的情况，将最大长度设为10，使用sleep 一秒消费一个，但是一直在生产，这样就是生产者大于消费者，主要使用put（）和take（）方法来操作堵塞队列

实现BlockingQueue

1）首先要实现一个队列，可以用链表或者数组实现队列，这里使用数组实现一个队列（环形队列），定义两个变量head,tail来标记数组头部和尾部，插入元素时，插在tail位置，tail++,出队列时取出head位置元素，head++，定义一个变量来标记长度，如果长度等于数组长度，则要回到数组的头部，来实现环形数组

public class ThreadDemo1 {
    //自己实现堵塞队列，先通过数组实现普通队列
    static class BlockingQueue{
        private int[] array=new int[1000];
        private int head=0;//记录头部
        private int tail=0;//记录尾部
        private int size=0;
        //实现入队列
        public void put(int value){
            if(size==array.length){
                System.out.println("队列满了，不能插入");
                return ;
            }
            array[tail]=value;
            tail++;
            //解决环形数组
            if(tail>=array.length){
                tail=0;
            }
            size++;
        }
        //实现出队列
        public Integer take(){
            if(size==0){
                return null;
            }
            int ret=array[head];
            head++;
            if(head>=array.length){
                head=0;
            }
            size--;
            return ret;
        }
    }
}

2.为了保证线程安全给队列进行加锁操作，并且实现堵塞队列

注意实现堵塞队列，此时队列是满的，多个线程实现都是要等待，当一个线程取走一个元素，就会通知其他线程队列不满，多个线程就要竞争锁，所以获取到锁操作后，还是要判断队列是否满，可能这个线程没有竞争到锁，所以要用while()来进行等待

static class BlockingQueue{
        private int[] array=new int[1000];
        private int head=0;//记录头部
        private int tail=0;//记录尾部
        //记录队列中元素长度
        private int size=0;
        //引入一个锁对象
        private Object locker=new Object();
        //实现入队列
        public void put(int value) throws InterruptedException {
            synchronized (locker){
                while(size==array.length){
                    locker.wait();
                }
                array[tail]=value;
                tail++;
                //解决环形数组
                if(tail>=array.length){
                    tail=0;
                }
                size++;
                locker.notifyAll();
            }
        }
        //实现出队列
        public Integer take() throws InterruptedException {
            int ret=0;
            synchronized (locker){
                while (size==0){
                    locker.wait();
                }
                ret=array[head];
                head++;
                if(head>=array.length){
                    head=0;
                }
                size--;
                locker.notifyAll();//唤醒操作，提醒等待元素，队列有位置了
            }
            return ret;
        }
    }

创建一个生产者消费者模型来检验自己实现的堵塞队列是否成功

public static void main(String[] args) throws InterruptedException {
        BlockingQueue queue=new BlockingQueue();
        Thread producer=new Thread(){
            @Override
            public void run() {
                for(int i=0;i<10000;i++){
                    try {
                        System.out.println("生产了元素："+ i);
                        queue.put(i);
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        };
        producer.start();
        Thread customer=new Thread(){
            @Override
            public void run() {
                try {
                    while(true){
                        int ret=queue.take();
                        System.out.println("消费了元素 "+ ret);
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        };
        customer.start();
        producer.join();
        customer.join();
    }

Java多线程(单例模式,堵塞队列,定时器)详解

实现了一个简单的堵塞队列

三、定时器

定时器就是闹钟，给定时器设定一个任务，约定某个任务XXX时间后执行

目的：让某个任务在某个时间点执行，不是立刻执行

使用Timer 提供的核心接口 schedule 指定一个任务交给定时器，再一定的时间之后执行这个任务

实现定时器
1）Timer 类中要包含一个Task类，每个Task类就表示一个具体的任务，Task里面包含一个时间戳（啥时候执行这个任务），还包含了一个Runnable 实例（用来表示具体任务是啥）
2）Timer里面通过一个带优先级的堵塞队列，来组织若干个task，根据时间先后来排优先级，快带时间的任务优先级更高
3）Timer 中还需要一个专门的线程，让这个线程不停扫描队首元素，看看队首元素是不是可以执行了，如果可以执行了，就执行这个任务，如果不能执行，就继续在队列中等待。

实现定时器:

import java.util.concurrent.PriorityBlockingQueue;
public class ThreadDemo2 {
    //实现一个简单的定时器  task要放到一个优先队列中，但是优先队列中需要进行比较排序
    static class Task implements Comparable<Task>{
        //啥时候去执行
        private long time;
        //执行什么
        private Runnable command;
        //一般去设定定时器的时候，传入的时间，一般都是时间间隔
        public Task(Runnable command,long time){
            this.command=command;
            //记录绝对时间
            this.time=System.currentTimeMillis()+time;
        }
        public void run(){
            command.run();
        }
        @Override
        public int compareTo(Task o) {
        //时间较小的排在前面
            return (int)(this.time-o.time);
        }
    }
    static class Timer{
        //创建一个带优先级的堵塞队列
       private PriorityBlockingQueue<Task> queue=new PriorityBlockingQueue<>();
       //使用这个对象来实现线程之间的协调任务
        private Object mailBox=new Object();
        //schedule 方法的功能就是把一个Task 放到Timer中
        public void schedule(Runnable command,long after){
            Task task=new Task(command,after);
            queue.put(task);
            //当worker 线程中包含wait 机制的时候，在安排任务的时候就需要显式的唤醒一下了
            synchronized (mailBox){
                mailBox.notify();
            }
        }
        public Timer(){
            //创建一个线程，让这个线程去扫描队列的队首元素
            Thread worker=new Thread(){
                @Override
                public void run() {
                    while (true){
                        //取出队首元素，判定一下这个元素能不能执行
                        try {
                            Task task=queue.take();
                            long currentTime=System.currentTimeMillis();
                            if(currentTime>=task.time){
                                //时间到了执行任务
                                task.run();
                            }else{
                                //时间没到，继续等待
                                queue.put(task);
                                synchronized (mailBox){
                                    mailBox.wait(task.time-currentTime);
                                }
                            }
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }
            };
            worker.start();
        }
    }
}