Linkedin Interview Question for Software Engineer Interns


Country: United States
Interview Type: Phone Interview




Comment hidden because of low score. Click to expand.
3
of 3 vote

What do you think about using DelayQueue?

Please, look at the code below.

public class ClientServerTest {

    private DelayQueue<Job> queue = new DelayQueue<>();
    private Random rand = new Random(System.nanoTime());

    @Test
    public void testMultipleClientProcessTasks() {
	ExecutorService exec = Executors.newCachedThreadPool();
	for (int i = 0; i < 5; i++) {
	    exec.submit(new Runnable() {
		@Override
		public void run() {
		    Client client = new Client(queue);
		    client.addTask(new Runnable() {
			@Override
			public void run() {
			    try {
				TimeUnit.SECONDS.sleep(1);
			    } catch (InterruptedException e) {
				System.err.println(Thread.currentThread()
					.getId() + ": " + e.getMessage());
			    }
			    System.out.println(Thread.currentThread().getId());
			}
		    }, rand.nextInt(500), TimeUnit.MILLISECONDS);
		}

	    });
	}
	exec.submit(new Runnable() {
	    @Override
	    public void run() {
		Server server = new Server(queue);
		server.processTasks();
	    }
	});
	try {
	    TimeUnit.SECONDS.sleep(8);
	} catch (InterruptedException e) {
	}
	assertThat(queue.isEmpty(), is(true));
	exec.shutdownNow();
    }
}

public class Client {
    
    private DelayQueue<Job> queue;

    public Client(DelayQueue<Job> queue) {
	this.queue = queue;
    }

    public void addTask(Runnable job, long delay, TimeUnit timeUnit) {
	queue.put(new Job(job, delay, timeUnit));
    }

}

public class Server {
    
    private DelayQueue<Job> queue;

    public Server(DelayQueue<Job> queue) {
	this.queue = queue;
    }

    public void processTasks() {
	while(!Thread.interrupted()) {
	    try {
		queue.take().job().run();
	    } catch (InterruptedException e) {
		System.err.println(e.getMessage());
	    }
	}
    }

}

public class Job implements Delayed {
    
    private Runnable job;
    private TimeUnit timeUnit;
    private long delay;
    private long trigger;

    public Job(Runnable job, long delay, TimeUnit timeUnit) {
	this.job = job;
	this.delay = delay;
	this.timeUnit = timeUnit;
	this.trigger = System.nanoTime() + TimeUnit.NANOSECONDS.convert(delay, timeUnit);
    }

    @Override
    public int compareTo(Delayed o) {
	Job that = (Job)o;
	if (this.trigger - that.trigger < 0) {
	    return -1;
	} else if (this.trigger - that.trigger > 0) {
	    return 1;
	} else {
	    return 0;
	}
    }

    @Override
    public long getDelay(TimeUnit unit) {
	return unit.convert(trigger - System.nanoTime(), TimeUnit.NANOSECONDS);
    }

    public Runnable job() {
	return job;
    }
}

- Anton December 25, 2014 | Flag Reply
Comment hidden because of low score. Click to expand.
0
of 0 votes

Good solution.

- Killedsteel April 10, 2015 | Flag
Comment hidden because of low score. Click to expand.
0
of 0 vote

You are calling run() method in Server class. It doesn't make sense to me. It will act as a normal method instead of thread.

- Tushar Goel April 28, 2015 | Flag Reply
Comment hidden because of low score. Click to expand.
0
of 0 vote

{
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.Delayed;


public class DelayedThreadPool
{

    private List<DelayedThread> workers;
    
    private DelayedQueue delayedQueue;

    public DelayedThreadPool()
    {
        workers = new ArrayList<DelayedThread>();
        delayedQueue = new DelayedQueue();
        
        for( int i = 0; i < 10; i++ )
        {
            DelayedThread newThread = new DelayedThread(delayedQueue, String.valueOf( i ));
            workers.add( newThread );
            newThread.start();
        }
    }
    
    public void addTask(DelayedTask<Delayed> taskToExecute)
    {
        this.delayedQueue.addTask( taskToExecute );
    }
    
    public void stop()
    {
        for( DelayedThread delayedThread : workers )
        {
            delayedThread.close();
        }
    }
}

}

- Ramesh BG May 22, 2015 | Flag Reply
Comment hidden because of low score. Click to expand.
0
of 0 vote

{
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.Delayed;


public class DelayedThreadPool
{

    private List<DelayedThread> workers;
    
    private DelayedQueue delayedQueue;

    public DelayedThreadPool()
    {
        workers = new ArrayList<DelayedThread>();
        delayedQueue = new DelayedQueue();
        
        for( int i = 0; i < 10; i++ )
        {
            DelayedThread newThread = new DelayedThread(delayedQueue, String.valueOf( i ));
            workers.add( newThread );
            newThread.start();
        }
    }
    
    public void addTask(DelayedTask<Delayed> taskToExecute)
    {
        this.delayedQueue.addTask( taskToExecute );
    }
    
    public void stop()
    {
        for( DelayedThread delayedThread : workers )
        {
            delayedThread.close();
        }
    }
}

/**
 * 
 */

/**
 * @author r7b
 *
 */
public class DelayedThread extends Thread
{

    private DelayedQueue delayedQueue;
    
    private boolean isStopped;
    
    public DelayedThread( DelayedQueue delayedQueue, String string )
    {
        this.delayedQueue = delayedQueue;
        setName( string );
    }
    
    @Override
    public void run()
    {
       
        while(!isStopped)
        try
        {
            Runnable task = delayedQueue.getTask();
            if(task != null) {
                task.run();
            }
        }
        catch( InterruptedException e )
        {
            e.printStackTrace();
        }
    }
    
    public void close()
    {
        isStopped = true;
    }
}
import java.util.Collections;
import java.util.LinkedList;
import java.util.concurrent.Delayed;
import java.util.concurrent.TimeUnit;

/**
 * @author r7b
 */
public class DelayedQueue
{
    private LinkedList<DelayedTask<Delayed>> blockingQueue;

    public DelayedQueue()
    {
        this.blockingQueue = new LinkedList<DelayedTask<Delayed>>();
    }

    public void addTask( DelayedTask<Delayed> delayedTask )
    {
        this.blockingQueue.add( delayedTask );
    }

    public synchronized Runnable getTask() throws InterruptedException
    {
        /*
         * sort the taks and take the first task in the queue.
         */
        
        while( !this.blockingQueue.isEmpty() )
        {
            Collections.sort( this.blockingQueue );
            DelayedTask<Delayed> peekElement = this.blockingQueue.peek();
            long delay = peekElement.getDelay( TimeUnit.NANOSECONDS );
            if( delay == 0L || delay > 0L )
            {
                return this.blockingQueue.remove();
            }
            else
            {
                wait(10);
            }
        }
        return null;
    }
    @Override
    public String toString()
    {
        return this.blockingQueue.toString();
    }
}
import java.util.concurrent.Delayed;
import java.util.concurrent.TimeUnit;

/**
 * 
 */

/**
 * @author r7b
 */
public abstract class DelayedTask<E> implements Delayed, Runnable
{

    private long timeToExecute;

    public long getTimeToExecute()
    {
        return timeToExecute;
    }

    public DelayedTask( long timeToExecute )
    {
        this.timeToExecute = timeToExecute;
    }

    @Override
    public int compareTo( Delayed other )
    {
        if( this == other )
        {
            return 0;
        }
        if( getDelay( TimeUnit.NANOSECONDS ) < other.getDelay( TimeUnit.NANOSECONDS ) )
        {
            return 1;
        }
        else if( getDelay( TimeUnit.NANOSECONDS ) > other.getDelay( TimeUnit.NANOSECONDS ) )
        {
            return -1;
        }
        return 0;
    }

    @Override
    public long getDelay( TimeUnit unit )
    {
        long currentTimeMillis = System.currentTimeMillis();
        long timeRemaining = currentTimeMillis - this.timeToExecute;
        return timeRemaining;
    }
    
    @Override
    public String toString()
    {
        StringBuilder stringBuilder = new StringBuilder();
        stringBuilder.append( "[" ).append( "Time To Execute:" ).append( this.timeToExecute ).append( "]" );
        return stringBuilder.toString();
    }
}

}

- Ramesh BG May 22, 2015 | Flag Reply
Comment hidden because of low score. Click to expand.
0
of 0 votes

{
import java.util.concurrent.Delayed;


public class TestDelayedThreadPool
{

    /**
     * @param args
     */
    public static void main( String[] args )
    {
        DelayedThreadPool delayedThreadPool = new DelayedThreadPool();
        for( int i = 1; i <= 10; i++ )
        {
            delayedThreadPool.addTask( new DelayedTask<Delayed>(System.currentTimeMillis() + i*1000L)
                {
                    @Override
                    public void run()
                    {
                        System.out.println("==================START=========================="+"current thread name: " +Thread.currentThread().getName()+" hello world "+"Time to execute "+ this.getTimeToExecute()+" Current    Time "+System.currentTimeMillis()+"===================END==========================");
                    }
                } );
        }
    }
}

}

- rameshbg1987 May 22, 2015 | Flag
Comment hidden because of low score. Click to expand.
0
of 0 vote
{{{{ {{{{ import java.util.ArrayList; import java.util.List; import java.util.concurrent.Delayed; public class DelayedThreadPool { private List<DelayedThread> workers; private DelayedQueue delayedQueue; public DelayedThreadPool() { workers = new ArrayList<DelayedThread>(); delayedQueue = new DelayedQueue(); for( int i = 0; i < 10; i++ ) { DelayedThread newThread = new DelayedThread(delayedQueue, String.valueOf( i )); workers.add( newThread ); newThread.start(); } } public void addTask(DelayedTask<Delayed> taskToExecute) { this.delayedQueue.addTask( taskToExecute ); } public void stop() { for( DelayedThread delayedThread : workers ) { delayedThread.close(); } } } /** * */ /** * @author r7b * */ public class DelayedThread extends Thread { private DelayedQueue delayedQueue; private boolean isStopped; public DelayedThread( DelayedQueue delayedQueue, String string ) { this.delayedQueue = delayedQueue; setName( string ); } @Override public void run() { while(!isStopped) try { Runnable task = delayedQueue.getTask(); if(task != null) { task.run(); } } catch( InterruptedException e ) { e.printStackTrace(); } } public void close() { isStopped = true; } } import java.util.Collections; import java.util.LinkedList; import java.util.concurrent.Delayed; import java.util.concurrent.TimeUnit; /** * @author r7b */ public class DelayedQueue { private LinkedList<DelayedTask<Delayed>> blockingQueue; public DelayedQueue() { this.blockingQueue = new LinkedList<DelayedTask<Delayed>>(); } public void addTask( DelayedTask<Delayed> delayedTask ) { this.blockingQueue.add( delayedTask ); } public synchronized Runnable getTask() throws InterruptedException { /* * sort the taks and take the first task in the queue. */ while( !this.blockingQueue.isEmpty() ) { Collections.sort( this.blockingQueue ); DelayedTask<Delayed> peekElement = this.blockingQueue.peek(); long delay = peekElement.getDelay( TimeUnit.NANOSECONDS ); if( delay == 0L || delay > 0L ) { return this.blockingQueue.remove(); } else { wait(10); } } return null; } @Override public String toString() { return this.blockingQueue.toString(); } } import java.util.concurrent.Delayed; import java.util.concurrent.TimeUnit; /** * */ /** * @author r7b */ public abstract class DelayedTask<E> implements Delayed, Runnable { private long timeToExecute; public long getTimeToExecute() { return timeToExecute; } public DelayedTask( long timeToExecute ) { this.timeToExecute = timeToExecute; } @Override public int compareTo( Delayed other ) { if( this == other ) { return 0; } if( getDelay( TimeUnit.NANOSECONDS ) < other.getDelay( TimeUnit.NANOSECONDS ) ) { return 1; } else if( getDelay( TimeUnit.NANOSECONDS ) > other.getDelay( TimeUnit.NANOSECONDS ) ) { return -1; } return 0; } @Override public long getDelay( TimeUnit unit ) { long currentTimeMillis = System.currentTimeMillis(); long timeRemaining = currentTimeMillis - this.timeToExecute; return timeRemaining; } @Override public String toString() { StringBuilder stringBuilder = new StringBuilder(); stringBuilder.append( "[" ).append( "Time To Execute:" ).append( this.timeToExecute ).append( "]" ); return stringBuilder.toString(); } } }}}} - rameshbg1987 May 22, 2015 | Flag Reply
Comment hidden because of low score. Click to expand.
0
of 0 vote

Was this asked in a phone interview ?

- dan November 08, 2015 | Flag Reply


Add a Comment
Name:

Writing Code? Surround your code with {{{ and }}} to preserve whitespace.

Books

is a comprehensive book on getting a job at a top tech company, while focuses on dev interviews and does this for PMs.

Learn More

Videos

CareerCup's interview videos give you a real-life look at technical interviews. In these unscripted videos, watch how other candidates handle tough questions and how the interviewer thinks about their performance.

Learn More

Resume Review

Most engineers make critical mistakes on their resumes -- we can fix your resume with our custom resume review service. And, we use fellow engineers as our resume reviewers, so you can be sure that we "get" what you're saying.

Learn More

Mock Interviews

Our Mock Interviews will be conducted "in character" just like a real interview, and can focus on whatever topics you want. All our interviewers have worked for Microsoft, Google or Amazon, you know you'll get a true-to-life experience.

Learn More