<?xml version="1.0" encoding="utf-8" ?><rss version="2.0"><channel><title><![CDATA[沉默]]></title><description><![CDATA[追求永远不止，你才能成功！]]></description><link>https://blog.youkuaiyun.com/andy_gx</link><language>zh-cn</language><generator>https://blog.youkuaiyun.com/</generator><copyright><![CDATA[Copyright &copy; andy_gx]]></copyright><item><title><![CDATA[跟着实例学习设计模式（9）-桥接模式bridge（结构型）]]></title><link>https://blog.youkuaiyun.com/andy_gx/article/details/46885033</link><guid>https://blog.youkuaiyun.com/andy_gx/article/details/46885033</guid><author>andy_gx</author><pubDate>Wed, 15 Jul 2015 00:13:59 +0800</pubDate><description><![CDATA[桥接模式属于结构型设计模式。
设计意图：将抽象部分与实现部分分离，使它们都可以独立的变化。
一看到设计意图，大家可能有些发懵，我们看到的继承和接口不都是抽象和实现分离的吗？尤其是接口和抽象类都是这样的实现啊！那怎么还有这么个桥接的分离呢？
我们先来看个例子。
例如：汽车品牌内置导航仪，我们希望实现，每个品牌的导航仪都可以在任何一个牌子的汽车上安装并启动。
汽车品牌有两个：宝马、奔驰。]]></description><category></category></item><item><title><![CDATA[跟着实例学习设计模式（8）-适配器模式adapter（结构型）]]></title><link>https://blog.youkuaiyun.com/andy_gx/article/details/46866917</link><guid>https://blog.youkuaiyun.com/andy_gx/article/details/46866917</guid><author>andy_gx</author><pubDate>Mon, 13 Jul 2015 20:19:24 +0800</pubDate><description><![CDATA[适配器模式属于结构型设计模式
设计意图：将一个类的接口转换成客户希望的另外一个接口。A d a p t e r模式使得原本由于接口不兼容而不能一起工作的那些类可以一起工作。
该模式正如名字一样适配器，就是为了能使之前的老接口可以焕发青春的模式，使用一个新的接口把已经存在的接口发布出去。

这样的设计模式，我们一版在企业信息化升级时会经常使用，有些企业存在的老接口经常不能对外接收数据，而重构]]></description><category></category></item><item><title><![CDATA[跟着实例学习设计模式（7）-原型模式prototype（创建型）]]></title><link>https://blog.youkuaiyun.com/andy_gx/article/details/46854395</link><guid>https://blog.youkuaiyun.com/andy_gx/article/details/46854395</guid><author>andy_gx</author><pubDate>Sun, 12 Jul 2015 23:18:04 +0800</pubDate><description><![CDATA[原型模式是创建型模式。
设计意图：用原型实例指定创建对象的类型，并通过拷贝这个原型来创建新的对象。
我们使用构建简历的例子的类图来说明原型模式。

类图：



原型模式主要用于对象的复制，它的核心是就是类图中的原型类Prototype。这里我们定义了一个抽象的原型接口，声明了用于clone自己的方法，这里我们已创建简历为具体原型类，Prototype类需要具备以下两个条件：]]></description><category></category></item><item><title><![CDATA[跟着实例学习设计模式（6）-生成器模式builder（创建型）]]></title><link>https://blog.youkuaiyun.com/andy_gx/article/details/46852607</link><guid>https://blog.youkuaiyun.com/andy_gx/article/details/46852607</guid><author>andy_gx</author><pubDate>Sun, 12 Jul 2015 20:56:37 +0800</pubDate><description><![CDATA[生成器模式是创建型设计模式。
设计意图：将一个复杂的类表示与其构造相分离，使得相同的构建过程能够得出不同的表示。
实例类图：


IVehicleBuilder：抽象建造者，为创建一个Vehicle对象并创建它的相关部件指定的抽象接口，把产品的生产过程分解为不同的步骤，从而使具体的建造者在具体的建造步骤上具有更多弹性，从而创造出不同表示的产品。（这里就是小车和卡车）
CarBuilde]]></description><category></category></item><item><title><![CDATA[跟着实例学习设计模式（5）-工厂方法 、抽象工厂的区别]]></title><link>https://blog.youkuaiyun.com/andy_gx/article/details/46849379</link><guid>https://blog.youkuaiyun.com/andy_gx/article/details/46849379</guid><author>andy_gx</author><pubDate>Sun, 12 Jul 2015 13:29:43 +0800</pubDate><description><![CDATA[工厂方法和抽象工厂都属于工厂模式，那么它们到底有什么区别呢？让我们来比较一下，首先我们从工厂接口的角度来分析一下。
工厂方法：
                工厂方法是创建一个系列的产品的同分类产品不同功能的创建接口，并且同分类不同功能的产品返回的产出物还得是相同的。例如：汽车的发动机的制造就可以使用工厂方法，]]></description><category></category></item><item><title><![CDATA[跟着实例学习设计模式（4）-抽象工厂（创建型）]]></title><link>https://blog.youkuaiyun.com/andy_gx/article/details/46848535</link><guid>https://blog.youkuaiyun.com/andy_gx/article/details/46848535</guid><author>andy_gx</author><pubDate>Sun, 12 Jul 2015 11:37:38 +0800</pubDate><description><![CDATA[抽象工厂属于创建型设计模式
设计意图：提供一个接口，可以创建一系列相关或相互依赖的对象，而无须指定它们具体的类。
光看设计意图有些抽象，不好理解，让我们来看一下实例类图，结合类图我们再做具体的解释，相信会让大家豁然开朗的。我们以生产汽车为例，我们生产的汽车分两个系列，小车、卡车，每个系列汽车都有发动机和油箱。
上图：

IAbstrcatFactory：抽象工厂接口，声明创建抽象产品的方]]></description><category></category></item><item><title><![CDATA[跟着实例学习设计模式（3）-工厂方法（创建型）]]></title><link>https://blog.youkuaiyun.com/andy_gx/article/details/46821951</link><guid>https://blog.youkuaiyun.com/andy_gx/article/details/46821951</guid><author>andy_gx</author><pubDate>Fri, 10 Jul 2015 12:16:52 +0800</pubDate><description><![CDATA[工厂方法属于创建型设计模式。

设计意图：定义一个用于创建对象的接口，让子类决定实例化哪一个类，工厂方法使一个类的实例化延迟到其子类。
       静态工厂使用面向对象的方式，有效的解决了增加新产品给客户端和实现类带来的代码修改问题，封装了创建过程，减低了增加新产品带来的代码修改错误，但是新增功能需要修改客户端代码和工厂创建类的判断逻辑，这样的设计违背了开放-封闭原则，对扩展开放，对修改封]]></description><category></category></item><item><title><![CDATA[跟着实例学习设计模式（2）-静态工厂（创建型）]]></title><link>https://blog.youkuaiyun.com/andy_gx/article/details/46820945</link><guid>https://blog.youkuaiyun.com/andy_gx/article/details/46820945</guid><author>andy_gx</author><pubDate>Thu, 09 Jul 2015 21:22:49 +0800</pubDate><description><![CDATA[静态工厂设计模式是创建型设计模式。
设计意图：实例化出我们需要的类对象，这些对象可以实现不同的功能，也可能只实现一个功能！
类图关系：

通过类图关系我们可以看到静态工厂负责创建OperationFather类的对象，我们来看一下实例代码。
我们是想实现一个计算器，计算器的功能暂时有加法、减法功能，以后可能随时增加新的功能如乘法、除法等。如果使用一般的做法，实际上我们写一个类就可以实现。]]></description><category></category></item><item><title><![CDATA[跟着实例学习设计模式（1）-单例模式（创建型）]]></title><link>https://blog.youkuaiyun.com/andy_gx/article/details/46767757</link><guid>https://blog.youkuaiyun.com/andy_gx/article/details/46767757</guid><author>andy_gx</author><pubDate>Mon, 06 Jul 2015 00:35:25 +0800</pubDate><description><![CDATA[单例模式属于创建型设计模式。
  设计意图：保证一个类只有一个实例，并提供一个访问它的全局访问点。
  单例模式根据单例，一种是懒汉式单例。饿汉式单例在单例类被加载时候，就实例化一个对象交给自己的引用；而懒汉式在调用取得实例方法的时候才会实例化对象。
  代码如下：
  懒汉式：
package com.home.singleton;

/**
 * 饿汉式单例]]></description><category></category></item><item><title><![CDATA[跟着实例学习java多线程10-定时任务实例Quartz等]]></title><link>https://blog.youkuaiyun.com/andy_gx/article/details/43588001</link><guid>https://blog.youkuaiyun.com/andy_gx/article/details/43588001</guid><author>andy_gx</author><pubDate>Sat, 07 Feb 2015 01:35:13 +0800</pubDate><description><![CDATA[定时任务是我们经常遇到的业务场景，我们有很多的功能都需要这样的技术来实现，例如：定时获取一些数据push出去，定时处理一些清理任务，定时检查某个值等。那么我们该怎么实现，在实现中又该注意一些什么？
定时任务就是另开一个线程来执行，其实也是并发的一类，大家可能不好理解，说定时不就是到时间执行一下，怎么还会产生并发，这里主要是看两个指标，一是看执行频率，二是看每次执行的时间，如果执行频率高并且执行任]]></description><category></category></item><item><title><![CDATA[跟着实例学习java多线程9-并发容器]]></title><link>https://blog.youkuaiyun.com/andy_gx/article/details/43496043</link><guid>https://blog.youkuaiyun.com/andy_gx/article/details/43496043</guid><author>andy_gx</author><pubDate>Wed, 04 Feb 2015 23:19:11 +0800</pubDate><description><![CDATA[并发容器专门为并发而生的，最常用的就是ConcurrentHashMap、BlockingQueue了，这两个并发容器是我们比较常用的，前者取代同步Map提供了很好的并发性，后者提供了一种生产者与消费者模式的队列，ConcurrentHashMap官方介绍说了，它并没有提供在Map上加锁独占访问，这说明什么？这说明它在原子性上是没有保障的，但是它在内存可见性上是完全保证的，也就说如果你需要使用独立]]></description><category></category></item><item><title><![CDATA[跟着实例学习java多线程8-同步容器类的问题]]></title><link>https://blog.youkuaiyun.com/andy_gx/article/details/43459359</link><guid>https://blog.youkuaiyun.com/andy_gx/article/details/43459359</guid><author>andy_gx</author><pubDate>Wed, 04 Feb 2015 01:35:40 +0800</pubDate><description><![CDATA[我们知道java有很多线程安全的容器类，我们也知道如果把可变状态的管理交给这些线程安全类来管理就可以实现线程安全，但是我们还可能遇到不可想象的问题。
例如：
package com.home.thread.thread8;

import java.util.Vector;

/**
 * @author gaoxu
 * 实践出真知！
 */
public class VectorQueue]]></description><category></category></item><item><title><![CDATA[跟着实例学习java多线程7-对象的组合发布]]></title><link>https://blog.youkuaiyun.com/andy_gx/article/details/43422913</link><guid>https://blog.youkuaiyun.com/andy_gx/article/details/43422913</guid><author>andy_gx</author><pubDate>Tue, 03 Feb 2015 00:21:46 +0800</pubDate><description><![CDATA[我们学习线程安全与同步的知识目的就是要实现一些可复用组件或编写出更大的程序。
java中类是对象抽象，那么怎么实现一个线程安全类是我们必须要知道的并正确使用的技术。
在设计线程安全类的过程中，需要包含以下三个基本元素：
       找出构成对象状态的所有变量。
       找出约束状态变量的不变性条件。
       建立对象状态的并发访问管理策略。
package com.hom]]></description><category></category></item><item><title><![CDATA[跟着实例学习java多线程6-如何正确发布线程安全的对象]]></title><link>https://blog.youkuaiyun.com/andy_gx/article/details/43387675</link><guid>https://blog.youkuaiyun.com/andy_gx/article/details/43387675</guid><author>andy_gx</author><pubDate>Mon, 02 Feb 2015 02:41:25 +0800</pubDate><description><![CDATA[我们前面所讲的一切其实都只是为了一个目标那就是能正确发布一个线程安全的对象。
一：线程封闭
这个很好理解如果一个变量是在一个线程中完成的状态改变，那么这个变量肯定是线程安全的。
我们常使用的是栈封闭和ThreadLocal类。
在java运行时内存区中有一个虚拟机栈，栈封闭说的就是这个栈，这个栈是线程私有的，它的生命周期与线程相同。虚拟机栈描述描述的是java方法执行的内存模型：每个方法被]]></description><category></category></item><item><title><![CDATA[跟着实例学习java多线程5-初识volatile变量]]></title><link>https://blog.youkuaiyun.com/andy_gx/article/details/43376759</link><guid>https://blog.youkuaiyun.com/andy_gx/article/details/43376759</guid><author>andy_gx</author><pubDate>Sun, 01 Feb 2015 23:01:57 +0800</pubDate><description><![CDATA[同步机制可以保证原子操作和内存可见性，但是同步机制对变量的访问性能是我们不得不考虑的问题，java语言提供了一种弱同步机制，volatile变量。
它的原理大致是这样的，当把变量声明为volatile类型后，编译器与运行时都会注意到这个变量是共享的，因此不会将变量上的操作与其他内存操作一起重排序。volatile变量不会被缓存在寄存器或者对其他处理器不可见的地方，因此在读取volatile类型的]]></description><category></category></item><item><title><![CDATA[跟着实例学习java多线程4-内存可见性]]></title><link>https://blog.youkuaiyun.com/andy_gx/article/details/43122053</link><guid>https://blog.youkuaiyun.com/andy_gx/article/details/43122053</guid><author>andy_gx</author><pubDate>Sun, 01 Feb 2015 14:59:51 +0800</pubDate><description><![CDATA[前三篇我们主要说了多线程访问共享可变状态时需要进行正确的同步处理，保证同一时刻只有一个线程访问相同的数据，我们使用synchronized关键字来实现原子性操作。今天我们在来认识一下同步的另一个重要方面：内存可见性，这个概念其实很好理解，就是保证在同一个时刻，共享可变状态对访问它的线程呈现出自己最新的状态变化。
我们经常遇到的情景是这样的，一个全局变量计数器，一个线程负责更新该数值，另一些线程获]]></description><category></category></item><item><title><![CDATA[跟着实例学习java多线程3-synchronized的多种写法有何区别？]]></title><link>https://blog.youkuaiyun.com/andy_gx/article/details/42932913</link><guid>https://blog.youkuaiyun.com/andy_gx/article/details/42932913</guid><author>andy_gx</author><pubDate>Tue, 20 Jan 2015 23:29:59 +0800</pubDate><description><![CDATA[同步代码块是一种有效实现操作原子性的方法，上一章我们讲了一些同步的原子操作的基础。
现在我们回忆一下上一章的两个问题。
1：不同的synchronized的写法有什么区别，又该怎么写创建线程的代码呢？
以class实例对象作为锁的写法
写法1
package com.home.thread;

/**
 * @author gaoxu
 * 
 */
public class SafeT]]></description><category></category></item><item><title><![CDATA[跟着实例学习java多线程2-synchronized锁住的是对象还是代码]]></title><link>https://blog.youkuaiyun.com/andy_gx/article/details/42834247</link><guid>https://blog.youkuaiyun.com/andy_gx/article/details/42834247</guid><author>andy_gx</author><pubDate>Sun, 18 Jan 2015 15:24:06 +0800</pubDate><description><![CDATA[上一篇文章我们通过一个实例来说明了并发编程为什么要做同步处理，下面我们再来巩固一下。
       对象如果拥有可变状态的变量，并且被多线程访问，那么这个时候我们要对可变状态变量的状态改变做原子操作处理。
       锁机制是保证这样的操作的一个有效的方法，它可以保证变量的状态在被更新时是在一个原子操作中进行的。
       java提供了一种内置锁机制来支持原子性：同步代码块（Sync]]></description><category></category></item><item><title><![CDATA[跟着实例学习java多线程1-为什么使用？]]></title><link>https://blog.youkuaiyun.com/andy_gx/article/details/42804273</link><guid>https://blog.youkuaiyun.com/andy_gx/article/details/42804273</guid><author>andy_gx</author><pubDate>Sat, 17 Jan 2015 23:38:38 +0800</pubDate><description><![CDATA[如今的互联网时代、移动互联网时代，我们开发的所有的系统和网站以及服务都要求支持高负载、大并发，要求的是效率，串行的代码已经不能满足我们对执行效率的需求，当然也会白瞎了如今这么好的硬件，现在是个台式机至少都是2核、4核的了，更别说32核、64核的高端服务器，要想充分利用cpu资源那就不能让他们闲着，所以多线程并发也就越来越重要了。
线程有很多优势：
1、提高多处理器的利用效率
2、简化业务功能]]></description><category></category></item><item><title><![CDATA[Solr学习笔记-在Tomcat上部署运行Solr]]></title><link>https://blog.youkuaiyun.com/andy_gx/article/details/38787907</link><guid>https://blog.youkuaiyun.com/andy_gx/article/details/38787907</guid><author>andy_gx</author><pubDate>Sun, 24 Aug 2014 02:09:32 +0800</pubDate><description><![CDATA[上一篇我们初识了Solr并且学习了Jetty的启动方式，查看了Solr的管理界面，这一篇我们来实现在Tomcat上部署运行Solr。
部署环境：
                window7
                jdk1.6.0_14
                Solr-4.7.2
                tomcat-6.0.37
Solr的安装配置Sol]]></description><category></category></item></channel></rss>