【ASK】200分，问几个比较深的问题。谢谢

Question

1，tomcat可不可以提供并行的服务,就是说两台机子上的tomcat同时为一个用户的请求进行响应,协同工作？？2，集群中有多台服务器，一台服务器挂了，其他服务器为用户提供服务，我想问下，这个用户的会话如何维持的？
   比如说，在A用户 在a机器登录，结果在b机器上处理一比交易，那另外一台机器如何知道用户的信息 是刚才在A用户登录的
  session呢？？3，3 片汉诺塔的移法？

Answer 1

1：可以；
2：记得好像有个这种可以集群 的session;
3:不懂……

Answer 2

问题2：可以把用户信息记录在数据库中，然后不同的群集调用同一个数据库，去查询用户信息，再创建到SESSION里面

Answer 3

一个也不懂  ~~~~(>_<)~~~~ 

Answer 4

1.不懂
2.tomcat集群的话，跟apache结合起来可以用session复制
3.各种递归程序
多的跟啥一样

Answer 5

第二个问题。负载均衡，Tomcat是能够实现的。session可以复制传递到其他的tomcat中。

Answer 6

著名的汉诺塔问题：
import javax.swing.JOptionPane;
public class TowersOfHanoi {
public static void main(String args[]) {
String intString = JOptionPane.showInputDialog("Enter number of disks:");
int n = Integer.parseInt(intString);
System.out.println("The moves are:");
moveDisks(n, 'A', 'B', 'C');
}
public static void moveDisks(int n, char fromTower, char toTower, char auxTower) {
if (n == 1)
System.out.println("Move disk " + n +" from " + fromTower + " to " + toTower);
else {
moveDisks(n-1, fromTower, auxTower, toTower);
System.out.println("Move disk " + n +" from " + fromTower + " to " + toTower);
moveDisks(n-1, auxTower, toTower, fromTower);
}
}
} 

Answer 7

你的意思 2台电脑 之间 通信， 但是 这有代价的， 可能需要jms 消息机制，如果 不只2台服务器，则 遍历的 服务器就很多了，当然 不过 几时 几百台 而已， 我面试 时是这么说的，面试官说 是否有 其他方案

Answer 8

1.可以
2.看其他帖子的回复
3.public class HanoiY    
{    
        
    void Move(char chSour,char chDest){    
        System.out.println("Move the top plate of "+chSour+"-->"+chDest);    
    }    
   
    void Hanoi(int n,char chA,char chB,char chC)    
    {    
        if(n==1)    
            Move(chA,chC);    
        else   
        {    
            Hanoi(n-1,chA,chC,chB);    
            this.Move(chA,chC);    
            Hanoi(n-1,chB,chA,chC);    
        }    
    }    
   
    public static void main(String[] args)    
    {    
        int n=Integer.parseInt(args[0]);    
        HanoiY han=new HanoiY();    
        han.Hanoi(n,'A','B','C');    
    }    
}   

Answer 9

1.一个请求只能由一台服务器来响应。
2.建立共享session,例如把所有用户session统一使用一台或者多台缓存服务器来管理,缓存服务器之间通信同步。
3.经典问题，google一下吧，只移动3片的话，自己想下就出来了。

Answer 10

汉诺塔动态演示程序：
/**
 *本程序完成的功能是利用汉递规算法实现汉诺塔的动态演示程序
 */
import javax.swing.*;
import java.awt.geom.*;
import java.awt.event.*;
import java.awt.*;
public class Hanoi extends JApplet implements ActionListener, Runnable
{
 /**
  *diskNum是盘子的数量
  */
 private int diskNum ;
 /**
  *各个组件的句柄
  */
 private JButton begin, stop;
 private JLabel lDiskNum;
 private JTextField text;
 JPanel pane;
 /**
  *定义一个线程句柄
  */
 private Thread animate;
 /**
  *定义a,b,c三个柱子上是否有盘子，有哪些盘子
  */
 private int adisk[];
 private int bdisk[];
 private int cdisk[];
 public void init()
 {
  
  Container content = getContentPane();
  content.setLayout(new BorderLayout());
  lDiskNum = new JLabel("盘子的数目");
  
  text = new JTextField(8);
  
  begin = new JButton("开始");
  begin.addActionListener(this);
  
  stop = new JButton("停止");
  stop.addActionListener(this);
  
  pane = new JPanel();
  pane.setLayout(new FlowLayout());
  pane.add(lDiskNum);
  pane.add(text);
  pane.add(begin);
  pane.add(stop);
  content.add(pane, BorderLayout.SOUTH);
  
 }
 public void paint(Graphics g)
 {
  Graphics2D g2D = (Graphics2D)g;
  Ellipse2D.Double ellipse;
  g2D.setPaint(getBackground());
  if(adisk != null)
  {
   /**
    *消除以前画的盘子
    */
   for(int j=adisk.length, i=0; --j>=0; i++ )
   {
    ellipse = new Ellipse2D.Double(20+i*5, 180-i*10, 180-i*10, 20);
    g2D.fill(ellipse);
    ellipse = new Ellipse2D.Double(220+i*5, 180-i*10, 180-i*10, 20);
    g2D.fill(ellipse);
    ellipse = new Ellipse2D.Double(420+i*5, 180-i*10, 180-i*10, 20);
    g2D.fill(ellipse);
   
   }
   drawEllipse(g, 20, adisk);//画A组盘子
   drawEllipse(g, 220, bdisk);//画B组盘子
   drawEllipse(g, 420, cdisk);//画C组盘子
   
  }
  pane.repaint(); 
 }
 public void update(Graphics g)
 {
  paint(g);
 }
 /**画出椭圆代表盘子，g是图形环境，x是最下面的盘子的横坐标，
  *arr是柱子数组
  */
 public void drawEllipse(Graphics g,int x,int arr[])
 {
  Graphics2D g2D = (Graphics2D)g;
  Ellipse2D.Double ellipse;
  g2D.setPaint(Color.gray);
  g2D.draw(new Line2D.Double(x+90, 10, x+90, 180));
  for(int j=arr.length, i=0; --j>=0; i++ )
   if(arr[j] != 0)
   {
    if(i%2 == 0)
     g2D.setPaint(Color.blue);
    else
     g2D.setPaint(Color.red);
    ellipse = new Ellipse2D.Double(x+i*5, 180-i*10, 180-i*10, 20);
    g2D.fill(ellipse);
   }
 }
 public void actionPerformed(ActionEvent e)
 {
  String command = e.getActionCommand();
  if(command.equals("开始"))
  {
   /**
    *进行初始化，开始的时候只有a柱子上有盘子，其他柱子都没有
    */
   diskNum = Integer.parseInt(text.getText());
   
   adisk = new int[diskNum];
   for(int i=0; i<adisk.length; i++)
    adisk[i] = 1;
   bdisk = new int[diskNum];
   for(int k=0; k<bdisk.length; k++)
    bdisk[k] = 0;
   cdisk = new int[diskNum];
   for(int i=0; i<cdisk.length; i++)
    cdisk[i] = 0;
   repaint();
   if(animate == null || !animate.isAlive())//创建一个线程
   {
    animate = new Thread(this);
    animate.start();
   }
  }
  if(command.equals("停止"))
  {
   for(int k=0; k<bdisk.length; k++)
    bdisk[k] = 0;
   for(int i=0; i<cdisk.length; i++)
    cdisk[i] = 0;
   repaint();
   text.getText();
   animate = null;
  }
 }
 /**
  *线程方法，在此调用汉诺塔执行移动盘子操作
  */
 public void run()
 {
  hanio(diskNum, 'A', 'B', 'C');
  repaint();
 }
 /**
  *汉诺塔递规调用程序，n是盘子的数量，A，B，C分别代表三个柱子
  */
 public  void hanio(int n, char A, char B, char C)
 {
  if(n > 1)
  {
   hanio(n-1, A, C, B);
   pause();//停顿几秒在执行
   switch(A)
   {
    case 'A':adisk[n-1] = 0;break;
    case 'B':bdisk[n-1] = 0;break;
    case 'C':cdisk[n-1] = 0;break;
    default:break;
   }
   switch(C)
   {
    case 'A':adisk[n-1] = 1;break;
    case 'B':bdisk[n-1] = 1;break;
    case 'C':cdisk[n-1] = 1;break;
    default:break;
   }
   repaint();
   hanio(n-1, B, A, C);
  }
  pause();
     switch(A)
  {
   case 'A':adisk[n-1] = 0;break;
   case 'B':bdisk[n-1] = 0;break;
   case 'C':cdisk[n-1] = 0;break;
   default:break;
  }
  switch(C)
  {
   case 'A':adisk[n-1] = 1;break;
   case 'B':bdisk[n-1] = 1;break;
   case 'C':cdisk[n-1] = 1;break;
   default:break;
  }
  repaint();
  
 } 
 /**
  *每隔半妙钟移动一个盘子
  */
 public void pause()
 {
  try{
   Thread.sleep(500);//可以修改此值加快盘子移动的速度
  }catch(InterruptedException e){}
 }
} 没优化，可以用

Answer 11

别的方法，我还不知道。
如果不用多个Tomcat进行负载均衡。
那可以使用代理方式。
就是说，多创建几个代理服务器进行数据的缓存。
首先，根据用户的线路IP，将请求转向到不同的代理服务器。（可以解决电信、联通互访速度慢的问题）
其次，代理服务器（创建大量的缓存），查看资源是否过时，如果不过时就响应用户请求，
      如果过时则去真正的Web容器上获取资源。资源也可以分别存放到不同的服务器上。
      代理服务器也可以有定时刷新策略。
最后，这种方案，只适用大型网站的建设，中小型网站，一般没有那么高的访问量。可以进行性能调优。

Answer 12

import java.util.Stack;public class HanoiImpl {
public static int count = 0;
public static Stack<Character> A, B, C;
public static void main(String[] args) {
A = new Stack<Character>();
B = new Stack<Character>();
C = new Stack<Character>();

A.push('C');
A.push('B');
A.push('A');

playHanoi(A.size(), A, B, C);
}

/**
 * 
 * @param n HanoiNum
 * @param A StartHanoi
 * @param B MediaHanoi
 * @param C DestinationHanoi
 */
public static void playHanoi(int n, Stack<Character> A, Stack<Character> B, Stack<Character> C) {
if(1 <= n) {
if(1 < n) playHanoi(n-1 , A, C, B);

System.out.print(A +"\t" + B + "\t" + C);
C.push(A.pop());
System.out.println("------->" + A + "\t" + B + "\t" + C);

if(1 < n) playHanoi(n-1, B, A, C);
}
}
}
/*
[C, B, A] [] []------->[C, B] [] [A]
[C, B] [A] []------->[C] [A] [B]
[A] [C] [B]------->[] [C] [B, A]
[C] [B, A] []------->[] [B, A] [C]
[B, A] [C] []------->[B] [C] [A]
[B] [A] [C]------->[] [A] [C, B]
[A] [] [C, B]------->[] [] [C, B, A]
*/大二时C老师就给演示过了，当时好想自己写一个，O(∩_∩)O哈哈~
上面的输出时递归输出地，所以中间的打印顺序并不代表A,B,C三柱的顺序，用数组可能好些~

Answer 13

Session 复制是服务器集群最为重要的课题。Tomcat 可以通过配置实现自动的 Session 复制。Session 复制底层实现很复杂，而且要求很高，因为 Session 数据必须广播给其他集群中的子节点，如果底层设计得不好，很严重影响集群的性能。对于这一点来说，开源的服务器是没法和商业服务器相比的。可以采用 Web 服务器的反向代理，使用访问者的 IP 地址进行 hash 处理，也就是说同一个 IP 地址访问肯定是被分发到同一个后端服务器上，这样可以省去 Session 复制。但是如果某台机器挂了，用户请求会被分发到其他机器上，那在这台机器上所有的 Session 信息将会丢失，如果 Session 中只是存储着用户登录信息，那这批用户也就是最多再登录一次。一般来说在 Session 中除了登录信息之外，不要再存放其他数据，这样如果进行 Session 复制速度将会大大提高。

Answer 14

1，tomcat可不可以提供并行的服务,就是说两台机子上的tomcat同时为一个用户的请求进行响应,协同工作？？不能，一个请求只能由一个 tomcat 处理。当然了，后端的业务逻辑可以分散在不同的机器上，这种称为分布式应用，需要进行组件级的开发，比如 EJB 什么的。

Answer 15

1. tomcat能提供并发动作, 但是建议使用webservice, 提供各个模块之间的对话2. 是通过负载均衡实现的3. 没有研究过!

Answer 16

集群故障恢复中的会话复制,一般在企业级应用服务器里常见;
比如WebSphere,不过实际上要做到无缝过渡,开销相当大,不值得!

Answer 17

1、可以；
2、共同使用session时，session是由A复制B，两台机器session可以保持一致；

Answer 18

第一个问题：
我觉得是可以的，用ajax，分别发送两个请求到不同的tomcat,把得到的结果合并了再展现在页面上。
第二个问题：
比如用tomcat的集群，一旦配置好以后，session问题集群服务器可以自动管理吧，当然集群中没有掉线的服务器中都应该有已登录用户的session?
第三个问题：不明白。