❣博主主页: 33的博客❣
▶️文章专栏分类:JavaEE◀️
🚚我的代码仓库: 33的代码仓库🚚
🫵🫵🫵关注我带你了解更多线程知识

1.前言

在开发过程中，我们会遇到很多经典的场景，针对这些经典场景，大佬们就提出了一些解决方案，我们只需要按照这个解决方案来进行代码的编写，这样就不会写得很差。

2.单例模式

我们先了解什么是设计模式，在开发过程中，我们会遇到很多经典的场景，针对这些经典场景，大佬们就提出了一些解决方案，按照这个方式进行编程，代码就不会很差，就例如下期中的棋谱，如果按照棋谱下棋也是不会下很烂的。
所谓单例就是单个实例（对象），那么怎么保证一个类只有一个对象呢？我们需要通过一些编程技巧来达成这样的效果。
在一个类的内部提供一个实例，把构造方法设置为private避免再构造出新的实例

2.1饿汉方式

饿汉方式：

class Singleton{private static Singleton instance=new Singleton();public static Singleton getsingleton(){return instance;}private  Singleton(){}
}
public class Demo17 {public static void main(String[] args) {Singleton s1=Singleton.getsingleton();//Singleton s2=new Singleton();}
}

上述代码中，创建一个实例的时候在类加载的时候，太早就创建了，那可不可以晚一点呢？

2.2饿汉方式

懒汉方式：

class Singleton2{private static Singleton2 instance2=null;public static Singleton2 getInstance2(){if(instance2==null){instance2=new Singleton2();}return instance2;}private Singleton2(){};
}

但懒汉模式是不安全的，如下：

这样就创建了两个实例，所以我们需要对读取和修改进行加锁操作

class Singleton3{private static Singleton3 instance3=null;Object lock=new Object();public static Singleton3 getInstance2(){synchronized (lock){if(instance3==null){instance3=new Singleton3();}}return instance3;}    
}

这样就只有在调用getInstance2方法才会去创建对象，但是又引出了新的问题，其实是否创建对象，只需要在第一次调用这个方法的时候判断，一旦创建好，以后都不用在再去判断了，可这样写，每次调用这个方法都会去判断，这样就消耗不少资源。我们进行优化：

class Singleton3{private static Singleton3 instance3=null;Object lock=new Object();public static Singleton3 getInstance2(){if(instance3==null){synchronized (lock){if(instance3==null){instance3=new Singleton3();}}}return instance3;}private Singleton3(){};
}

大家以为到这儿，代码完美了吗？其实并不是，在new的时候可能会引起指令重排序问题，那么什么是指令重排序问题呢？指令重排序也是编译器为了提高执行效率，做出的优化，在保持逻辑不变的前提下，可能对编译器做出优化.
例如我们要去一个水果超市买香蕉、苹果、火龙果、猕猴桃四种水果但它们在不同的展区。
优化前：

优化后
在通常情况下，在单线程中，指令重排序，就能够保证逻辑不变的情况下，把程序的效率提高，但在多线程中就不一定了，可能会误判。
new操作是可能触发指令重排序
new可以分为3步：
1.申请内存空间
2.在内存空间上构造对象（构造方法）
3.把内存地址复制给instance引用。
如果内存进程优化：
1.申请内存空间
2.把内存地址复制给instance引用。
3.在内存空间上构造对象（构造方法）

那么该怎么解决这个问题呢？可以使用volatile让其修饰instanse就可以保证，在修改instanse的时候就不会出现指令重排序问题。

class singleton{private static volatile  singleton instance=null;public static singleton getinstance(){if (instance==null){synchronized (singleton.class){if (instance==null){instance=new singleton();}}}return instance;}private singleton(){}  
}
public class Demo21 {public static void main(String[] args) {singleton s1=singleton.getinstance();}
}

这个时候才算真正的完成一个单例模式。

3.阻塞队列

3.1概念

阻塞队列也是多线程编程中比较常见的一种数据结构，它是一种特殊的队列，它具有线程安全的特点，并且带有阻塞特性。
阻塞队列最大的意义就是用来实现“生产者消费者模型”
例如：一家人在一起包饺子，但是擀面杖只有一个，那么就指定一定人擀饺子皮就称它为生产者，每擀一张皮，就放入圆盘中，其余人都包饺子称为消费者，如果圆盘中没有饺子皮了，消费者就要等待生产，如果圆盘中放满了就要等待生产者就要等待消费。
那么为啥要引入“生产者消费者模型”呢？队我们又有什么好处呢？

1.解耦合：就是降低两个代码块的紧密程度
2.削峰填谷
那么在Java中，怎么实现阻塞队列呢？在标准库里，以及提供了线程的

 public static void main(String[] args) throws InterruptedException {BlockingDeque<Integer> deque=new LinkedBlockingDeque<>();deque.put(1);deque.put(2);deque.put(3);System.out.println(deque.take());System.out.println(deque.take());System.out.println(deque.take());System.out.println(deque.take());}

最后一次出队列，队列已经空了，所以就会阻塞:

3.2实现

既然我们已经会使用阻塞队列了，那我们能不能自己实现一下呢？我们底层可以采用循环数组来实现。

public class MyBlockingqueue {String[] arr=new String[20];private volatile int head=0;//后续中既会读又会改，为了避免内存可见性＋volatileprivate volatile int end=0;private volatile int size=0;public void put(String elem) throws InterruptedException {synchronized (this){if(end==arr.length){this.wait();return;}arr[end]=elem;end++;size++;this.notify();//唤醒因为队列空导致的阻塞if(end==arr.length){end=0;}}}public String tack() throws InterruptedException {synchronized (this){if (size==0){this.wait();}String ret=arr[head];head++;size--;this.notify();//唤醒因为队列满导致的阻塞if(head==arr.length){head=0;}return ret;}}
}

4.定时器

4.1概念

定时器也是日常开发中常见的组件，约定一个时间，时间到达后就会执行某个逻辑。在Java标准库中，有一个线程的标准库。

public static void main(String[] args) {Timer timer=new Timer();timer.schedule(new TimerTask() {@Overridepublic void run() {System.out.println("3000");}},3000);timer.schedule(new TimerTask() {@Overridepublic void run() {System.out.println("2000");}},2000);timer.schedule(new TimerTask() {@Overridepublic void run() {System.out.println("1000");}},1000);System.out.println("定时器打开");
}

主线程执行schdule方法时，此时就把任务放到了timer中，此时timer中也也包含一个线程，叫做扫描线程，一旦时间到达就会给改线程安排任务。那么我们能不能自己实现呢？

4.2实现

1.需要定义一个类来描述一个任务，这个任务需要包含时间，和实际任务。
2.需要有一个数据结构，把任务全部存到数据库中
3.Timer中需要一个线程来描述任务是否到达时间
一个任务类：

lass  MyTimerTask implements Comparable<MyTimerTask>{private   Runnable runnable;private long time;public MyTimerTask(Runnable runnable,long delay){this.runnable=runnable;this.time=System.currentTimeMillis()+delay;}public long gettime(){return time;}public Runnable getrun(){return runnable;}@Overridepublic int compareTo(MyTimerTask o) {return (int) (this.time-o.time);}
}

一个Timer类：

public class MyTimer {private PriorityQueue<MyTimerTask> queue=new PriorityQueue<>();Object locker=new Object();public void schedule(Runnable runnable,long time ){synchronized (locker){queue.offer(new MyTimerTask(runnable,time));locker.notify();}}public MyTimer(){Thread t=new Thread(()->{while (true){try {synchronized (locker){while (queue.isEmpty()){locker.wait();}MyTimerTask task= queue.peek();long curenttime=System.currentTimeMillis();if (curenttime>=task.gettime()){task.getrun().run();queue.poll();}else {locker.wait(task.gettime()-curenttime);}}}catch (InterruptedException e){e.printStackTrace();}}});t.start();}
}

测试类：

class M{public static void main(String[] args) {MyTimer myTimer=new MyTimer();myTimer.schedule(new Runnable() {@Overridepublic void run() {System.out.println("3000");}},3000);myTimer.schedule(new Runnable() {@Overridepublic void run() {System.out.println("2000");}},2000);System.out.println("开始");}
}

5.线程池

5.1概念

池，这个词，是计算机中一种比较重要的思想方法，很多地方都涉及到，比如内存池，进程池，连接池等等。
线程池,就是指在使用第一个线程的时候就把其他线程线程一并创建好，后续如果想要使用这个其他线程，就不必再重新创建新的线程，直接从线程池中回去即可。
那么为啥线程创建好放在池子里后续再从池子中取，比新建线程的效率更高呢？
从池子中取是纯用户态的操作，而创建线程是用户态+内核态相互配合完成的。如果一段程序是在系统内核中执行的就是叫内核态，否则为用户态。当创建线程时，就需要调用系统api，进入内核进入一系列操作，但操作系统内核不仅仅是给该线程提供服务，也要给其他线程提供服务，那么这个效率就是非常低的了。
在Java标准库中，提供了写好的线程池，直接用即可。

public static void main(String[] args) {ExecutorService service= Executors.newCachedThreadPool();}

线程池对象并不是直接new的，而是调用一个方法返回线程池对象Executors.newCachedThreadPool()称为工厂模式。
通常情况下创建一个对象需要用new关键字，new关键字会触发类的构造方法，但构造方法具有局限性，例如：在一个类中，我即能用笛卡尔坐标系来表示一个点，又能有极坐标的方法表示一个:

class point{//笛卡尔坐标public point(double x,double y){}//极坐标public point(double a,double b){}
}

但如果要在一个类中实现多个构造方法，那么就要保证构造方法的参数不同，或者是类型不同。为了解决构造方法的局限性，我们就使用工厂设计模式。
工厂设计模式就是指，用一个单独的类，再使用静态普通方法代替构造方法做的事情。

class PointFactory{public static Point MackXY(){Point p=new Point();.......return p;}public static Point MackAB(){Point p=new Point();.......return p;}
}

在构造线程池中也有多种方法：

 public static void main(String[] args) {//线程池是动态的，cache缓存用了之后不立即释放ExecutorService service= Executors.newCachedThreadPool();//固定创建几个线程ExecutorService service1=Executors.newFixedThreadPool(3);//相当于定时器，但不是一个扫描线程进程操作而是多个线程了ExecutorService service2=Executors.newScheduledThreadPool(4);//固定只有一个线程ExecutorService service3=Executors.newSingleThreadExecutor();}

上述多种方法都是对ThreadExecutor进行的封装，这个类非常丰富，提供了很多参数，标准库中上述多种方法实际给这个类填写了不同的参数来构造线程。

具体看最后一种构造方法，因为包含了前面三种

ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue, ThreadFactory threadFactory, RejectedExecutionHandler handler) 

int corePoolSize:核心线程数
int maximumPoolSize：最大线程数
long keepAliveTime：非核心线程在终止之前等待新任务的最长时间
TimeUnit unit：时间单位
BlockingQueue workQueue：阻塞队列，存放线程池的任务
ThreadFactory threadFactory：用于创建新线程的工厂。
RejectedExecutionHandler handler：线程拒绝策略

RejectedExecutionHandler handler：线程拒绝策略
一个线程池中，能容纳的线程数目已经达到最大上限，继续再添加将有不同的效果：有以下4种效果

1.ThreadPoolExecutor.AbortPolicy：线程池直接抛出异常
2ThreadPoolExecutor.CallerRunsPolicy：新添加的任务由添加任务的线程自己执行
3.ThreadPoolExecutor.DiscardOldestPolicy：丢弃队列中最老的任务
4.ThreadPoolExecutor.DiscardPolicy：丢弃当前新加的任务

5.2实现

public class MyThreadPool {//设置任务队列BlockingDeque<Runnable> queue=new LinkedBlockingDeque<>();//任务放到队列public void submit(Runnable runnable) throws InterruptedException {queue.put(runnable);}//线程执行public MyThreadPool(int n) throws InterruptedException {for (int i=0;i<n;i++){Thread t=new Thread(()->{try {Runnable runnable = queue.take();runnable.run();} catch (InterruptedException e) {e.printStackTrace();}});t.start();}}
}
class M{public static void main(String[] args) throws InterruptedException {MyThreadPool myThreadPool=new MyThreadPool(4);for (int i=0;i<100;i++){int id=i;myThreadPool.submit(new Runnable() {@Overridepublic void run() {System.out.println("i="+id);}});}}
}

6.总结

单例模式，阻塞队列，定时器，线程池，是一些常用的多线程代码，希望同学们能够熟练掌握它们得使用方法，感兴趣的同学也可以自己实现一下。

下期预告：多线程进阶