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

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

目录一、单例模式饿汉模式懒汉模式懒汉模式二、堵塞队列实现BlockingQueue三、定时器总结

一、单例模式

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

单例模式的实现，主要依托于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;

zAyNcOq }

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 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 queue=new LinkedBlockingDeque();

//创建生产者线程

Thread producer=new Thread(){

@Override

public void run() {

zAyNcOq 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;

synchronizezAyNcOqd (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类就表示一个具体的任务，Taskhttp://里面包含一个时间戳（啥时候执行这个任务），还包含了一个Runnable 实例（用来表示具体任务是啥）

2）Timer里面通过一个带优先级的堵塞队列，来组织若干个task，根据时间先后来排优先级，快带时间的任务优先级更高

3）Timer 中还需要一个专门的线程，让这个线程不停扫描队首元素，看看队首元素是不是可以执行了，如果可以执行了，就执行这个任务，如果不能执行，就继续在队列中等待。

实现定时器:

import java.util.concurrent.PriorityBlockingQueue;

public class ThreadDemo2 {

//实现一个简单的定时器 task要放到一个优先队列中，但是优先队列中需要进行比较排序

static class Task implements Comparable{

//啥时候去执行

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 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();

}

}

}

总结

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

版权声明：本文内容由网络用户投稿，版权归原作者所有，本站不拥有其著作权，亦不承担相应法律责任。如果您发现本站中有涉嫌抄袭或描述失实的内容，请联系我们jiasou666@gmail.com 处理，核实后本网站将在24小时内删除侵权内容。