JavaWeb语法四：多线程案例

最新推荐文章于 2024-03-01 14:54:33 发布

崽_85

最新推荐文章于 2024-03-01 14:54:33 发布

阅读量1.1k

点赞数 9

分类专栏： Java web 文章标签： java 开发语言

本文链接：https://blog.csdn.net/qq_56701924/article/details/128400782

版权

Java web 专栏收录该内容

8 篇文章 0 订阅

订阅专栏

前言：前一篇我们讲了线程不安全的原因以及解决办法，接下来我们将讲多线程案例，进一步来了解线程。

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");
                }
            });
        }
    }
}

总结：

以上就是我总结的多线程案例，若有错误或者有不对的，请各位铁子留言纠错，若感觉不错，请一键三连。