【线程】Java多线程代码案例（1）

晚渔声

已于 2024-11-28 13:26:14 修改

阅读量1.5k

点赞数 37

分类专栏：多线程技术文章标签：单例模式 java 阻塞队列 java-ee

于 2024-11-28 09:54:25 首次发布

本文链接：https://blog.youkuaiyun.com/telasi2004/article/details/144075546

版权

多线程技术专栏收录该内容

9 篇文章

订阅专栏

【线程】Java多线程代码案例（1）

一、“单例模式” 的实现

“单例模式”即在一个Java 进程中，要求指定的类，只能有一个实例。通过一些特殊的技巧，来确保这里的实例不会有多个。

1.1“饿汉模式”

class Singleton{
	//在这个类被加载的时候，初始化这个静态成员
    private static Singleton instance=new Singleton();

    public static Singleton getInstance() {
        return instance;
    }
    //构造方法私有，在类外部不允许new新的实例
    private Singleton(){}
}

在类外不允许创建新的实例：
instance实例时Singleton类的静态成员变量，在内存中只有一份存储空间，是唯一的。

1.2 “懒汉模式”

“懒汉模式”创建实例的时机会相对晚一些，只有到第一次使用的时候，才会创建实例。

class Singleton{
    private static Singleton instance=null;

    public static Singleton getInstance() {
        if (instance==null) {
            instance=new Singleton();
        }
        return instance;
    }
    //构造方法私有，在类外部不允许new新的实例
    private Singleton(){}

}

同样，在类外不允许创建新的实例。但是在类内创建实例的时机会相对晚一些。

1.3 线程安全问题

再次观察这两份代码，是否会存在线程安全问题呢？

其实在“饿汉模式”下，并不存在线程安全的问题，因为此处在加载类的时候，就创建了唯一的实例，后续使用只涉及到了“读取”这个操作；
而在“懒汉模式”下，就会存在一些线程安全问题，我们接下来仔细分析此处可能存在的线程安全问题：

由“随机调度”引起的线程安全问题
因为在“懒汉模式”下，既涉及到了读的操作，也涉及到了写的操作。如果在多线程中出现这样的执行顺序，就会创建出多个实例，在我们要求“单例模式”的初心下，就出现了问题。

这样的问题，也很容易解决，无非是通过加锁将读写操作打包到一起，使其成为“原子性”的操作。

public static Singleton getInstance() {
        synchronized (locker) {
            if (instance == null) {
                instance = new Singleton();
            }
        }
        return instance;
    }

这样的话，instance == null 和 instance=new Singleton()这两个操作就被打包到一起，就不会出现这样的问题了。但是，这份代码仍有一些问题。

效率上的问题
上述线程安全问题，其实只会在第一次创建实例的时候有可能会出现。也就是在整个使用过程中，只有第一次需要加锁，而我们现在的策略是每次读取instance实例都要加锁，就会造成效率低下。

public static Singleton getInstance() {
        if(instance==null) {
            synchronized (locker) {
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }

对于这样的问题，我们可以在外层再加一层判定，只在第一次创建实例的时候才加锁。

这样的代码，第一次见可能还是会有些疑惑，明明是两个一样的判定条件，怎么就需要两次？
首先我们分析，外面这个判定不要了可以吗？不行，这会影响效率。
那么，里面这个判定不要了可以吗？也不可以，如果里面这层判定没有，本质上instance == null 和 instance=new Singleton()这两步操作没有被打包到一起，仍会存在线程安全的问题。

那么，两层判定都不能去掉，究竟有何玄机呢？
这其实是因为加锁会引起阻塞，也就是意味着这两个判定执行的时间是不相同的，在阻塞的这段时间内，别的线程可能完成了一些操作（比如此处的新建实例），使得判定不再成立。

解决了效率上的问题，还可能会存在一些问题，我们继续分析。

由“系统优化”引起的指令重排序问题

instance = new Singleton();

这条代码，可简单理解为由三个步骤组成：
（1）申请一段内存空间；
（2）在这个内存上调用构造方法，创建出这个实例；
（3）把这个内存地址赋值给Instance。

正常情况下，系统是按1、2、3的步骤执行的，也有可能会优化为1、3、2的执行顺序。如果在单线程中，1、3、2的执行顺序不会有什么问题，但在多线程中，未必如此。
在这里插入图片描述

如果是这样的执行顺序，那t2线程返回的instance实例，就是一个未初始化的“全0”的值，就会出现问题。

那么这样的问题，如何解决？
依靠于Java中提供的volatile关键字，我们之前提到它可以强制系统从内存中读取数据、避免出现“内存可见性问题”。此处是volatile的第二个功能，禁止指令重排序。

private volatile static Singleton instance=null;

到此，这段代码就实现了既高效，且避免了线程安全的问题。完整代码如下：

class Singleton{
    private volatile static Singleton instance=null;
    private static Object locker;
    public static Singleton getInstance() {
        if(instance==null) {
            synchronized (locker) {
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
    //构造方法私有，在类外部不允许new新的实例
    private Singleton(){}

}

二、“阻塞队列”的实现

2.1阻塞队列

阻塞队列，是基于普通队列做出的扩展（先进先出），优势在于：

线程安全
具有阻塞特性
（1）如果一个队列已经满了，此时入队列就会阻塞，直到队列不满；
（2）如果一个队列已经空了，此时出队列就会阻塞，直到队列不空。

在 Java 标准库中内置了阻塞队列. 如果我们需要在⼀些程序中使⽤阻塞队列, 直接使⽤标准库中的即可.

BlockingQueue 是⼀个接⼝. 由ArrayBlockingQueue、LinkedBlockingQueue、PriorityBlockingQueue实现。
put ⽅法⽤于阻塞式的⼊队列, take ⽤于阻塞式的出队列.
BlockingQueue 也有 offer, poll, peek 等⽅法, 但是这些⽅法不带有阻塞特性.

2.2生产者消费者模型

在这里插入图片描述
引入生产者消费者模型，

一方面是为了“解耦合”，也就是说比如原来是生产者和消费者直接交互，那么如果消费者变更、或者生产者变更，我们的代码就需要有比较大的改动，现在统一面向缓冲区（阻塞队列），就可以很好的“解耦合”。
另一方面是“削峰填谷”，通过这个阻塞队列可以很好的控制消费者读取信息的速率。避免短时间内出现大量数据，引起问题。

2.3 阻塞队列的实现

实现阻塞队列，实质上就是实现三个方面：

先实现普通队列

class MyBlockingQueue{
    private String[] elems=null;
    private int head=0;
    private int tail=0;
    private int size=0;
    
    public MyBlockingQueue(int capacity){
        elems=new String[capacity];
    }
    
    public void put(String elem){
        if(size >= elems.length){
            //队列满了，此处要能够阻塞
        }
        elems[tail]=elem;
        tail++;
        if(tail>= elems.length){
            tail=0;
        }
        size++;
    }
    
    public String take(){
        String elem=null;
        if(size == 0){
            //队列空了，要能阻塞
        }
        elem=elems[head];
        head++;
        if(head >= elems.length){
            head=0;
        }
        size--;
        return elem;
    }
    
}

再加上线程安全
我们要求入队列和出队列、多次入队列、多次出队列不能并行执行，就要通过加锁实现。那锁都要包含那些操作呢？

那么这个判断队列是否满了的操作是否需要包裹？

试想这样的执行顺序，如果是入队列最后一个元素，就会出现问题。所以加锁应该包含判断队列是否为满的操作。

    public void put(String elem) {
        synchronized (locker) {
            if (size >= elems.length) {
                //队列满了，此处要能够阻塞
            }
            
            elems[tail] = elem;
            tail++;
            if (tail >= elems.length) {
                tail = 0;
            }
            size++;
        }
    }

    public String take() {
        synchronized (locker) {
            String elem = null;
            if (size == 0) {
                //如果队列为空，实现阻塞
            }
            elem = elems[head];
            head++;
            if (head >= elems.length) {
                head = 0;
            }
            size--;
            return elem;
        }
    }

再加上阻塞功能
我们通过wait()和notify()实现。

public void put(String elem) throws InterruptedException {
        synchronized (locker) {
            if (size >= elems.length) {
                //队列满了，此处要能够阻塞
                locker.wait();
            }

            elems[tail] = elem;
            tail++;
            if (tail >= elems.length) {
                tail = 0;
            }
            size++;
            locker.notify();
        }
    }

    public String take() throws InterruptedException {
        synchronized (locker) {
            String elem = null;
            if (size == 0) {
                locker.wait();
            }
            elem = elems[head];
            head++;
            if (head >= elems.length) {
                head = 0;
            }
            size--;
            locker.notify();
            return elem;
        }
    }

看到这样的代码，想必大家心中会有一个问题，你这一个锁里又wait()、又notify()的，这能行吗？不是自己把自己唤醒了吗？
但实际上这种问题还真不会出现。

真实情况应该是这样：

虽然我们刚才所说的这种问题不会出现，但仍有可能出现“连环唤醒”问题：
在这里插入图片描述

这里我们假设队列空了进入阻塞，我们通过put()加入一个元素后，这里随机唤醒一个线程进行take()操作，这个线程执行过程中，又把另一个线程唤醒进行take(),此时就会出现问题。

如何解决？
关键在于此处的 if 只判定一次。第一个线程被唤醒取走一个元素、并将第二个线程唤醒后，第二个线程如果能在判定1次队列是否为空，此时就不会出现问题。

这也很容易实现，我们只需要将 if 改成 while 即可。
在这里插入图片描述

2.4 再谈生产者消费者模型

我们可以通过通过控制入队或者出队的速度，来模拟这一过程。

//生产者
Thread t1=new Thread(()->{
           int n=1;
           while(true){
               try {
                   queue.put(n+"");
                   System.out.println("生产元素 "+n);
                   n++;
                   //2. 生产慢消费快
                   Thread.sleep(500);
               } catch (InterruptedException e) {
                   throw new RuntimeException(e);
               }
           }
        });
//消费者
 Thread t2=new Thread(()->{
            while(true){
                try {
                    String n=queue.take();
                    System.out.println("消费元素 "+n);
                    //1. 生产块消费慢
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        });

生产快消费慢
生产慢消费快

完整代码：

class MyBlockingQueue{
    private String[] elems=null;
    private int head=0;
    private int tail=0;
    private int size=0;

    private static Object locker=new Object();

    public MyBlockingQueue(int capacity){
        elems=new String[capacity];
    }

    public void put(String elem) throws InterruptedException {

        synchronized (locker) {
            while(size >= elems.length) {
                //队列满了，此处要能够阻塞
                locker.wait();
            }

            elems[tail] = elem;
            tail++;
            if (tail >= elems.length) {
                tail = 0;
            }
            size++;
            locker.notify();
        }
    }

    public String take() throws InterruptedException {
        synchronized (locker) {
            String elem = null;
            while(size == 0) {
                locker.wait();
            }
            elem = elems[head];
            head++;
            if (head >= elems.length) {
                head = 0;
            }
            size--;
            locker.notify();
            return elem;
        }
    }

}

public class ThreadDemo4 {
    public static void main(String[] args) {
        MyBlockingQueue queue=new MyBlockingQueue(5);
        //生产者
        Thread t1=new Thread(()->{
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            int n=1;
           while(true){
               try {
                   queue.put(n+"");
                   System.out.println("生产元素 "+n);
                   n++;
                   //Thread.sleep(500);
               } catch (InterruptedException e) {
                   throw new RuntimeException(e);
               }
           }
        });

        //消费者
        Thread t2=new Thread(()->{
            while(true){
                try {
                    String n=queue.take();
                    System.out.println("消费元素 "+n);
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        });

        t1.start();
        t2.start();

    }
}