ivaneye.com

语言和并发-01启动线程

概述

本系列文章意在比较Java与Clojure在线程实现上的区别！

Java的线程主要基于锁机制，而Clojure主要模拟了数据库事务操作，所谓的STM(软事务模型)。主要从代码层面给出两者的区别，孰优孰劣请自行判断！

启动线程

Java代码

package concurrent;
import java.util.concurrent.*;
/**
 * Created by ivan on 15-2-22.
 * Java启动线程
 */
public class Start {
    public static void main(String[] args) throws InterruptedException, ExecutionException {
        //实现Runnable接口，需要通过一个Thread实例来启动线程
        new Thread(new A()).start();
        //继承Thread类，直接通过自身来启动线程
        new B().start();
        //JDK1.5开始，可以通过Executor来执行线程.效果和上面没有区别
        ExecutorService e = Executors.newCachedThreadPool();
        e.execute(new A());
        e.execute(new B());
        //Callable需要submit,返回Future
        Future<String> f = e.submit(new C());
        //get方法是个阻塞方法
        System.out.println("Future f = " + f.get());
        e.shutdown();
    }
}

语言与模式-23迭代器模式

意图

提供一种方法顺序访问一个聚合对象中各个元素, 而又不需暴露该对象的内部表示。

适用性

Java实现

Java提供了Iterable接口，直接实现此接口即可!

public class AList implements Iterable{
    ...
    private int idx;
    public static void main(String[] args) {
        AList list = new AList();
        list.add(1);
        list.add(2);
        list.add(3);
        for(Object o : list){
            System.out.println(o);
        }
    }
    @Override
    public Iterator iterator() {
        return new Iterator() {
            @Override
            public boolean hasNext() {
                return idx < length;
            }
            @Override
            public Object next() {
                return arr[idx++];
            }
        };
    }
}

语言与模式-22访问者模式

意图

表示一个作用于某对象结构中的各元素的操作。它使你可以在不改变各元素的类的前提下定义作用于这些元素的新操作。

适用性

Java实现

//访问者
public interface Visitor {
    public void visit(Park park);
    public void visit(ParkA parkA);
    public void visit(ParkB parkB);
}

//清洁工A,负责parkA的卫生情况
public class VisitorA implements Visitor {
    public void visit(Park park) {
    }
    public void visit(ParkA parkA) {
        System.out.println("清洁工A:完成公园" + parkA.getName()+ "的卫生");
    }
    public void visit(ParkB parkB) {
    }
}

语言与模式-21解释器模式

意图

给定一个语言，定义它的文法的一种表示，并定义一个解释器，这个解释器使用该表示来解释语言中的句子。

适用性

Java实现

抽象表达式角色

public abstract class Expression {
    /**
     * 以环境为准，本方法解释给定的任何一个表达式
     */
    public abstract boolean interpret(Context ctx);
    /**
     * 检验两个表达式在结构上是否相同
     */
    public abstract boolean equals(Object obj);
    /**
     * 返回表达式的hash code
     */
    public abstract int hashCode();
    /**
     * 将表达式转换成字符串
     */
    public abstract String toString();
}

语言与模式-20中介者模式

意图

用一个中介对象来封装一系列的对象交互。中介者使各对象不需要显式地相互引用，从而使其耦合松散，而且可以独立地改变它们之间的交互。

适用性

Java实现

//抽象同事类
public abstract class Person {
    // 维持一个抽象中介者的引用
    protected Mediator mediator;
    protected String name;
    public Person(String name, Mediator mediator){
        this.mediator = mediator;
        this.name = name;
    }
    /**
     * 设置中介者对象
     * @param mediator
     */
    public void setMediator(Mediator mediator){
        this.mediator = mediator;
    }
    /**
     * 向中介 发送消息
     */
    protected abstract void sendMessage(String msg);
    /**
     * 从中介 获取消息
     */
    protected abstract void getMessage(String msg);
}

语言与模式-19策略模式

意图

定义一系列的算法,把它们一个个封装起来, 并且使它们可相互替换。本模式使得算法可独立于使用它的客户而变化。

适用性

Java实现

public class Context {
    //持有一个具体策略的对象
    private Strategy strategy;
    /**
     * 构造函数，传入一个具体策略对象
     * @param strategy    具体策略对象
     */
    public Context(Strategy strategy){
        this.strategy = strategy;
    }
    /**
     * 策略方法
     */
    public void contextInterface(){
        strategy.strategyInterface();
    }
}

语言与模式-18状态模式

意图

允许一个对象在其内部状态改变时改变它的行为。对象看起来似乎修改了它的类。

适用性

Java实现

public class Order{
     private State unPayState;
     private State payedState;
     private State sendState;
     private State doneState;    //四种状态，四种类,对应的get,set方法省略
     private State state = unPayState;     //当前状态
     public Order(){
        unPayState = new UnPayState(this);
        payedState = new PayedState(this);            //传入Order对象，为了修改Order的状态
        ...
     }
     public void pay(){
          state.pay();
     }
     public void send(){
          state.send();
     }
     ....
}