1. Moving the calculation from onTick to onFeedData - calculate only when a feed element gets formed.
2. Calculate the indicators asynchronously and always work with the last available calculated values. Here you would need to be careful while doing historical testing as if the calculation completes in 2 seconds, the historical time might be already a couple of minutes ahead. See the example below.
3. Calculate indicators on array (note that OsMA is of unstable period - you would need to fetch extra 100 feed input prices),see: https://www.dukascopy.com/wiki/#Indicator_Calculation/Calculate_indicator_on_array

public class FeedOsmaAsync implements IStrategy, IFeedListener {

    @Configurable("")
    public IFeedDescriptor feedDescriptor = new RenkoFeedDescriptor(Instrument.EURUSD, PriceRange.valueOf(10), OfferSide.BID);

    private Object[][] optInputSets = new Object[][] { new Object[] { 12, 26, 5 }, new Object[] { 50, 110, 25 }, new Object[] { 290, 630, 120 } };
    private Map<Object[], Double> lastOsmas = new HashMap<Object[], Double>();
    private Set<ExecutorService> executors = new HashSet<ExecutorService>();

    //...
    
    /**
     * We calculate every indicator in its own thread
     * 
     * @throws JFException
     */
    private void scheduleOsmasCalculation() throws JFException {
        for (final Object[] optInputs : optInputSets) {
            ScheduledExecutorService exec = Executors.newSingleThreadScheduledExecutor();
            executors.add(exec);
            //every 100 millis we recalculate the last osma value in case a new tick has arrived
            exec.scheduleAtFixedRate(new Runnable() {
                
                ITick lastTick = null;
                
                @Override
                public void run() {                    
                    long start = System.nanoTime();
                    try {
                        ITick tick = history.getLastTick(feedDescriptor.getInstrument());
                        if(tick.equals(lastTick)){
                            return; //same tick
                        }
                        lastTick = tick;
                         Object[] osmaResult  = indicators.calculateIndicator(feedDescriptor, new OfferSide[] { feedDescriptor.getOfferSide() }, "OSMA",
                                new AppliedPrice[] { AppliedPrice.CLOSE }, optInputs, shift);
                        double osmalLast = (Double) osmaResult[0];
                        synchronized(lastOsmas){
                            lastOsmas.put(optInputs, osmalLast);
                        }
                        print("shift=%s last osma%s=%.5f in %.6f secs", shift, Arrays.toString(optInputs), osmalLast,
                                ((double) (System.nanoTime() - start)) / 1000000000);
                    } catch (JFException e) {
                        console.getErr().println(e);
                        e.printStackTrace();
                    }

                }
            }, 0, 100, TimeUnit.MILLISECONDS);
        }
    }
    //...
    @Override
    public void onStop() throws JFException {
        for(ExecutorService exec : executors){
            exec.shutdown();
        }
    }
}