Java多线程四个案例

关注

原创 2026-08-14 16:44:57 219 阅读 AI 写同款· GEO 优化 ›

Java多线程实现方式2：runnable接口、龟兔赛跑案例实现Runnable 定义MyRunnable类实现Runnable接口实现run()方法，编写线程执行体创建线程对象，调用start()方法启动线程案例： package MyDemo; //创建线程方式2：实现runnable接口 //1.实现接口 //2.重写run方法 //3.创建runbale接口实现类的对象。 //启动线程。需要创建一个线程Thread对象，然后把runb... 阅读详情

1，单例模式
2，阻塞队列
3，线程池
4，定时器

一，单例模式

单例模式也就是一个进程中只允许有一个实例，是我们平时在开发中比较重要常见的一种模式，我们单例模式一般分为两种，一种是饿汉模式，一种是懒汉模式

饿汉模式：

//饿汉模式
class Singleton{
    //static保证了成员或者方法是属于类的，不属于实例，所以你不能通过new实例来调用它，刚刚好保证单例，因为new实例会创建多个对象
    private static Singleton instance=new Singleton();
    //单例模式最关键的
    private Singleton(){
    }
    public static Singleton getInstance(){
        return instance;
    }
}

在饿汉模式里面，我们调用的开始就直接创建了唯一实例，所以线程安全，因为没有判断等其他操作，只有读的操作

懒汉模式（原始）：

class Singleton3 {
    private static Singleton3 instance;
    private Singleton3() {
    }
    public static Singleton3 getInstance() {
        if (instance == null) {
            instance = new Singleton3();
        }
        return instance;
    }
}

在get方法里面判断了是否创建过实例之后再来操作，但是这样的懒汉模式线程不安全，当我们两个线程同时判定是否为空的时候，可能就会出现创建了两个instance实例，单例模式就失败了，并且new操作会因为指令重排序导致出现问题，指令重排序：编译器的一种底层优化，调整指令执行顺序，使代码效率更高。

（1）就比如new这个操作可以简化理解为三个操作：1：分配内存空间，2：针对空间进行初始化，3：内存空间首地址，赋值到引用变量中。按正常顺序，我们应该是123，但是经过指令重排序会导致变成132，就会传回去一个没有数据的值。

（2）并且外层还有if判断，加上new操作，就会使这个创建操作不是原子的，也会因为线程的随机调度导致线程安全问题，所以我们要在instance变量前面加上volatile修饰，防止指令重排序，并且在if和new的这个操作外层套上一把锁，将两个操作打包为一个整体。

（3）但是我们还需要思考一个问题，当我们第一次创建好实例之后，就不需要每次都使用锁然后判断了，这样会浪费时间和内存空间，所以我们外层需要再使用一层if判断

懒汉模式（改进）：

class Singleton2 {
    private static volatile Singleton2 instance;
    private Singleton2() {
    }
    public static Singleton2 getInstance() {//双重检查
        if (instance == null) {
            synchronized (Singleton2.class) {
                if (instance == null) {
                    instance = new Singleton2();
                }
            }
        }
        return instance;
    }
}

总结一下单例模式注意线程安全需要注意的点1：正确的加锁，2：双重if判断，3：volatile

dataSource实现单例：

//dataSource实现单例模式
class DataSource {
    private static volatile DataSource dataSource;
    private DataSource() {
    }
    public static DataSource getInstance() {
        if (dataSource == null) {
            synchronized (DataSource.class) {
                if (dataSource == null) {
                    DataSource ds=new DataSource();
                    dataSource.setUrl("jdbc:mysql://127.0.0.1:3306/java117?characterEncoding=utf8&useSSL=false&serverTimezone=UTC");
                    dataSource.setUser("root");       // 你的mysql账号
                    dataSource.setPassword("你的密码"); // 你的mysql密码
                    dataSource=ds;
                }
            }
        }
        return dataSource;
    }
}

这里有个注意点，就是我们用来一个ds这样的零时变量，最后再赋值回去，这样的作用是什么：因为有指令重排序这样的问题，所以如果没有这个零时变量，其他线程可能最坏情况下拿到还没初始化，并且还没有set的database对象，因为即使有锁，外线程依旧可以拿到里面的对象，因为DataSource是static修饰的，所有线程是共用的这一个

二，阻塞队列

队列特点：先进先出

阻塞队列的特点：1：线程安全，2：阻塞功能（阻塞队列为空的时候尝试出的时候，队列满尝试入的情况）

阻塞功能可以帮助实现生产者-消费者模型：1：降低资源的竞争，2：解决耦合（耦合就是代码功能的关联性，我们追求低耦合，关联性越低越好），3：削峰填谷（可以使请求高峰以及请求低谷的时候，服务器依旧可以按照自己的节奏来执行）

生产者-消费者的不足：1：单个请求的响应时间会受影响，2：使服务器结构更加复杂，3：这个模型更适合异步

阻塞队列的相关方法展示：

方便分为峰值和谷值来展示


import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;

//阻塞队列
public class demo8 {
    //生产快，但是消费慢，因为消费要有sleep，所以队列就产生了阻塞，每次保证队列只有两个元素
    //如果我不设置队列大小，不用阻塞队列，生产者就会疯狂的生成，然后占满内存，抛出异常
    public static void main1(String[] args) {
        BlockingQueue<Integer> blockingQueue = new ArrayBlockingQueue<>(2);
        //生产者
        Thread t1=new Thread(()->{
            for (int i = 0; i < 500; i++) {
                try {
                    blockingQueue.put(i);
                    System.out.println("生产了"+i);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        });
        //消费者
        Thread t2=new Thread(()->{
            for (int i = 0; i < 500; i++) {
                try {
                    Thread.sleep(500);
                    int take=blockingQueue.take();
                    System.out.println("消费了"+take);

                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        });
        t1.start();
        t2.start();
    }
    //消费快，生成慢
    public static void main(String[] args) {
        BlockingQueue<Integer> blockingQueue = new ArrayBlockingQueue<>(2);
        //生产者
        Thread t1=new Thread(()->{
            for (int i = 0; i < 500; i++) {
                try {
                    Thread.sleep(500);
                    blockingQueue.put(i);
                    System.out.println("生产了"+i);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        });
        //消费者
        Thread t2=new Thread(()->{
            for (int i = 0; i < 500; i++) {
                try {
                    int take=blockingQueue.take();
                    System.out.println("消费了"+take);

                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        });
        t1.start();
        t2.start();
    }
}

对于代码的解释：如果我们不使用阻塞队列进行阻塞的话，会出现

1：瞬时流量洪峰：生产者疯狂生成任务，消费处理不过来 → 队列满，生产者 put 阻塞（防止 OOM）。

什么是OOM：JVM 堆内存已经全部用光，还想继续创建新对象，JVM 直接抛OutOfMemoryError异常，程序直接崩溃。

2：流量低谷：没有新任务产生，队列全部消费完 → 队列空，消费者 take 阻塞，CPU 不轮询空转

什么是空转：线程一直在 CPU 循环做无效判断，啥业务活不干，但是一直占用 CPU，白白消耗 CPU 资源。

阻塞队列就很好地解决了以上的问题

自己实现简单的阻塞队列：

//自己创建的阻塞队列
class MyBlockingQueue{
    Object locker=new Object();
    private String[] array = new String[1000];
    private int head = 0;
    private int tail = 0;
    private int size = 0;
    public MyBlockingQueue(int capacity){
        array=new String[capacity];
    }
    public void put(String elm) throws InterruptedException {
        synchronized (locker) {
            //队列是满的
            while (size == array.length) {
                locker.wait();
            }
            //队列不满开始放东西
            array[tail] = elm;
            tail++;
            if (tail >= array.length) {
                tail = 0;
            }
            size++;
            locker.notify();
        }
    }
    public String take() throws InterruptedException {
        synchronized (locker) {
            //当队列为空的时候
            while (size==0){
               locker.wait();
            }
            //当队列不为空的时候
            String elm = array[head];
            head++;
            if (head >= array.length) {
                head = 0;
            }
            size--;
            locker.notify();
            return elm;
        }
    }
}

public class demo3 {
    public static void main(String[] args) {
        MyBlockingQueue myBlockingQueue=new MyBlockingQueue(2);
        //生产者
        Thread t1=new Thread(()->{
            for (int i = 0; i < 500; i++) {
                try {
                    Thread.sleep(500);
                    myBlockingQueue.put(i+"");
                    System.out.println("生产了"+i);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        });
        //消费者
        Thread t2=new Thread(()->{
            for (int i = 0; i < 500; i++) {
                try {
                    String take=myBlockingQueue.take();
                    System.out.println("消费了"+take);

                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        });
        t1.start();
        t2.start();
    }
}

阻塞我们用到的是wait和notify的组合，因为我们需要达成某种条件才会阻塞，并且达到某种条件才会唤醒，不能单纯的sleep以及join，并且我们这里用到的循环是while，因为while可以有再次判断的机制

三，线程池

当我们刚引入线程的时候，我们会发现线程比进程好太多了，但是接下来我们还是会发现线程的使用开销也大了一些，所以我们再引入了线程池，也就是把线程提前创建好放在里面，这样就比操作系统创建的效率来的更高

这是一台电脑的基本组成，当我们调用start来创建线程的时候，我们会有从用户态到内核态再到用户态的切换，这样会消耗一些时间和内存，但是线程池是纯用户态的操作，会更加节省开销

线程池的构造

我们来介绍一下这里的参数

（1）corePoolSize(核心线程数)，maximumPoolSize（最大线程数）

这里涉及到两类线程1：核心线程（在创建线程池当初就已经有了）2：非核心线程（因为任务太多额外创建的），两者相加就是最大线程数

（2）keepAliveTime （数值），unit（单位）

这里描述了非核心现场释放的时机

（3）workQueue（任务队列）

这里放要执行的任务，并且可以保证线程安全，可以让调用者手动指定队列

（4）threadFactory（线程工厂）

工厂设计模式：有一个工厂类，可以不依赖构造方法

可以自己提供工厂类，当然也可以用系统提供的工厂类（里面有两种）

（5）handler（拒绝策略）

任务队列到达上限，就会触发拒绝策略，主要有四种1：抛出异常，

2：调用submit这个线程自己负责来执行，

3：把任务队列中，最老的任务丢弃，把空的留给新的，

4：把任务队列中，最近添加的任务丢弃，把空的留给更加新的

线程池的创建

MyThreadFactory myThreadFactory=new MyThreadFactory("消息业务",false);
        ThreadPoolExecutor threadPoolExecutor=new ThreadPoolExecutor(
                2,
                4,
                2,
                TimeUnit.SECONDS,
                new ArrayBlockingQueue<>(10),
                myThreadFactory,
                new ThreadPoolExecutor.AbortPolicy()
        );

package thread;

import java.util.concurrent.ThreadFactory;
import java.util.concurrent.atomic.AtomicInteger;

public class MyThreadFactory implements ThreadFactory {
    //获取旧的编号，并且进行自增
    private final AtomicInteger threadIndex = new AtomicInteger(1);
    private final String threadName;
    private final boolean isDaemon;
    public MyThreadFactory(String threadName, boolean isDaemon) {
        this.threadName = threadName;
        this.isDaemon = isDaemon;
    }
    @Override
    public Thread newThread(Runnable r) {
        //先自定义名字
       String threadname= this.threadName + threadIndex.getAndIncrement();
       //创建线程
        Thread thread = new Thread(r,threadname);
        //设置守护线程
        thread.setDaemon(isDaemon);
        //设置未捕获异常处理器：线程运行抛出异常会进入这里
        thread.setUncaughtExceptionHandler((t, e) -> {
            System.err.println("【线程异常】线程名:" + t.getName() + "，异常信息:" + e.getMessage());
            e.printStackTrace();
        });
        return thread; // 返回给线程池使用
    }
}

这是我们自己创建了一个线程工厂然后传入进去，当然我们也可以用操作系统自带的

不过操作系统还提供了一个更加简单的构造方法，使用Excutor这个工厂类来创建线程池

前面两个是普通线程池，可以自动扩容，三四是指定了线程池的大小，六七十控制在未来的某个时间点执行，其他的可以自行去了解一下

并且我们往线程池中添加任务是使用submit关键字

自己实现固定数量的线程池

//自己创建线程池
class MyThreadPool{
    private BlockingQueue<Runnable> blockingQueue=new ArrayBlockingQueue<>(10);
    public void submit(Runnable runnable) throws InterruptedException {
        blockingQueue.put(runnable);
    }
    //添加构造方法
    public MyThreadPool(int size){
        for (int i = 0; i < size; i++) {
            Thread t=new Thread(()->{
                    try {
                        while (true) {
                        Runnable runnable = blockingQueue.take();
                        runnable.run();}
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
            });
            t.start();
            t.setDaemon(true);
        }

    }
}

四，定时器

定时器就和闹钟一样，在规定时间后进行执行

定时器的使用

public static void main(String[] args) throws InterruptedException {
        Timer timer=new Timer();
        timer.schedule(new TimerTask() {
            @Override
            public void run() {
                System.out.println("定时任务执行了");
            }
        },1000);
        Thread.sleep(2000);
        timer.cancel();
    }

自己实现简易定时器

自己实现定时器的主要要点：（1）因为编译器的定时器需要我们传入任务然后时间，所以我们也需要创建一个任务类，里面定义了runnable以及时间（有时间间隔delay，也有任务时间time）

（2）我们用到优先级队列来存储任务，并且在任务类里面添加比较方法，让优先级队列知道是通过时间来进行排序的

（3）通过锁来使操作原子化，并且锁的位置也很重要

（4）通过wait/notify来进行阻塞等待以及唤醒，第一个wait是等待队列不为空，第二个等待是为了等待到达任务的执行时间，两个等待同时因为schedule方法里面的notify来唤醒，因为第一个等待本身就是等待不为空，schedule方法里面添加了方法所以就唤醒，第二个是因为可能新添加的任务时间更早，可能需要重新排序，但是在我们add方法执行后的瞬间就会重新进行排序了，所以同时在这里唤醒就是合理的

import java.util.PriorityQueue;
//自己实现定时器
//先得有一个任务类，定时器中的任务在这里编写以及初始化
class TimerTask implements Comparable<TimerTask>{
    private Runnable runnable;
    //目的是判定是否到达执行时间
    private long time;
    //delay是时间间隔
    public TimerTask(Runnable runnable, long delay) {
        this.runnable = runnable;
        this.time = System.currentTimeMillis() + delay;
    }
    //在MyTimer里面通过run方法进行执行
    public void run(){
        runnable.run();
    }
    public long getTime() {
        return time;
    }

    @Override
    public int compareTo(TimerTask o) {
        return (int)(this.time - o.time);
    }
}
class MyTimer {
    Object locker =new Object();
    private PriorityQueue<TimerTask> queue = new PriorityQueue<>();

    public void schedule(Runnable runnable, long delay) {
        synchronized (locker){
            TimerTask timerTask = new TimerTask(runnable, delay);
            queue.add(timerTask);
            locker.notify();
        }
    }

    //去执行任务
    public MyTimer() {
        Thread thread = new Thread(() -> {
            while (true) {
                synchronized (locker) {
                    TimerTask timerTask = queue.peek();
                    try {
                        while (timerTask == null) {//队列为空
                            locker.wait();
                            timerTask = queue.peek();
                        }
                        long currentTime = System.currentTimeMillis();
                        if (currentTime >= timerTask.getTime()) {//到达执行时间
                            queue.poll().run();
                        } else {
                            locker.wait(timerTask.getTime() - currentTime);
                        }
                    }catch (InterruptedException e){
                        throw new RuntimeException("wait被终止");
                    }
                }
            }
        });
        thread.setDaemon(true);
        thread.start();
    }
}
public class demo12 {
    public static void main(String[] args) throws InterruptedException {
        MyTimer myTimer = new MyTimer();
        myTimer.schedule(() ->
            System.out.println("定时任务执行了1000"), 1000);
        myTimer.schedule(() ->
                        System.out.println("定时任务执行了2000"), 2000);
        myTimer.schedule(() ->
                        System.out.println("定时任务执行了3000"), 3000);
        Thread.sleep(5000);
    }
}