精华内容
下载资源
问答
  • 多线程设计模式

    2014-12-17 14:52:50
    Java多线程 设计模式 附加目录 详细介绍
  • Java多线程设计模式 清晰完整PDF版 Java多线程设计模式源代码
  • 多线程开发可以更好的发挥多核cpu性能,常用的多线程设计模式有:Future、Master-Worker、GuardSusperionsion、不变、生产者-消费者 模式;jdk除了定义了若干并发的数据结构,也内置了多线程框架和各种线程池;锁...

    多线程开发可以更好的发挥多核cpu性能,常用的多线程设计模式有:Future、Master-Worker、Guard Susperionsion、不变、生产者-消费者 模式;jdk除了定义了若干并发的数据结构,也内置了多线程框架和各种线程池;    锁(分为内部锁、重入锁、读写锁)、ThreadLocal、信号量等在并发控制中发挥着巨大的作用。

    多线程设计模式:

    1.Single Threaded Execution Pattern

    [同一时刻只允许一个线程操作]

    比喻:三个挑水的和尚,只能同一时间一个人过桥,不然都掉河里喂鱼了。

    总结:在多个线程同时要访问的方法上加上synchronized关键字。

    2.Immutable Pattern

    [变量赋值一次后只能读取,不能改变。]   比喻:一夫多妻制,多个妻子共享一个丈夫。一旦赋值,任何一个妻子不能更改共享的 husband为其它人。

    总结:将多线程共享的变量用final关键字修饰。

    3.Guarded Suspension Pattern

    [要等到我准备好哦,没准备好就在门口等着,准备好了再叫你。]   比喻:

    GG:小伙子去MM家,敲门...

    MM:我在换衣服,稍等。

    GG:等待 【调用wait()方法挂起自己的线程】

    MM:换好了,进来吧 【调用notify()或着notifyAll()方法通知GG】

    总结:判断某个条件是否为真,如果条件成立则继续执行一步,如果条件不成立用wait()方法挂起当前线程,条件为真后由另一个线程用notify()或 着notifyAll()方法唤醒挂起的线程。

    4.Balking Pattern

    [有人在做了?哈哈,太好了,我就不过去了!]

    比喻:饭店里我想好了要点的菜后,高高的举起手示意服务生过来,一个服务生准备过去的时候看到另外一个服务生已经过去了,哈哈已经有人过去了我就不过去了。

    总结:设置一个volatile的共享变量,多个线程进入同一方法时,判断变量的值是否为真,如果为真说明有人已经在做这个工作了,线程返回,反之将变量赋值为真并执行。

    5.Producer-Consumer Pattern

    [生产-消费者,你生产蛋榚我来吃。]

    比喻(1):一群猪围着猪食槽的一头,塞进几块玉米饼后,群猪争先恐后从食槽头抢,谁抢到谁吃。

    比喻(2):一群猪围着猪食槽的头和尾,塞进几块玉米饼后,群猪争先恐后从食槽头和食槽尾抢,谁抢到谁吃。

    总结:<1>生产者将生产出来的东西add(E e)到一个Queue,然后唤醒正在从Queue等东西的线程,用poll()方法从队列的头获取到东西,当Queue里的东西被取完,取东西的线程再次被挂起。

    <2>生产者将生产出来的东西放入(方法很多,有add(E e)、addFirst(E e)、addLast(E e)等)一个Deque,然后唤醒正在从Queue等东西的线程,线程从Deque的头和尾取东西,当Deque里的东西被取完,取东西的线程再次被挂起。

    6.Read-Write Lock Pattern

    [学生抄的时候,不允许老师擦掉黑板上的字。]

    比喻:老师在黑板上写了些字,下面的同学在拼命的抄,过会儿老师要写些新的字,写新字要擦掉原来的那些,问:都写完了么?如果都回答写完了,就擦掉原来的字写新的,如果还有一个回答没写完,就等待最后一个同学抄完再写。

    总结:Jdk1.5及以上有专门的读写锁实现

    java.util.concurrent.locks.ReentrantReadWriteLock.ReadLock;

    java.util.concurrent.locks.ReentrantReadWriteLock.WriteLock;

    7.Thread-Per-Message Pattern

    [一任务一线程]

    总结:一个客人一个妞服务,好是好,可是天朝扫黄太厉害,现在狼多肉少哇,用线程池吧,轮流服务。

    8.Worker Thread Pattern

    [同Producer-Consumer Pattern]

    9.Future Pattern

    [给您一张提货单,下午来取。]

    比喻:

    李刚:大钞票一摔,来只大蛋榚!

    店员:对不起没这么大的,但现做,给您张单子,下午xx点来取。

    李刚:取货单??,上面都写了些啥?

    订单号:SB01

    客户名:李刚

    已付款:250

    取货时间:PM2:50

    总结:调用某个方法时,这个方法可能需要请求其它系统,这个过程比较耗时,为了提高客户的体验需要方法立即返回,过一段时间再查询结果。

    在程序里声明一个Hashmap,Key保存订单号,Value保存生产出的蛋榚,然后根据订单号取得对应的蛋榚。

    10.Two-Phase Termination Pattern

    [玩具收拾好,睡觉去]   比喻:小孩子在玩具,到点了妈妈喊:别玩了,睡觉去!

    总结:一个线程在while(!isInterrupted()){..}循环中执行,另外一个线程判断某个条件达到后获得准备被结束线程的句柄,调用interrupt()

    设置线程的中断状态。

    11.Thread-Specific Storage Pattern

    [线程私有物品保管箱]    总结:一个方法可能会被同一个线程访问多次,如果每访问一次就要声明一个数据库连接的Connection变量,则对程序的性能有影响。将Connection放在ThreadLocal里,这样每次访问就不必再产生一个Connection,同一个线程对应同一个Connection.

    展开全文
  • 多线程设计模式之保护性暂停模式

    万次阅读 2020-09-14 14:56:30
    多线程设计模式之保护性暂停模式 定义 保护性暂停模式(Guarded Suspension Design Pattern):当线程在访问某个对象时,发现条件不满足时,就暂时挂起等待条件满足时再次访问。 如果某个结果需要在多线程之间传递,...

    多线程设计模式之保护性暂停模式

    定义

    保护性暂停模式(Guarded Suspension Design Pattern):当线程在访问某个对象时,发现条件不满足时,就暂时挂起等待条件满足时再次访问。

    如果某个结果需要在多线程之间传递,则可以让这些线程关联到一个对象GuardedObject,但是如果这个结果需要不断的从一个线程到另一个线程那么可以使用消息队列(生产者/消费者)

    Thread.join()、Future就采用了保护性暂停模式。

    简单实现

    package com.morris.concurrent.pattern.guardedsuspension.v2;
    
    public class GuardedObject<V> {
    
        private final Object lock = new Object();
    
        private V v;
    
        private boolean isFinished;
    
        public void set(V v) {
            synchronized (lock) {
                this.v = v;
                isFinished = true;
                lock.notifyAll();
            }
        }
    
        public V get() throws InterruptedException {
            synchronized (lock) {
                while (!isFinished) {
                    lock.wait();
                }
            }
            return v;
        }
    }
    

    超时实现

    public V get(long millis) {
        synchronized (lock) {
            while (!isFinished) {
                try {
                    lock.wait(millis);
                    break;
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
        return v;
    }
    

    上面的超时实现有点小问题。

    分析:假如超时时间是5s,但是在第2s的时候别人把这个线程中断了但是此时还没有结果,那么这个线程就会进入下次循环继续等待5s,这样这个线程就等待7s了。

    最终实现如下:

    public V get(long millis) {
        long begin = System.currentTimeMillis(); // 等待开始时间
        long waitedTime = 0; // 等待了多长时间
        synchronized (lock) {
            while (!isFinished) {
                if(waitedTime >= millis) {
                    System.out.println("超时了,不等了");
                    break;
                }
                try {
                    lock.wait(millis - waitedTime); // 继续等待剩余时间
                    break;
                } catch (InterruptedException e) {
                    waitedTime = System.currentTimeMillis() - begin;
                    System.out.println("被中断了,等了" + waitedTime + "ms");
                }
            }
        }
        return v;
    }
    

    使用保护性暂停模式实现Future和Callable

    public interface Callable<T> {
        T call();
    }
    
    public interface Future<T> {
        T get();
    }
    
    public class FutureTask<T> implements Future<T> {
    
        private boolean isFinish;
    
        private T t;
    
        public synchronized void set(T t) {
            this.t = t;
            this.isFinish = true;
            this.notifyAll();
        }
    
        @Override
        public synchronized T get() {
            while (!isFinish) {
                try {
                    this.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            return t;
        }
    }
    
    public abstract class Executors {
    
        public static <T> Future<T> newSingleThreadPool(Callable<T> callable) {
            FutureTask<T> future = new FutureTask<>();
            new Thread(()->{
                T t = callable.call();
                future.set(t);
            }).start();
            return future;
        }
    
    }
    
    展开全文
  • Java 多线程设计模式

    2018-05-26 20:27:03
    《JAVA多线程设计模式》中包含JAVA线程的介绍导读,12个重要的线程设计模式和全书总结以及丰富的附录内容。每一章相关线程设计模式的介绍,都举一反三使读者学习更有效率。
  • java多线程设计模式

    2018-09-05 11:18:48
    java多线程设计模式,高清PDF文档,详细阐述了Java多线程下相关设计模式以及应用,值得学习和收藏以及参考
  • Java多线程设计模式源代码
  • java_多线程设计模式

    2018-01-16 10:54:50
    java_多线程设计模式,一部挺适合新手了解并且使用java多线程的入门教程
  • Java多线程设计模式

    2015-11-20 17:03:58
    Java多线程设计模式 + 源码 结城浩著 2005 好书
  • 图解 java多线程设计模式 源码(自己写的)
  • 以下是读者阅读《图解Java多线程设计模式》.[日].结城浩 后觉得用得比较多的几种Java多线程设计模式精简总结 一.Producer-Consumer(生产者-消费者)模式 1.几种角色理解 (1)Data:由Producer角色生成,供...

    以下是读者阅读《图解Java多线程设计模式》.[日].结城浩 后觉得用得比较多的几种Java多线程设计模式精简总结

    一.Producer-Consumer(生产者-消费者)模式

    1.几种角色理解

    (1)Data:由Producer角色生成,供Consumer角色使用

    (2)Producer(生产者):生成Data角色,并将其传递给Channer通道角色

    (3)Consumer(消费者):从Channel角色获取Data角色并使用

    (4)Channel(通道):Channel角色保管从Producer角色获取的,还会相应Consumer角色的请求,传递Data角色。为了保证安全性,Channel会对Producer和Consumer的访问执行互斥处理。

    一些处理规则:

    当Producer将Data传给Channel时,如果Channel状态不适合接收,则等待;

    当Consumer从Channel获取Data时,如果Channel没有可传递的Data,则等待;

    当存在多个Producer和Consumer时为了避免各处理相互影响,Channel应执行互斥处理

    2.为什么不直接传递而是通过中间的Channel

    为了避免Producer和Consumer之间直接调用,Producer角色将Data传递给Consumer,无需等待Consumer的处理又可以准备下一个Data角色,同理Consumer的消费也无需等待。他俩不会相互影响,提高了性能

     

    ....待更新

     

     

    ### 若对你有帮助的话,欢迎点赞!评论!转发!谢谢!

    上一篇:并发容器

    展开全文
  • 多线程设计模式.rar

    2010-07-13 14:15:25
    多线程设计模式 多线程设计模式 多线程设计模式 多线程设计模式 多线程设计模式
  • 一本学习想学习一下java多线程设计模式的书籍,希望对你有用

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 12,903
精华内容 5,161
关键字:

多线程设计模式