目录
1.单例模式
1.1：饿汉模式
1.2：懒汉模式
2.阻塞式队列
2.1:生产者消费者模型
2.2：阻塞队列的模拟实现
3.线程池
3.1：标准库中的线程池
3.2：模拟实现线程池
前言：前一篇我们讲了线程不安全的原因以及解决办法，接下来我们将讲多线程案例，进一步来了解线程。
1.单例模式
单例模式（单个实例，单个类，只能被创建一个实例。）是校招中最常考的设计模式。而设计模式是什么意思勒？
设计模式：就是针对一些典型的场景，给出一些典型的方案，就想棋谱一样。
1.1：饿汉模式
class singleton{
private static singleton instance=new singleton();
private singleton() {
}
public static singleton getInstance(){
return instance;
}
}
public class ThreadDemo1 {
public static void main(String[] args) {
//singleton s=new singleton();//这里为啥报错了？
singleton s1=singleton.getInstance();
singleton s2=singleton.getInstance();
System.out.println(s1==s2);//这个结果是true为啥了
}
}
这个饿汉模式是怎么实现了只能创造一个实例，且实例是唯一的。
1.private static singleton instance=new singleton()；
static 修饰的成员instance是类属性，相当于这个属性对应的内存空间在类对象中，而在这里类对象又是唯一的实例（是在类加载阶段，就把实例创建出来）这就让这个实例是唯一的。
类加载：运行一个java程序，就需要让java进程能够找到并读取对应的.class文件。就会读取文件内容并解析，构造成类对象，这一系列的过程就是类加载。
2.private singleton(){}：有private 修饰的构造方法是私有的，只能在singleton这个类进行使用，无法进行new 一个对象。
3. 只能调用getInstance 这个 方法来获得instance这个实例对象。所以是s1和s2是指向同一个实例对象。所以返回的true。
1.2：懒汉模式
class singletonLazy{
private static singletonLazy instance=null;
public static singletonLazy getInstance(){
if(instance==null){
instance=new singletonLazy();
}
return instance;
}
private singletonLazy(){
}
}
public class ThreadDemo2 {
public static void main(String[] args) {
singletonLazy s1=singletonLazy.getInstance();
singletonLazy s2=singletonLazy.getInstance();
System.out.println(s1==s2);
}
}
这个懒汉模式，在类加载的时候不创建实例，第一次使用的时候才创建实例。但这个是线程不安全的。那我们要了解一下，为啥是线程不安全的勒?
为啥是线程不安全的?
线程不安全是首次创建实例时，如果在多个线程中同时调用getInstance,就可能导致创建出多个实例。
线程一调用com的时候，instance这个对象是 null,在进行创建instance这个实例的时候，线程二进行com的时候，那时候instance这个对象还是 null，也会进行创建instance这个实例。这样可能导致创建多个实例。
为了解决线程不安全。使用双重if判定。
给instance加上volatile。
2.阻塞式队列
阻塞队列是一种特殊的队列，遵循"先进先出"的原则。
当队列满的时候，继续入队列就会阻塞，直到有其他线程从队列中取走元素。
当队列空的时候，继续出队列也会阻塞，直到其他线程往队列中插入元素。
阻塞队列的一个典型应用场景就是 "生产者消费者模型"，这是一种非常典型的开发模型。
2.1:生产者消费者模型
优点一：能够让多个服务器之间解耦合。
A 只需要和阻塞队列进行交互，不需要知道B是怎么运行的。哪怕B挂了，出现了问题，跟A也没有什么关系，A和B是陌生人。
B 只需要和阻塞队列进行交互，不需要知道A是怎么运行的，哪怕A挂了，出现了问题，跟B也没有什么关系，B和A是陌生人。
优点二：能过对于请求削峰填谷。
假如未使用生产者消费者模型
A暴涨=>B暴涨
A作为入口服务器，计算量很轻，请求暴涨，问题不大，但B作为应用服务器，计算量可能很大，需要的系统资源也更多，如果请求更多，需要的资源进一步增加，如果主机的硬件不够，程序就会面临挂的风险。
A请求暴涨=>阻塞队列的请求暴涨。由于阻塞队列没啥计算量，就只是单纯的存个数据，就能抗住更大的压力，而B这边仍然按照原来的速度来消费数据，不会因为A的暴涨而引来暴涨，这样B就被保护的很好，就不会因为这种请求的波动而引起来崩溃。
”削峰“:请求不会一直暴涨下去，而带来的这种峰值也不会持续很久，就一阵，过去就恢复了。
”填谷":当请求很少的时候，B依然按照原来的频率来处理之前积压的数据。
2.2：阻塞队列的模拟实现
通过循环队列的方式方法来实现。
使用synchronized进行加锁控制。
put插入元素的时候，判定如果队列满了，就进行wait。
take 取出元素的时候，判定如果队列为空，就进行wait。
class BlockingQueue {
int[] queue = new int[3];
int prev = 0;
int tail = 0;
int size = 0;
Object lock=new Object();
//入队列
public void put (int value) throws InterruptedException {
//判断队列是否为满
synchronized (lock) {
if (size >= queue.length) {
lock.wait();//队列满了，进入阻塞队列
}
queue[tail] = value;
size++;
tail++;
if (tail >= queue.length) {
tail = 0;
}
//此处唤醒put队列为空的阻塞等待
lock.notify();
}
}
public Integer take() throws InterruptedException {
//判断队列是否为空
synchronized (lock) {
if (size == 0) {
lock.wait();//队列为空进入阻塞队列
}
int val = queue[prev];
prev++;
size--;
if (prev >= queue.length) {
prev = 0;
}
lock.notify();//此处唤醒put队列未满的阻塞队列
return val;
}
}
}
public class ThreadDemo3 {
public static void main(String[] args) throws InterruptedException {
BlockingQueue blockingQueue=new BlockingQueue();
//生产者
Thread t=new Thread(()->{
int num=0;
while(true){
try {
System.out.println("生产了"+num);
blockingQueue.put(num);
num++;
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
});
Thread t1=new Thread(()->{
try {
while(true) {
int num = blockingQueue.take();
System.out.println("消费了" + num);
Thread.sleep(30);
}
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
});
t.start();
t1.start();
}
}
标准库里面的阻塞队列
BlockingQueue<Integer> blockingQueue=new LinkedBlockingQueue<>();
3.线程池
把线程提前创建好，放到线程池中，后面需要用线程，直接从池子取，就不必从系统这边申请。线程用完，也不是还给系统，而是返回池子中，以备下次再用。
3.1：标准库中的线程池
创建固定线程数的线程池
ExecutorService pool= Executors.newFixedThreadPool(10)
这里10是指定创建10个线程的线程池。
创建线程数目动态增长
ExecutorService pool=Executors.newCachedThreadPool();
创建只包含单个线程的线程池
ExecutorService pool=Executors.newSingleThreadExecutor();
3.2：模拟实现线程池
核心操作为submit，江任务加入到线程池中。
使用Worker类描述一个工作线程，使用runable描述一个任务。
使用一个BlockingQueue组织所有的任务。
每一个woker线程要做的事情，不停的从blockqueue中取任务并执行。
指定一个线程池中最大的线程数当当前线程数超过这个最大值时，就不再新增线程。
public class MyThreadPool {
//使用一个数据结构来组织一个任务。
BlockingDeque<Runnable> deque=new LinkedBlockingDeque<>();
static class worker extends Thread {
private BlockingDeque<Runnable> deque = null;
public worker(BlockingDeque<Runnable> deque) {
this.deque = deque;
}
@Override
public void run() {
//循环去线程池中拿出任务
while (true) {
Runnable runnable = null;
try {
runnable = deque.take();
runnable.run();
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
}
}
//创建一个数据结构来组织线程
List<Thread>works=new ArrayList<>();
//在构造方法中，就这些线程放到上述的线程池中
public MyThreadPool(int n) {
for(int i=0;i<n;i++){
worker worker=new worker(deque);
worker.start();
works.add(worker);
}
}
public void submit(Runnable runnable){
try {
deque.put(runnable);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
public static void main(String[] args) {
MyThreadPool pool=new MyThreadPool(10);
for (int i=0;i<10;i++){
pool.submit(new Runnable() {
@Override
public void run() {
System.out.println("hello");
}
});
}
}
}
总结：
以上就是我总结的多线程案例，若有错误或者有不对的，请各位铁子留言纠错，若感觉不错，请一键三连。
