1 /* 2 * Copyright (c) 2009-2010 jMonkeyEngine 3 * All rights reserved. 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions are 7 * met: 8 * 9 * * Redistributions of source code must retain the above copyright 10 * notice, this list of conditions and the following disclaimer. 11 * 12 * * Redistributions in binary form must reproduce the above copyright 13 * notice, this list of conditions and the following disclaimer in the 14 * documentation and/or other materials provided with the distribution. 15 * 16 * * Neither the name of 'jMonkeyEngine' nor the names of its contributors 17 * may be used to endorse or promote products derived from this software 18 * without specific prior written permission. 19 * 20 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 21 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 22 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 23 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR 24 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, 25 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, 26 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR 27 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF 28 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING 29 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS 30 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 31 */ 32 33 package com.jme3.asset; 34 35 import java.util.concurrent.Callable; 36 import java.util.concurrent.ExecutorService; 37 import java.util.concurrent.Executors; 38 import java.util.concurrent.ThreadFactory; 39 40 /** 41 * <code>ThreadingManager</code> manages the threads used to load content 42 * within the Content Manager system. A pool of threads and a task queue 43 * is used to load resource data and perform I/O while the application's 44 * render thread is active. 45 */ 46 public class ThreadingManager { 47 48 protected final ExecutorService executor = 49 Executors.newFixedThreadPool(2, 50 new LoadingThreadFactory()); 51 52 protected final AssetManager owner; 53 54 protected int nextThreadId = 0; 55 ThreadingManager(AssetManager owner)56 public ThreadingManager(AssetManager owner){ 57 this.owner = owner; 58 } 59 60 protected class LoadingThreadFactory implements ThreadFactory { newThread(Runnable r)61 public Thread newThread(Runnable r) { 62 Thread t = new Thread(r, "pool" + (nextThreadId++)); 63 t.setDaemon(true); 64 t.setPriority(Thread.MIN_PRIORITY); 65 return t; 66 } 67 } 68 69 protected class LoadingTask implements Callable<Object> { 70 private final String resourceName; LoadingTask(String resourceName)71 public LoadingTask(String resourceName){ 72 this.resourceName = resourceName; 73 } call()74 public Object call() throws Exception { 75 return owner.loadAsset(new AssetKey(resourceName)); 76 } 77 } 78 79 // protected class MultiLoadingTask implements Callable<Void> { 80 // private final String[] resourceNames; 81 // public MultiLoadingTask(String[] resourceNames){ 82 // this.resourceNames = resourceNames; 83 // } 84 // public Void call(){ 85 // owner.loadContents(resourceNames); 86 // return null; 87 // } 88 // } 89 90 // public Future<Void> loadContents(String ... names){ 91 // return executor.submit(new MultiLoadingTask(names)); 92 // } 93 94 // public Future<Object> loadContent(String name) { 95 // return executor.submit(new LoadingTask(name)); 96 // } 97 isLoadingThread()98 public static boolean isLoadingThread() { 99 return Thread.currentThread().getName().startsWith("pool"); 100 } 101 102 103 } 104