如何在云平台虚拟机上运行Java计算密集型任务

作者：佚名 2012-10-23 09:30:18

通过Windows Azure，你可以使用一个虚拟机来处理计算密集型任务，本文将带你了解如何创建一个可运行计算密集型的Java应用程序，并可以被另一个Java应用程序所监视的虚拟机。你将学到如何远程登录到你的虚拟机、如何在你的虚拟机上安装一个JRE或JDK、如何创建一个服务总线命名空间等方法。

通过Windows Azure，你可以使用一个虚拟机来处理计算密集型任务，例如，一个虚拟机可以处理任务，并交付结果给客户机或移动应用程序。本文将让你了解如何创建一个可运行计算密集型的Java应用程序，并可以被另一个Java应用程序所监视的虚拟机。

本教程假定你知道如何创建Java控制台应用程序、导入库到你的Java应用程序及生成一个Java存档(JAR)。假设没有Windows Azure的相关知识。

你将学到：

如何创建一个虚拟机

如何远程登录到你的虚拟机

如何在你的虚拟机上安装一个JRE或JDK

如何创建一个服务总线命名空间

如何创建一个执行计算密集型任务的Java应用程序

如何创建一个监视计算密集型任务进展情况的Java应用程序

如何运行Java应用程序

如何停止Java应用程序

本教程将使用Traveling Salesman Problem作为计算密集型任务。下面是在Java应用程序中运行计算密集型任务的例子：

以下是一个Java应用程序监控计算密集型任务的例子：

注意

要完成本教程，你需要一个已启用 Windows Azure 虚拟机功能的 Windows Azure 帐户。你可以创建一个免费的试用帐号，在短短的几分钟内启用预览功能。#p#

创建一个虚拟机

1. 登录Windows Azure预览管理入口。

2. 单击新建按钮。

3. 单击“虚拟机”。

4. 单击快速创建。

5. 在创建虚拟机界面，为DNS 名称输入一个值。

6. 在图片下拉列表中，选择一个图像，如Windows Server 2008 R2 SP1。

7. 在“新密码”框中输入密码，并在确认框中重新输入密码。请记住这个密码，你将使用它来远程登录虚拟机。

8. 从位置下拉列表中，为你的虚拟机选择数据中心位置。例如美国西部。

9. 单击“创建虚拟机”，你的虚拟机将被创建。你可以通过管理网站上的虚拟机部分来监视状态。

远程登录你的虚拟机

1. 登录预览管理入口网站。

2. 单击“虚拟机”。

3. 单击要登录的虚拟机名称。

4. 单击“连接”。

5. 当系统提示输入密码时，请使用你创建虚拟机时设置的密码。

在虚拟机上安装一个JRE或JDK

在你的虚拟机上运行Java应用程序，你需要安装一个Java Runtime Environment(JRE)。为了本教程，我们将安装一个Java开发工具包(JDK)到你的虚拟机，并且使用JDK的JRE。当然，你也可以选择只安装JRE。

在本教程中，将从Oracle网站安装一个JDK。

1. 登录到虚拟机上。

2. 在你的浏览器中打开http://www.oracle.com/technetwork/java/javase/downloads/index.html。

3. 点击下载按钮来下载你想要的JDK。在本教程中使用Java SE 6更新32 JDK的下载按钮。

4. 接受许可协议。

5. 点击下载适用于Windows x64(64位)的可执行文件。

6. 按照提，并根据自身需要把JDK安装到你的虚拟机中。

需要注意的是，服务总线功能要求GTE CyberTrust Global Root证书作为你JRE的cacerts 存储的一部分进行安装。此证书会自动包含在本教程中所用的 JRE。如果您的 JRE cacerts 存储区中没有此证书，它可以从https://secure.omniroot.com/cacert/ct_root.der上复制证书内容进行安装，内容为一个.cer文件，并通过密钥工具将其添加到cacerts 存储。#p#

如何创建一个服务总线命名空间

要在Windows Azure开始使用服务总线队列，您必须首先创建一个服务命名空间。一个服务命名空间提供了一个范围容器处理你的应用程序中的服务总线资源。

创建一个服务命名空间：

1. 登录Windows Azure管理入口(这与Windows Azure预览管理入口不同)。

2. 在左侧的导航栏中，单击服务总线、访问控制和缓存。

3. 单击服务总线按钮，然后单击新建按钮。

4. 在创建一个新的服务命名空间的对话框中，输入一个名称空间，然后以确保它是唯一的，点击检查可用性按钮。

5. 在确保名称空间的名字是可用的之后，选择你的命名空间被托管的国家或地区，但后单击创建命名空间按钮。

你创建的命名空间，将出现在管理入口，需要一段时间来激活。等到被激活时，然后再进行下一个步骤。

获取默认的命名空间的管理凭据

为了执行管理操作，比如在心的命名空间创建一个队列，你需要获得命名空间的管理凭据。

1. 在左侧的导航栏中，单击服务总线按钮，以显示列表中可用的命名空间：

2. 从显示的列表中选择刚刚创建的命名空间：

3. 右侧会列出新的命名空间的属性：

4. 默认密钥是隐藏的。点击查看按钮以显示安全证书：

5. 记下默认的发行者和默认密钥，你将使用该信息对命名空间执行操作。#p#

如何创建一个执行计算密集型任务的Java应用程序

1. 在你的开发机器(并不一定是你所创建的虚拟机)上，为Java下载Windows Azure SDK。

2. 在本小节的末尾创建一个Java控制台应用程序使用的示例代码。在本教程中，我们将使用TSPSolver.java作为java文件的名字。修改your_service_bus_namespace、 your_service_bus_owner、以及 your_service_bus_key 等占位符，分别使用您的服务总线命名空间、默认发行人和默认密钥值。

3. 编码后，导出应用程序到一个可运行的Java归档(JAR)，并把所需的库到打包已生成的JAR。在本教程中，我们将使用TSPSolver.jar作为生成的JAR名称。

// TSPSolver.java
import com.microsoft.windowsazure.services.core.Configuration;
import com.microsoft.windowsazure.services.core.ServiceException;
import com.microsoft.windowsazure.services.serviceBus.*;
import com.microsoft.windowsazure.services.serviceBus.models.*;
import java.io.*;
import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
public class TSPSolver {
// Value specifying how often to provide an update to the console.
private static long loopCheck = 100000000;
private static long nTimes = 0, nLoops=0;
private static double[][] distances;
private static String[] cityNames;
private static int[] bestOrder;
private static double minDistance;
private static ServiceBusContract service;
private static void buildDistances(String fileLocation, int numCities) throws Exception{
try{
BufferedReader file = new BufferedReader(new InputStreamReader(new DataInputStream(new FileInputStream(new File(fileLocation)))));
double[][] cityLocs = new double[numCities][2];
for (int i = 0; i<numCities; i++){
String[] line = file.readLine().split(", ");
cityNames[i] = line[0];
cityLocs[i][0] = Double.parseDouble(line[1]);
cityLocs[i][1] = Double.parseDouble(line[2]);
}
for (int i = 0; i<numCities; i++){
for (int j = i; j<numCities; j++){
distances[i][j] = Math.hypot(Math.abs(cityLocs[i][0] - cityLocs[j][0]), Math.abs(cityLocs[i][1] - cityLocs[j][1]));
distances[j][i] = distances[i][j];
}
}
} catch (Exception e){
throw e;
}
}
private static void permutation(List<Integer> startCities, double distSoFar, List<Integer> restCities) throws Exception {
try
{
nTimes++;
if (nTimes == loopCheck)
{
nLoops++;
nTimes = 0;
DateFormat dateFormat = new SimpleDateFormat("MM/dd/yyyy HH:mm:ss");
Date date = new Date();
System.out.print("Current time is " + dateFormat.format(date) + ". ");
System.out.println( "Completed " + nLoops + " iterations of size of " + loopCheck + ".");
}
if ((restCities.size() == 1) && ((minDistance == -1) || (distSoFar + distances[restCities.get(0)][startCities.get(0)] + distances[restCities.get(0)][startCities.get(startCities.size()-1)] < minDistance))){
startCities.add(restCities.get(0));
newBestDistance(startCities, distSoFar + distances[restCities.get(0)][startCities.get(0)] + distances[restCities.get(0)][startCities.get(startCities.size()-2)]);
startCities.remove(startCities.size()-1);
}
else{
for (int i=0; i<restCities.size(); i++){
startCities.add(restCities.get(0));
restCities.remove(0);
permutation(startCities, distSoFar + distances[startCities.get(startCities.size()-1)][startCities.get(startCities.size()-2)],restCities);
restCities.add(startCities.get(startCities.size()-1));
startCities.remove(startCities.size()-1);
}
}
}
catch (Exception e)
{
throw e;
}
}
private static void newBestDistance(List<Integer> cities, double distance) throws ServiceException, Exception {
try
{
minDistance = distance;
String cityList = "Shortest distance is "+minDistance+", with route: ";
for (int i = 0; i<bestOrder.length; i++){
bestOrder[i] = cities.get(i);
cityList += cityNames[bestOrder[i]];
if (i != bestOrder.length -1)
cityList += ", ";
}
System.out.println(cityList);
service.sendQueueMessage("TSPQueue", new BrokeredMessage(cityList));
}
catch (ServiceException se)
{
throw se;
}
catch (Exception e)
{
throw e;
}
}
public static void main(String args[]){
try {
Configuration config = ServiceBusConfiguration.configureWithWrapAuthentication(
"your_service_bus_namespace", "your_service_bus_owner", "your_service_bus_key");
service = ServiceBusService.create(config);
int numCities = 10; // Use as the default, if no value is specified at command line.
if (args.length != 0)
{
if (args[0].toLowerCase().compareTo("createqueue")==0)
{
// No processing to occur other than creating the queue.
QueueInfo queueInfo = new QueueInfo("TSPQueue");
service.createQueue(queueInfo);
System.out.println("Queue named TSPQueue was created.");
System.exit(0);
}
if (args[0].toLowerCase().compareTo("deletequeue")==0)
{
// No processing to occur other than deleting the queue.
service.deleteQueue("TSPQueue");
System.out.println("Queue named TSPQueue was deleted.");
System.exit(0);
}
// Neither creating or deleting a queue.
// Assume the value passed in is the number of cities to solve.
numCities = Integer.valueOf(args[0]);
}
System.out.println("Running for " + numCities + " cities.");
List<Integer> startCities = new ArrayList<Integer>();
List<Integer> restCities = new ArrayList<Integer>();
startCities.add(0);
for(int i = 1; i<numCities; i++)
restCities.add(i);
distances = new double[numCities][numCities];
cityNames = new String[numCities];
buildDistances("c:\\TSP\\cities.txt", numCities);
minDistance = -1;
bestOrder = new int[numCities];
permutation(startCities, 0, restCities);
System.out.println("Final solution found!");
service.sendQueueMessage("TSPQueue", new BrokeredMessage("Complete"));
}
catch (ServiceException se)
{
System.out.println(se.getMessage());
se.printStackTrace();
System.exit(-1);
}
catch (Exception e)
{
System.out.println(e.getMessage());
e.printStackTrace();
System.exit(-1);
}
}
}

#p#

如何创建一个监视计算密集型任务进展情况的Java应用程序

1. 在你的开发机器上，创建一个Java控制台应用程序，使用的示例代码在本小节的末尾。在本教程中，我们将使用TSPClient.java作为Java文件名。和之前一样，分别使用你的服务总线命名空间、默认发行人和默认密钥值，修改your_service_bus_namespace、 your_service_bus_owner、以及 your_service_bus_key 等占位符。

2. 导出应用程序到一个可执行的JAR，并打包所需的库到生成的JAR。在本教程中，我们将使用TSPClient.jar生成的JAR名。

// TSPClient.java
import java.util.Date;
import java.text.DateFormat;
import java.text.SimpleDateFormat;
import com.microsoft.windowsazure.services.serviceBus.*;
import com.microsoft.windowsazure.services.serviceBus.models.*;
import com.microsoft.windowsazure.services.core.*;
public class TSPClient
{
public static void main(String[] args)
{
try
{
DateFormat dateFormat = new SimpleDateFormat("MM/dd/yyyy HH:mm:ss");
Date date = new Date();
System.out.println("Starting at " + dateFormat.format(date) + ".");
String namespace = "your_service_bus_namespace";
String issuer = "your_service_bus_owner";
String key = "your_service_bus_key";
Configuration config;
config = ServiceBusConfiguration.configureWithWrapAuthentication(
namespace, issuer, key);
ServiceBusContract service = ServiceBusService.create(config);
BrokeredMessage message;
int waitMinutes = 3; // Use as the default, if no value is specified at command line.
if (args.length != 0)
{
waitMinutes = Integer.valueOf(args[0]);
}
String waitString;
waitString = (waitMinutes == 1) ? "minute." : waitMinutes + " minutes.";
// This queue must have previously been created.
service.getQueue("TSPQueue");
int numRead;
String s = null;
while (true)
{
ReceiveQueueMessageResult resultQM = service.receiveQueueMessage("TSPQueue");
message = resultQM.getValue();
if (null != message && null != message.getMessageId())
{
// Display the queue message.
byte[] b = new byte[200];
System.out.print("From queue: ");
s = null;
numRead = message.getBody().read(b);
while (-1 != numRead)
{
s = new String(b);
ss = s.trim();
System.out.print(s);
numRead = message.getBody().read(b);
}
System.out.println();
if (s.compareTo("Complete") == 0)
{
// No more processing to occur.
date = new Date();
System.out.println("Finished at " + dateFormat.format(date) + ".");
break;
}
}
else
{
// The queue is empty.
System.out.println("Queue is empty. Sleeping for another " + waitString);
Thread.sleep(60000 * waitMinutes);
}
}
}
catch (ServiceException se)
{
System.out.println(se.getMessage());
se.printStackTrace();
System.exit(-1);
}
catch (Exception e)
{
System.out.println(e.getMessage());
e.printStackTrace();
System.exit(-1);
}
}
} #p#

如何运行Java应用程序

运行计算密集型应用程序，首先要创建队列，然后解决Traveling Saleseman Problem，它会将当前的最佳路径添加到服务总线队列。当计算密集型应用程序正在运行(或运行后)，运行客户端，从服务总线的队列显示结果。

如何运行计算密集型应用程序

1. 登陆到虚拟机上。

2. 创建一个你将在其中运行应用程序的文件夹。例如：c:\TSP。

3. 复制TSPSolver.jar到c:\TSP.

4. 创建一个包含以下内容的名为c:\TSP\cities.txt的文档：

City_1, 1002.81, -1841.35
City_2, -953.55, -229.6
City_3, -1363.11, -1027.72
City_4, -1884.47, -1616.16
City_5, 1603.08, -1030.03
City_6, -1555.58, 218.58
City_7, 578.8, -12.87
City_8, 1350.76, 77.79
City_9, 293.36, -1820.01
City_10, 1883.14, 1637.28
City_11, -1271.41, -1670.5
City_12, 1475.99, 225.35
City_13, 1250.78, 379.98
City_14, 1305.77, 569.75
City_15, 230.77, 231.58
City_16, -822.63, -544.68
City_17, -817.54, -81.92
City_18, 303.99, -1823.43
City_19, 239.95, 1007.91
City_20, -1302.92, 150.39
City_21, -116.11, 1933.01
City_22, 382.64, 835.09
City_23, -580.28, 1040.04
City_24, 205.55, -264.23
City_25, -238.81, -576.48
City_26, -1722.9, -909.65
City_27, 445.22, 1427.28
City_28, 513.17, 1828.72
City_29, 1750.68, -1668.1
City_30, 1705.09, -309.35
City_31, -167.34, 1003.76
City_32, -1162.85, -1674.33
City_33, 1490.32, 821.04
City_34, 1208.32, 1523.3
City_35, 18.04, 1857.11
City_36, 1852.46, 1647.75
City_37, -167.44, -336.39
City_38, 115.4, 0.2
City_39, -66.96, 917.73
City_40, 915.96, 474.1
City_41, 140.03, 725.22
City_42, -1582.68, 1608.88
City_43, -567.51, 1253.83
City_44, 1956.36, 830.92
City_45, -233.38, 909.93
City_46, -1750.45, 1940.76
City_47, 405.81, 421.84
City_48, 363.68, 768.21
City_49, -120.3, -463.13
City_50, 588.51, 679.33

1. 在命令提示符下，将目录更改到c:\TSP。

2. 确保JRE的bin文件夹在PATH环境变量中。

3. 在你运行运行TSP求解排列之前，你需要创建服务总线队列。运行下面的命令来创建服务总线队列：

java -jar TSPSolver.jar createqueue

现在，创建队列，你可以运行TSP求解排列。 #p#

如何运行客户端监控应用程序

1. 登录到你将运行客户端应用程序的计算机。该计算机并不一定是运行TSPSolver应用程序的同一台机器，虽然它也可以。

2. 创建一个你将在其中运行应用程序的文件夹。例如：c:\TSP。

3. 复制TSPClient.jar到c:\TSP。

4. 确保JRE的bin文件夹在PATH环境变量中。

5. 在命令提示符下，将目录更改到c:\TSP。

6. 运行下面的命令：

java -jar TSPClient.jar

(可选)通过在命令行中的参数指定检查队列之间的睡眠分钟数。默认检查队列的睡眠周期是3分钟，如果你想为睡眠时间间隔使用不同的值，例如一分钟，运行以下命令：

java -jar TSPClient.jar 1

客户端将一直运行，直到它看到一个“完整”的队列消息。注意，如果你没有在运行客户端的情况下运行多个事件的求解器，你可能需要多次运行客户端来完全清空队列。或者，你可以删除队列，然后再重新创建。删除队列，请运行以下TSPSolver(不是TSPClient)命令：

java -jar TSPSolver.jar deletequeue

求解器将运行，直到它检查完所有路线。

如何停止Java应用程序

对于求解器和客户端应用程序，如果你想在正常完成前结束，你可以按Ctrl+ C组合键退出。

责任编辑：王程程来源： DZone

计算应用虚拟机 Java 云平台