Node.js 基础原理编程

Node.js 基础原理编程

第1题 Java实现两个线程读写队列

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.concurrent.LinkedBlockingDeque;
public class TwoThreads {
     //Define a queue
    private static LinkedBlockingDeque<String> queue=new LinkedBlockingDeque<String>();
     //write data to queue     
    public static class Writer extends Thread {
        public void run(){
           BufferedReader reader=new BufferedReader(new InputStreamReader(System.in));
           String str=null;
           while(true){
               try {
                   str=reader.readLine();
                   queue.put(str);
                   //if input "exit" in Console, the Application exits.
                   if("exit".equals(str)){ 
                      break;
                  }
              } catch (InterruptedException | IOException e) {
                  e.printStackTrace();
              }    
          } 
        }
    }
    //read data from queue
    public static class Reader extends Thread {
        public void run(){
            String str=null;
                while(true){
                    try {
                        str=queue.take();
                        System.out.println(str);
                        if("exit".equals(str)){
                            break;
                        }
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
  	}
 
    public static void main(String[] args) throws IOException {
        Writer writer = new Writer();
        Reader reader = new Reader();
        writer.start();
        reader.start();
    }
}

第2题 用wait和notify改写上述代码

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.concurrent.LinkedBlockingDeque;
public class TwoThreads {
    //Define a queue
    private static LinkedBlockingDeque<String> queue=new LinkedBlockingDeque<String>();
    //write data to queue
    class Writer extends Thread {
        public void run(){
            try {
                BufferedReader reader=new BufferedReader(new InputStreamReader(System.in));
                String str=null; 			
                while(true){  
                    str=reader.readLine();    				
                    queue.put(str);     				
                    //if input "exit" in Console, the Application exits.    				
                    if("exit".equals(str)){     					
                        break;
                    }
                    synchronized (queue) {
                        queue.notify(); 
                    }  
                }   
    		reader.close();
    	    }catch (InterruptedException | IOException e) {
    		e.printStackTrace();
    		}
    	}
    }
    //read data from queue
    class Reader extends Thread {
        public void run(){
            String str=null;
            while(true){
                if(queue.size()>0) {
                    str=queue.poll();
                    System.out.println(str);
                    if("exit".equals(str)){
                        break;
                        }
                }else {
                    synchronized (queue) {
                        try {
                            queue.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }
            }
        }
    }

    public static void main(String[] args) throws IOException { 
        TwoThreads twothread = new TwoThreads();
        Writer writer = twothread.new Writer();
        Reader reader = twothread.new Reader();
        writer.start();
        reader.start();
    }    
}    

第3题 画出命令模式的静态类图

第4题 使用命令模式改写上述程序，使之实现事件的回调

// 基于Command模式编程
import java.util.concurrent.LinkedBlockingDeque;

public class Client {
   LinkedBlockingDeque<String> queue=new LinkedBlockingDeque<String>();
   Receiver receiverWriter = new ConcreteReceiverWriter();
   Receiver receiverWriter = new ConcreteReceiverWriter();
   Receiver receiverReader = new ConcreteReceiverReader();
   
   Invoker invoker = new Invoker();
   invoker.setCommand(new ConcreteCommandWriter(receiverWriter));
   invoker.action(queue);
   invoker.setCommand(new ConcreteCommandReader(receiverReader));
   invoker.action(queue);

import java.util.concurrent.LinkedBlockingDeque;

public abstract class Command {
    public abstract void execute(LinkedBlockingDeque<String> queue);
}

import java.util.concurrent.LinkedBlockingDeque;

public class ConcreteCommandReader extends Command{
    private Receiver receiver;
    public ConcreteCommandReader(Receiver receiver) {
    	this.receiver = receiver;
    }
    @Override
    public void execute(LinkedBlockingDeque<String> queue) {
	receiver.receiver(queue);
    }
}

import java.util.concurrent.LinkedBlockingDeque;
public class ConcreteCommandWriter extends Command{
    private Receiver receiver; 
    public ConcreteCommandWriter(Receiver receiver) {
    this.receiver = receiver;
    }
     @Override
    public void execute(LinkedBlockingDeque<String> queue) {
         receiver.receiver(queue);
    }
}

import java.util.concurrent.LinkedBlockingDeque;

public abstract class Receiver { 
      public abstract void receiver(LinkedBlockingDeque<String> queue); 
}

import java.util.concurrent.LinkedBlockingDeque;

public class ConcreteReceiverReader extends Receiver{
    @Override 
    public void receiver(LinkedBlockingDeque<String> queue) { 
        String str=null;
        while(true) {
            str=queue.poll();
            if("exit".equals(str)){
                   break;
             }
            System.out.println(str);
         } 
     }
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.concurrent.LinkedBlockingDeque;

public class ConcreteReceiverWriter extends Receiver{ 
    public LinkedBlockingDeque<String> queue=new LinkedBlockingDeque<String>();
    @Override
    public void receiver(LinkedBlockingDeque<String> queue) { 
        String str=null;
        BufferedReader reader=new BufferedReader(new InputStreamReader(System.in));
        try {
            while(true){    
                str=reader.readLine();
                queue.put(str); 
                //if input "exit" in Console, the Application exits.
                if("exit".equals(str)){ 
                    break;
                }        
            } 
            reader.close();
        } catch (IOException | InterruptedException e) {
                e.printStackTrace();
        }  
     } 
}

import java.util.concurrent.LinkedBlockingDeque;

public class Invoker {
    private Command command;
    //Receive command
    public void setCommand(Command command){
        this.command = command;
    }
    //Execute action
    public void action(LinkedBlockingDeque<String> queue){
        this.command.execute(queue);
    }
}

第5题 模仿js定义事件及回调的语法，实现node.js中事件的监听与事件的触发。

package eventListener;

public class Demo {
 public static void main(String[] args) {
  //创建事件的一个监听
        EventEmitter emitter = new EventEmitter();       
        emitter.addListener("some_event",new EventListener(){
            @Override
            public void handleEvent(EventObject event) { 
             System.out.println("some_event事件触发，调用此回调");          
            }
        });
        //触发事件“openWindows”
        emitter.emit(new EventObject("some_event"));
 }
}

package eventListener;
import java.util.Vector;

public class EventEmitter {
 //Define listener list 
    private Vector<EventListener> ListenerList = new Vector<EventListener>();
    //Add listener to this List
    public void addListener(String some_event, EventListener eventListener) {
 	 ListenerList.add(eventListener);
 }
   //receive event
    public void emit(EventObject event){        
        for(EventListener eventListener:ListenerList){
                eventListener.handleEvent(event);
        }
    }
}

package eventListener;

public interface  EventListener extends java.util.EventListener {
 //handleEvent
    public void handleEvent(EventObject event);
}

package eventListener;

public class EventObject extends java.util.EventObject{ 
     private static final long serialVersionUID = 1L;
     public EventObject(Object source){
         super(source);
     }     
}