<?xml version="1.0" encoding="utf-8" ?><rss version="2.0"><channel><title><![CDATA[caomiao2006的专栏]]></title><description><![CDATA[]]></description><link>https://blog.youkuaiyun.com/caomiao2006</link><language>zh-cn</language><generator>https://blog.youkuaiyun.com/</generator><copyright><![CDATA[Copyright &copy; caomiao2006]]></copyright><item><title><![CDATA[代理模式 适配器模式 外观模式 装饰模式 区别 比较]]></title><link>https://blog.youkuaiyun.com/caomiao2006/article/details/53386032</link><guid>https://blog.youkuaiyun.com/caomiao2006/article/details/53386032</guid><author>caomiao2006</author><pubDate>Mon, 28 Nov 2016 22:57:39 +0800</pubDate><description><![CDATA[代理模式

1 代理模式中的原类和代理类继承同一父类；

2 原类对象与代理类对象接口相同，功能一致；

3 起到了隐藏原类的作用。




适配器模式

1 只有适配器继承目标接口；

2 讲原有类接口转换为目标代码需求的接口。




外观模式

1 是多个类的集成、统一适配。




代理模式注重的是隔离限制，关注于控制对对象的访问，让外]]></description><category></category></item><item><title><![CDATA[使用Lock，wait/notify，Semaphore三种方式实现多线程通信]]></title><link>https://blog.youkuaiyun.com/caomiao2006/article/details/53385869</link><guid>https://blog.youkuaiyun.com/caomiao2006/article/details/53385869</guid><author>caomiao2006</author><pubDate>Mon, 28 Nov 2016 22:38:20 +0800</pubDate><description><![CDATA[Java的多线程通信有Lock，wait/notify，Semaphore三种方式，以一道常见面试题来简单演示这三种多线程通信方式。

两个线程循环间隔打印指定内容，一个打印从1到52的数字，一个打印从A到Z的字母，打印输出如下：

1
2
A
3
4

B

......

51
52
Z


使用Lock实现代码如下：





[java] ]]></description><category></category></item><item><title><![CDATA[java并发（十二）饥饿和公平]]></title><link>https://blog.youkuaiyun.com/caomiao2006/article/details/53385797</link><guid>https://blog.youkuaiyun.com/caomiao2006/article/details/53385797</guid><author>caomiao2006</author><pubDate>Mon, 28 Nov 2016 22:37:24 +0800</pubDate><description><![CDATA[如果一个线程因为CPU时间全部被其他线程抢走而得不到CPU运行时间，这种状态被称之为“饥饿”。而该线程被“饥饿致死”正是因为它得不到CPU运行时间的机会。解决饥饿的方案被称之为“公平性” – 即所有线程均能公平地获得运行机会。 

下面是本文讨论的主题： 

1. Java中导致饥饿的原因： 

高优先级线程吞噬所有的低优先级线程的CPU时间。 
线程被永久堵塞在一个等待进入同步块的]]></description><category></category></item><item><title><![CDATA[ReentrantLock公平锁与非公平锁]]></title><link>https://blog.youkuaiyun.com/caomiao2006/article/details/53385669</link><guid>https://blog.youkuaiyun.com/caomiao2006/article/details/53385669</guid><author>caomiao2006</author><pubDate>Mon, 28 Nov 2016 22:28:30 +0800</pubDate><description><![CDATA[总括：   

  在Java的ReentrantLock构造函数中提供了两种锁：创建公平锁和非公平锁（默认）。代码如下：
          public ReentrantLock() {
             sync = new NonfairSync();
          }

     在公平的锁上，线程按照他们发出请求的顺序获取锁，但在非公平锁上，则允许‘插队’]]></description><category></category></item><item><title><![CDATA[Java并发编程：线程间协作的两种方式：wait、notify和Condition]]></title><link>https://blog.youkuaiyun.com/caomiao2006/article/details/53385602</link><guid>https://blog.youkuaiyun.com/caomiao2006/article/details/53385602</guid><author>caomiao2006</author><pubDate>Mon, 28 Nov 2016 22:20:14 +0800</pubDate><description><![CDATA[在前面我们将了很多关于同步的问题，然而在现实中，需要线程之间的协作。比如说最经典的生产者-消费者模型：当队列满时，生产者需要等待队列有空间才能继续往里面放入商品，而在等待的期间内，生产者必须释放对临界资源（即队列）的占用权。因为生产者如果不释放对临界资源的占用权，那么消费者就无法消费队列中的商品，就不会让队列有空间，那么生产者就会一直无限等待下去。因此，一般情况下，当队列满时，会让生产者交出对临界]]></description><category></category></item><item><title><![CDATA[Thread的中断机制(interrupt)]]></title><link>https://blog.youkuaiyun.com/caomiao2006/article/details/53385477</link><guid>https://blog.youkuaiyun.com/caomiao2006/article/details/53385477</guid><author>caomiao2006</author><pubDate>Mon, 28 Nov 2016 22:07:39 +0800</pubDate><description><![CDATA[先看收集了别人的文章，全面的了解下java的中断：

中断线程

线程的thread.interrupt()方法是中断线程，将会设置该线程的中断状态位，即设置为true，中断的结果线程是死亡、还是等待新的任务或是继续运行至下一步，就取决于这个程序本身。线程会不时地检测这个中断标示位，以判断线程是否应该被中断（中断标示值是否为true）。它并不像stop方法那样会中断一个正在运行的线程。
]]></description><category></category></item><item><title><![CDATA[JAVA多线程之wait/notify]]></title><link>https://blog.youkuaiyun.com/caomiao2006/article/details/53385350</link><guid>https://blog.youkuaiyun.com/caomiao2006/article/details/53385350</guid><author>caomiao2006</author><pubDate>Mon, 28 Nov 2016 21:55:51 +0800</pubDate><description><![CDATA[本文主要学习JAVA多线程中的 wait()方法 与 notify()/notifyAll()方法的用法。

①wait() 与 notify/notifyAll 方法必须在同步代码块中使用

②wait() 与  notify/notifyAll() 的执行过程

③中断 调用wait()方法进入等待队列的 线程

④notify 通知的顺序不能错

⑤多线程中测试某个条件的]]></description><category></category></item><item><title><![CDATA[Java wait() notify()方法使用实例讲解]]></title><link>https://blog.youkuaiyun.com/caomiao2006/article/details/53385297</link><guid>https://blog.youkuaiyun.com/caomiao2006/article/details/53385297</guid><author>caomiao2006</author><pubDate>Mon, 28 Nov 2016 21:50:48 +0800</pubDate><description><![CDATA[1）wait()、notify()和notifyAll()方法是本地方法，并且为final方法，无法被重写。

　　2）调用某个对象的wait()方法能让当前线程阻塞，并且当前线程必须拥有此对象的monitor（即锁，或者叫管程）

　　3）调用某个对象的notify()方法能够唤醒一个正在等待这个对象的monitor的线程，如果有多个线程都在等待这个对象的monitor，则只能唤醒其中一]]></description><category></category></item><item><title><![CDATA[如何在 Java 中正确使用 wait, notify 和 notifyAll]]></title><link>https://blog.youkuaiyun.com/caomiao2006/article/details/53385268</link><guid>https://blog.youkuaiyun.com/caomiao2006/article/details/53385268</guid><author>caomiao2006</author><pubDate>Mon, 28 Nov 2016 21:46:59 +0800</pubDate><description><![CDATA[wait, notify 和 notifyAll，这些在多线程中被经常用到的保留关键字，在实际开发的时候很多时候却并没有被大家重视。本文对这些关键字的使用进行了描述。

在 Java 中可以用 wait、notify 和 notifyAll 来实现线程间的通信。。举个例子，如果你的Java程序中有两个线程——即生产者和消费者，那么生产者可以通知消费者，让消费者开始消耗数据，因为队列缓 冲区中有]]></description><category></category></item><item><title><![CDATA[Java静态方法不具有多态性详解]]></title><link>https://blog.youkuaiyun.com/caomiao2006/article/details/53385047</link><guid>https://blog.youkuaiyun.com/caomiao2006/article/details/53385047</guid><author>caomiao2006</author><pubDate>Mon, 28 Nov 2016 21:25:15 +0800</pubDate><description><![CDATA[动态绑定机制使得基类的引用能够指向正确的子类对象，从而使得面向基类编程成为可能。

然而动态绑定在以下两种情况会失效。

1、基类方法是private或final修饰的

这个很好理解，因为private说明该方法对子类是不可见的，子类再写一个同名的方法并不是对父类方法进行复写(Override)，而是重新生成一个新的方法，也就不存在多态的问题了。同理也可以解释final，因为方法同样]]></description><category></category></item><item><title><![CDATA[理解java多态的面试题（理解加粗的样例解析部分）]]></title><link>https://blog.youkuaiyun.com/caomiao2006/article/details/53384988</link><guid>https://blog.youkuaiyun.com/caomiao2006/article/details/53384988</guid><author>caomiao2006</author><pubDate>Mon, 28 Nov 2016 21:22:07 +0800</pubDate><description><![CDATA[class A{
    public String show(D obj){
           return ("A and D");
    } 
    public String show(A obj){

           return ("A and A");
    } 
}   

class B extends A{
    public String show(B ob]]></description><category></category></item><item><title><![CDATA[多态经典面试题解析]]></title><link>https://blog.youkuaiyun.com/caomiao2006/article/details/53384971</link><guid>https://blog.youkuaiyun.com/caomiao2006/article/details/53384971</guid><author>caomiao2006</author><pubDate>Mon, 28 Nov 2016 21:18:53 +0800</pubDate><description><![CDATA[多态经典面试题

已知类ABCD，B继承于A，C和D继承于B，具体如下





[html] view
 plain copy






public class A {  
    public void print(A a){  
        System.out.println("A and A");  
    }  
      
   ]]></description><category></category></item><item><title><![CDATA[jvm住内存与工作内存，内存模型反映的java多线程问题]]></title><link>https://blog.youkuaiyun.com/caomiao2006/article/details/53384934</link><guid>https://blog.youkuaiyun.com/caomiao2006/article/details/53384934</guid><author>caomiao2006</author><pubDate>Mon, 28 Nov 2016 21:16:38 +0800</pubDate><description><![CDATA[找了多篇文章,自己将重点以及可以让人深入理解jvm以及多线程的知识做总结,作为自己的学习笔记:



一、jvm主内存与工作内存

    首先，JVM将内存组织为主内存和工作内存两个部分。主内存中主要包括本地方法区和堆。每个线程都有一个工作内存，工作内存中主要包括两个部分，一个是属于该线程的栈和对主存部分变量拷贝的寄存器。  


1.所有的变量都存储在主内存中(虚拟机内存的一]]></description><category></category></item><item><title><![CDATA[【Java线程】Java内存模型总结]]></title><link>https://blog.youkuaiyun.com/caomiao2006/article/details/53384905</link><guid>https://blog.youkuaiyun.com/caomiao2006/article/details/53384905</guid><author>caomiao2006</author><pubDate>Mon, 28 Nov 2016 21:14:19 +0800</pubDate><description><![CDATA[学习资料：http://www.infoq.com/cn/articles/Java-memory-model-1




Java的并发采用的是共享内存模型（而非消息传递模型），线程之间共享程序的公共状态，线程之间通过写-读内存中的公共状态来隐式进行通信。多个线程之间是不能直接传递数据交互的，它们之间的交互只能通过共享变量来实现

同步是显式进行的。程序员必须显式指定某个方法或某段]]></description><category></category></item><item><title><![CDATA[java线程内存模型,线程、工作内存、主内存]]></title><link>https://blog.youkuaiyun.com/caomiao2006/article/details/53384873</link><guid>https://blog.youkuaiyun.com/caomiao2006/article/details/53384873</guid><author>caomiao2006</author><pubDate>Mon, 28 Nov 2016 21:09:48 +0800</pubDate><description><![CDATA[java线程内存模型

线程、工作内存、主内存三者之间的交互关系图：



 

key edeas

所有线程共享主内存

每个线程有自己的工作内存

refreshing local memory to/from main memory must  comply to JMM rules


 

产生线程安全的原因

线程的working memor]]></description><category></category></item><item><title><![CDATA[JSP 自定义标签]]></title><link>https://blog.youkuaiyun.com/caomiao2006/article/details/53384821</link><guid>https://blog.youkuaiyun.com/caomiao2006/article/details/53384821</guid><author>caomiao2006</author><pubDate>Mon, 28 Nov 2016 21:04:57 +0800</pubDate><description><![CDATA[自定义标签是用户定义的JSP语言元素。当JSP页面包含一个自定义标签时将被转化为servlet，标签转化为对被 称为tag handler的对象的操作，即当servlet执行时Web container调用那些操作。

JSP标签扩展可以让你创建新的标签并且可以直接插入到一个JSP页面。 JSP 2.0规范中引入Simple Tag Handlers来编写这些自定义标记。

你可以继承Si]]></description><category></category></item><item><title><![CDATA[数据库分库分表(sharding)系列(五) 一种支持自由规划无须数据迁移和修改路由代码的Sharding扩容方案]]></title><link>https://blog.youkuaiyun.com/caomiao2006/article/details/53313932</link><guid>https://blog.youkuaiyun.com/caomiao2006/article/details/53313932</guid><author>caomiao2006</author><pubDate>Wed, 23 Nov 2016 23:24:43 +0800</pubDate><description><![CDATA[作为一种数据存储层面上的水平伸缩解决方案，数据库Sharding技术由来已久，很多海量数据系统在其发展演进的历程中都曾经历过分库分表的Sharding改造阶段。简单地说，Sharding就是将原来单一数据库按照一定的规则进行切分，把数据分散到多台物理机（我们称之为Shard)上存储，从而突破单机限制，使系统能以Scale-Out的方式应对不断上涨的海量数据，但是这种切分对上层应用来说是透明的，多个]]></description><category></category></item><item><title><![CDATA[缓存算法（页面置换算法）-FIFO、LFU、LRU]]></title><link>https://blog.youkuaiyun.com/caomiao2006/article/details/53313853</link><guid>https://blog.youkuaiyun.com/caomiao2006/article/details/53313853</guid><author>caomiao2006</author><pubDate>Wed, 23 Nov 2016 23:10:42 +0800</pubDate><description><![CDATA[1. FIFO -- 先进先出

如果一个数据最先进入缓存中，则应该最早淘汰掉。也就是说，当缓存满的时候，应当把最先进入缓存的数据给淘汰掉。

实现：

利用一个双向链表保存数据，当来了新的数据之后便添加到链表末尾，如果Cache存满数据，则把链表头部数据删除，然后把新的数据添加到链表末尾。在访问数据的时候，如果在Cache中存在该数据的话，则返回对应的value值；否则返回-1。如果]]></description><category></category></item><item><title><![CDATA[支付系统对账算法优化方案]]></title><link>https://blog.youkuaiyun.com/caomiao2006/article/details/53296039</link><guid>https://blog.youkuaiyun.com/caomiao2006/article/details/53296039</guid><author>caomiao2006</author><pubDate>Wed, 23 Nov 2016 00:06:32 +0800</pubDate><description><![CDATA[一、目前对账的算法：

1、从上游渠道（银行、银联等金融机构）获取对账文件，程序逐行解析入库

2、在存储过程中，以上游对账文件的表为基准，程序逐行读取并与我们系统的交易记录/账务记录（有账务系统情况下，合理方案应该是于账务记录）对比，查找出差异记录。

3、以我们系统的交易记录/账务记录为基准，程序逐行读取与上游对账文件对比，查找出差异记录

二、目前对账算法问题：

1、使]]></description><category></category></item><item><title><![CDATA[递归算法转换为非递归算法]]></title><link>https://blog.youkuaiyun.com/caomiao2006/article/details/53239862</link><guid>https://blog.youkuaiyun.com/caomiao2006/article/details/53239862</guid><author>caomiao2006</author><pubDate>Sun, 20 Nov 2016 12:02:28 +0800</pubDate><description><![CDATA[递归算法实际上是一种分而治之的方法，它把复杂问题分解为简单问题来求解。对于某些复杂问题(例如hanio塔问题)，递归算法是一种自然且合乎逻辑的解决问题的方式，但是递归算法的执行效率通常比较差。因此，在求解某些问题时，常采用递归算法来分析问题，用非递归算法来求解问题；另外，有些程序设计语言不支持递归，这就需要把递归算法转换为非递归算法。
    将递归算法转换为非递归算法有两种方法，一种是直接求值]]></description><category></category></item></channel></rss>