Java并发编程中的设计模式解析(一)-阿里云开发者社区

开发者社区> 数据库> 正文

Java并发编程中的设计模式解析(一)

简介: Java并发编程,除了被用于各种Web应用、分布式系统和大数据系统,构成高并发系统的核心基础外,其本身也蕴含着大量的设计模式思想在里面。这一系列文章主要是结合Java源码,对并发编程中使用到的、实现的各类设计模式做归纳总结,以便进一步沉淀对Java并发设计的理解。

Java并发编程,除了被用于各种Web应用、分布式系统和大数据系统,构成高并发系统的核心基础外,其本身也蕴含着大量的设计模式思想在里面。这一系列文章主要是结合Java源码,对并发编程中使用到的、实现的各类设计模式做归纳总结,以便进一步沉淀对Java并发设计的理解。

模板设计模式

Thread类中run和start方法,就是一个典型的模板设计模式的实现,即:父类定义算法逻辑代码,子类实现其细节

 1 public synchronized void start() {
 2         /**
 3          * 线程对象新建后的New状态,其内部thereadStatus属性为0
 4          */
 5         if (threadStatus != 0)
 6             throw new IllegalThreadStateException();
 7 
 8         /* 同时会被添加到一个ThreadGroup */
 9         group.add(this);
10 
11         boolean started = false;
12         //调用JNI方法start0()来启动线程
13         try {
14             start0();
15             started = true;
16         } finally {
17         //线程结束之后,再次启动将抛出异常
18             try {
19                 if (!started) {
20                     group.threadStartFailed(this);
21                 }
22             } catch (Throwable ignore) {
23                 /* do nothing. If start0 threw a Throwable then
24                   it will be passed up the call stack */
25             }
26         }
27     }

下面以一个例子演示模板模式:

public class TemplateMethod {
    //相当于Thread类的start方法, 用final修饰避免被更改
    public final void print(String message) {
        System.out.println("-------------");
        wrapPrint(message);
        System.out.println("-------------");
    }
    //相当于Thread的run方法, 用protected修饰限于子类重写
    protected void wrapPrint(String message) {
        
    }
    
    public static void main(String[] args) {
        //通过匿名内部子类, 重写父类的wrapPrint方法, 从而实现不同的输出模板
        TemplateMethod t1 = new TemplateMethod() {
            @Override
            protected void wrapPrint(String message) {
                System.out.println("111" + message + "111");
            }
        };
        t1.print("Hello World!");
        
        TemplateMethod t2 = new TemplateMethod() {
            @Override
            protected void wrapPrint(String message) {
                System.out.println("222" + message + "222");
            }
        };
        t2.print("Hello World!");
    }
}

策略模式

创建Java多线程中,实现Runnable接口作为Target并传入Thread类的构造方法来生成线程对象的过程,就体现了GoF中策略模式的设计思想。下面是一个简单的示例:

首先,仿照Runnable接口的思想,定义一个用于处理数据库行的接口

1 /*
2  * RowHandler定义了对数据库查询返回结果操作的方法, 具体实现需要
3  * 实现类完成, 类似于Runnable接口
4  */
5 public interface RowHandler<T> {
6     T handle(ResultSet rs);
7 }

然后,仿照Thread方法,定义数据库查询的工作类

 1 public class RecordQuery  {
 2     
 3     private final Connection connection;
 4 
 5     public RecordQuery(Connection connection) {
 6         this.connection = connection;
 7     }
 8     //方法中传入RowHandler的实现类
 9     public <T> T query(RowHandler<T> handler, String sql, Object... params) throws SQLException {
10             PreparedStatement stmt;
11             ResultSet resultSet;
12             stmt = connection.prepareStatement(sql);
13             int index = 1;
14             for (Object param : params) {
15                 stmt.setObject(index++, param);
16             }
17             resultSet = stmt.executeQuery();
18             //调用实现类的handle方法来处理数据
19             return handler.handle(resultSet);
20     }
21 }

生产者-消费者模式

生产者-消费者模式是使用Java并发编程通信所实现的经典模式之一。该模式是通过队列这一数据结构来存储对象元素,由多线程分别充当生产者和消费者,生产者不断生成元素、消费者不断消费元素的过程。下面通过代码来演示:

实现一个带有入队和出队的队列

 1 /*
 2  * 通过一个生产者-消费者队列来说明线程通信的基本使用方法
 3  */
 4 public class EventQueue {
 5     //定义一个队列元素数量, 一旦赋值则不可更改
 6     private final int max;
 7     //定义一个空的内部类, 代表存储元素
 8     static class Event{        }
 9     //定义一个不可改的链表集合, 作为队列载体
10     private final LinkedList<Event> eventQueue = new LinkedList<>();
11     //如果不指定初始容量, 则容量默认为10
12     private final static int DEFAULT_MAX_EVENT = 10;
13     //使用自定义容量初始化队列
14     public EventQueue(int max) {
15         this.max = max;
16     }
17     //如果不指定初始容量, 则容量默认为10
18     public EventQueue() {
19         this(DEFAULT_MAX_EVENT);
20     }
21     //封装一个输出到控制台的方法
22     private void console(String message) {
23         System.out.printf("%s:%s\n",Thread.currentThread().getName(), message);
24     }
25     //定义入队方法
26     public void offer(Event event) {
27         //使用链表对象作为锁, 通过synchronized代码块实现同步
28         synchronized(eventQueue) {
29             //在循环中判断如果队列已满, 则调用锁的wait方法, 使生产者线程阻塞
30             while(eventQueue.size() >= max) {
31                 try {
32                     console(" the queue is full");
33                     eventQueue.wait();
34                 } catch (InterruptedException e) {
35                     e.printStackTrace();
36                 }
37             }
38             console(" the new event is submitted");
39             eventQueue.addLast(event);
40             //唤醒所有等待中的消费者;注意如果此处使用notify(),可能导致线程不安全
41             this.eventQueue.notifyAll();
42         }
43     }
44     //定义出队方法
45     public Event take() {
46         //使用链表对象作为锁
47         synchronized(eventQueue) {
48             //在循环中判断如果队列已空, 则调用锁的wait方法, 使消费者线程阻塞
49             while(eventQueue.isEmpty()) {
50                 try {
51                     console(" the queue is empty.");
52                     eventQueue.wait();
53                 } catch (InterruptedException e) {
54                     e.printStackTrace();
55                 }
56             }
57             Event event = eventQueue.removeFirst();
58             //唤醒所有等待中的生产者;注意如果此处使用notify(),可能导致线程不安全
59             this.eventQueue.notifyAll();
60             console(" the event " + event + " is handled/taked.");
61             return event;
62         }
63     }
64 }

验证该队列的类

 1 /*
 2  * producer/client pattern
 3  */
 4 public class EventClient {
 5     
 6     public static void main(String[] args) {
 7         //定义不可变队列实例
 8         final EventQueue eventQueue = new EventQueue();
 9         //新建生产者线程, 可以设置多个
10         new Thread(()->{
11             while(true) {
12                 eventQueue.offer(new EventQueue.Event());
13             }
14         }, "producer").start();
15         //新建消费者线程, 可以设置多个
16         new Thread(()->{
17             while(true) {
18                 eventQueue.take();
19                 try {
20                     TimeUnit.MILLISECONDS.sleep(10);
21                 } catch (InterruptedException e) {
22                     e.printStackTrace();
23                 }
24             }
25         }, "consumer").start();
26     }
27 }

版权声明:本文内容由阿里云实名注册用户自发贡献,版权归原作者所有,阿里云开发者社区不拥有其著作权,亦不承担相应法律责任。具体规则请查看《阿里云开发者社区用户服务协议》和《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容,填写侵权投诉表单进行举报,一经查实,本社区将立刻删除涉嫌侵权内容。

分享:
数据库
使用钉钉扫一扫加入圈子
+ 订阅

分享数据库前沿,解构实战干货,推动数据库技术变革

其他文章