Java tutorial
/* * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You under the Apache License, Version 2.0 * (the "License"); you may not use this file except in compliance with * the License. You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ /* $Id: FOPTestbed.java 1297404 2012-03-06 10:17:54Z vhennebert $ */ package org.apache.fop.threading; import java.io.File; import java.io.OutputStream; import java.text.DecimalFormat; import java.util.Collections; import java.util.Iterator; import java.util.List; import javax.xml.transform.Source; import javax.xml.transform.Templates; import javax.xml.transform.TransformerConfigurationException; import javax.xml.transform.TransformerFactory; import javax.xml.transform.stream.StreamSource; import org.apache.avalon.framework.CascadingRuntimeException; import org.apache.avalon.framework.activity.Executable; import org.apache.avalon.framework.activity.Initializable; import org.apache.avalon.framework.configuration.Configurable; import org.apache.avalon.framework.configuration.Configuration; import org.apache.avalon.framework.configuration.ConfigurationException; import org.apache.avalon.framework.container.ContainerUtil; import org.apache.avalon.framework.logger.AbstractLogEnabled; import org.apache.commons.io.IOUtils; import org.apache.commons.io.output.CountingOutputStream; import org.apache.commons.io.output.NullOutputStream; /** * Testbed for multi-threading tests. The class can run a configurable set of task a number of * times in a configurable number of threads to easily reproduce multi-threading issues. */ public class FOPTestbed extends AbstractLogEnabled implements Configurable, Initializable { private int repeat; private List taskList = new java.util.ArrayList(); private int threads; private File outputDir; private Configuration fopCfg; private Processor foprocessor; private boolean writeToDevNull; private int counter = 0; private List results = Collections.synchronizedList(new java.util.LinkedList()); /** {@inheritDoc} */ public void configure(Configuration configuration) throws ConfigurationException { this.threads = configuration.getChild("threads").getValueAsInteger(10); this.outputDir = new File(configuration.getChild("output-dir").getValue()); this.writeToDevNull = configuration.getChild("devnull").getValueAsBoolean(false); Configuration tasks = configuration.getChild("tasks"); this.repeat = tasks.getAttributeAsInteger("repeat", 1); Configuration[] entries = tasks.getChildren("task"); for (int i = 0; i < entries.length; i++) { this.taskList.add(new TaskDef(entries[i])); } this.fopCfg = configuration.getChild("processor"); } /** {@inheritDoc} */ public void initialize() throws Exception { this.foprocessor = createFOProcessor(); } /** * Starts the stress test. */ public void doStressTest() { getLogger().info("Starting stress test..."); long start = System.currentTimeMillis(); this.counter = 0; //Initialize threads ThreadGroup workerGroup = new ThreadGroup("FOP workers"); List threadList = new java.util.LinkedList(); for (int ti = 0; ti < this.threads; ti++) { TaskRunner runner = new TaskRunner(); ContainerUtil.enableLogging(runner, getLogger()); Thread thread = new Thread(workerGroup, runner, "Worker- " + ti); threadList.add(thread); } //Start threads Iterator i = threadList.iterator(); while (i.hasNext()) { ((Thread) i.next()).start(); } //Wait for threads to end while (threadList.size() > 0) { Thread t = (Thread) threadList.get(0); if (!t.isAlive()) { threadList.remove(0); continue; } try { Thread.sleep(100); } catch (InterruptedException ie) { //ignore } } long duration = System.currentTimeMillis() - start; report(duration); } private void report(long duration) { int count = this.results.size(); int failures = 0; long bytesWritten = 0; System.out.println("Report on " + count + " tasks:"); Iterator iter = this.results.iterator(); while (iter.hasNext()) { Result res = (Result) iter.next(); if (res.failure != null) { System.out.println("FAIL: " + (res.end - res.start) + " " + res.task); System.out.println(" -> " + res.failure.getMessage()); failures++; } else { System.out.println("good: " + (res.end - res.start) + " " + res.filesize + " " + res.task); bytesWritten += res.filesize; } } System.out.println("Stress test duration: " + duration + "ms"); if (failures > 0) { System.out.println(failures + " failures of " + count + " documents!!!"); } else { float mb = 1024f * 1024f; System.out.println("Bytes written: " + (bytesWritten / mb) + " MB, " + (bytesWritten * 1000 / duration) + " bytes / sec"); System.out.println("NO failures with " + count + " documents."); } } private class TaskRunner extends AbstractLogEnabled implements Runnable { public void run() { try { for (int r = 0; r < repeat; r++) { Iterator i = taskList.iterator(); while (i.hasNext()) { TaskDef def = (TaskDef) i.next(); final Task task = new Task(def, counter++, foprocessor); ContainerUtil.enableLogging(task, getLogger()); task.execute(); } } } catch (Exception e) { getLogger().error("Thread ended with an exception", e); } } } /** * Creates a new FOProcessor. * @return the newly created instance */ public Processor createFOProcessor() { try { Class clazz = Class .forName(this.fopCfg.getAttribute("class", "org.apache.fop.threading.FOProcessorImpl")); Processor fop = (Processor) clazz.newInstance(); ContainerUtil.enableLogging(fop, getLogger()); ContainerUtil.configure(fop, this.fopCfg); ContainerUtil.initialize(fop); return fop; } catch (Exception e) { throw new CascadingRuntimeException("Error creating FO Processor", e); } } private class TaskDef { private String fo; private String xml; private String xslt; private Templates templates; public TaskDef(String fo) { this.fo = fo; } public TaskDef(Configuration cfg) throws ConfigurationException { this.fo = cfg.getAttribute("fo", null); if (this.fo == null) { this.xml = cfg.getAttribute("xml"); this.xslt = cfg.getAttribute("xslt", null); if (this.xslt != null) { TransformerFactory factory = TransformerFactory.newInstance(); Source xsltSource = new StreamSource(new File(xslt)); try { this.templates = factory.newTemplates(xsltSource); } catch (TransformerConfigurationException tce) { throw new ConfigurationException("Invalid XSLT", tce); } } } } public String getFO() { return this.fo; } public String getXML() { return this.xml; } public Templates getTemplates() { return this.templates; } public String toString() { StringBuffer sb = new StringBuffer(); if (this.fo != null) { sb.append("fo="); sb.append(this.fo); } else { sb.append("xml="); sb.append(this.xml); sb.append(" xslt="); sb.append(this.xslt); } return sb.toString(); } } private class Task extends AbstractLogEnabled implements Executable { private TaskDef def; private int num; private Processor fop; public Task(TaskDef def, int num, Processor fop) { this.def = def; this.num = num; this.fop = fop; } public void execute() throws Exception { getLogger().info("Processing: " + def); long start = System.currentTimeMillis(); try { DecimalFormat df = new DecimalFormat("00000"); File outfile = new File(outputDir, df.format(num) + fop.getTargetFileExtension()); OutputStream out; if (writeToDevNull) { out = new NullOutputStream(); } else { out = new java.io.FileOutputStream(outfile); out = new java.io.BufferedOutputStream(out); } CountingOutputStream cout = new CountingOutputStream(out); try { Source src; Templates templates; if (def.getFO() != null) { src = new StreamSource(new File(def.getFO())); templates = null; } else { src = new StreamSource(new File(def.getXML())); templates = def.getTemplates(); } fop.process(src, templates, cout); } finally { IOUtils.closeQuietly(cout); } results.add(new Result(def, start, System.currentTimeMillis(), cout.getByteCount())); } catch (Exception e) { results.add(new Result(def, start, System.currentTimeMillis(), e)); throw e; } } } private static class Result { private TaskDef task; private long start; private long end; private long filesize; private Throwable failure; public Result(TaskDef task, long start, long end, long filesize) { this(task, start, end, null); this.filesize = filesize; } public Result(TaskDef task, long start, long end, Throwable failure) { this.task = task; this.start = start; this.end = end; this.failure = failure; } } }