亲宝软件园·资讯

展开

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

caiyec 人气:0
想了解Java多线程(单例模式,堵塞队列,定时器)详解的相关内容吗,caiyec在本文为您仔细讲解Java多线程的相关知识和一些Code实例,欢迎阅读和指正,我们先划重点:Java单例模式,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,

在这里插入图片描述

这里我们通过加锁操作来使得操作变为原子性,使得懒汉模式变为线程安全的,可以把锁加到方法上,这时候是针对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();
        }
    }
}

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

在这里插入图片描述

可以借助堵塞队列的最大长度来设置一个生产者比消费者快的情况,将最大长度设为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();
    }

在这里插入图片描述

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

三、定时器

定时器就是闹钟,给定时器设定一个任务,约定某个任务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();
        }
    }
}

总结

本篇文章就到这里了,希望能给你带来帮助,也希望您能够多多关注的更多内容!

加载全部内容

相关教程
猜你喜欢
用户评论