23 posts tagged with "Java"

public class Lock {

	private boolean isLocked = false;

	public synchronized void lock() throws InterruptedException {
		while (isLocked) {
			wait();
		}
		isLocked = true;
	}

	public synchronized void unlock() {
		isLocked = false;
		notify();
	}
}

lock.lock();
try {
  // ... method body
} finally {
  lock.unlock();
}

public class Singleton {
	private static volatile Singleton _instance; // volatile variable
	private Singleton(){} //private constructor

	public static Singleton getInstance() {
		if (_instance == null) {
			synchronized (Singleton.class) {
				if (_instance == null)
					_instance = new Singleton();
			}
		}
		return _instance;
	}
}

import java.util.concurrent.CyclicBarrier;

public class CyclicBarrierExample {

	public static void main(String[] args) {
		CyclicBarrier barrier = new CyclicBarrier(3, new BarrierAction());

		new Thread(new Party(barrier)).start();
		new Thread(new Party(barrier)).start();
		new Thread(new Party(barrier)).start();

		try {
			// sleep to avoid BrokenBarrierException
			Thread.sleep(1000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}

		System.out.println("\nReset the barrier....\n");
		// reset the barrier
		barrier.reset();

		new Thread(new Party(barrier)).start();
		new Thread(new Party(barrier)).start();
		new Thread(new Party(barrier)).start();
	}

}

public class BarrierAction implements Runnable {

	@Override
	public void run() {
		System.out.println("Barrier Action Executes !!!");
	}

}

import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;

public class Party implements Runnable {
	CyclicBarrier barrier;

	public Party(CyclicBarrier barrier) {
		this.barrier = barrier;
	}

	@Override
	public void run() {
		try {
			System.out.println(Thread.currentThread().getName() + " waiting at barrier.");
			this.barrier.await();
		} catch (InterruptedException | BrokenBarrierException e) {
			e.printStackTrace();
		}
	}

}

import java.util.concurrent.Semaphore;

public class SemaphoreExample {

	public static void main(String[] args) {
		Semaphore semaphore = new Semaphore(2);

		new Thread(new Task(semaphore)).start();
		new Thread(new Task(semaphore)).start();
		new Thread(new Task(semaphore)).start();
		new Thread(new Task(semaphore)).start();
	}

}

class Task implements Runnable {

	Semaphore semaphore;

	public Task(Semaphore semaphore) {
		this.semaphore = semaphore;
	}

	@Override
	public void run() {
		try {
			semaphore.acquire();
			System.out.println(Thread.currentThread().getName() + " acquired");

			Thread.sleep(2000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		} finally {
			semaphore.release();
			System.out.println(Thread.currentThread().getName() + " released");
		}
	}
}

import java.util.concurrent.LinkedBlockingQueue;

public class ThreadPool
{
	volatile boolean isRunning;
	private LinkedBlockingQueue<Runnable> blockingQueue;
	private WorkerThread[] workerThreads;

	public ThreadPool(int poolSize)
	{
		blockingQueue = new LinkedBlockingQueue<>(4);
		workerThreads = new WorkerThread[poolSize];

		// create worker threads
		for (int i = 0; i < poolSize; i++)
		{
			workerThreads[i] = new WorkerThread(i + "", blockingQueue);
		}

		// start all threads
		for (WorkerThread workerThread : workerThreads)
		{
			workerThread.start();
		}
	}

	public void execute(Runnable task)
	{
		synchronized (blockingQueue)
		{

			while (blockingQueue.size() == 4)
			{
				try
				{
					blockingQueue.wait();
				} catch (InterruptedException e)
				{
					System.out.println("An error occurred while queue is waiting: " + e.getMessage());
				}
			}

			blockingQueue.add(task);

			// notify all worker threads waiting for new task
			blockingQueue.notifyAll();
		}
	}
}

import java.util.concurrent.LinkedBlockingQueue;

public class WorkerThread extends Thread
{
	private LinkedBlockingQueue<Runnable> queue;

	public WorkerThread(String name, LinkedBlockingQueue<Runnable> queue)
	{
		super(name);
		this.queue = queue;
	}

	@Override
	public void run()
	{

		while (true)
		{
			synchronized (queue)
			{
				while (queue.isEmpty())
				{
					try
					{
						queue.wait();
					} catch (InterruptedException e)
					{
						System.out.println("An error occurred while queue is waiting: " + e.getMessage());
					}
				}

				try
				{
					Runnable runnable = this.queue.poll();
					System.out.println(
							"worker " + Thread.currentThread().getName() + " executing thread " + runnable.toString());
					runnable.run();
					Thread.sleep(1000);

					// notify threads waiting to put task in queue
					queue.notifyAll();
				} catch (InterruptedException e)
				{
					e.printStackTrace();
				}
			}
		}
	}

}

public class ThreadPoolTester
{

	public static void main(String[] args)
	{
		ThreadPool pool = new ThreadPool(2);

		for (int i = 0; i < 10; i++)
		{
			pool.execute(new Task(i + ""));
		}
	}

}

class Task implements Runnable
{
	String name;

	public Task(String name)
	{
		this.name = name;
	}

	@Override
	public void run()
	{
		System.out.println("Task " + this.name + " is running");
	}

	@Override
	public String toString()
	{
		return this.name;
	}
}

/**
 * Custom CoundDownLach implementation
 * @author sandeep
 *
 */
public class CustomCountDownLatch
{
	int counter;

	public CustomCountDownLatch(int counter)
	{
		this.counter = counter;
	}

	public synchronized void await() throws InterruptedException
	{
		if (counter > 0)
		{
			wait();
		}
	}

	/**
	 * method will decrement the counter by 1 each time
	 */
	public synchronized void countDown()
	{
		counter--;
		if (counter == 0)
		{
			notifyAll();
		}
	}
}

package com;  

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface NotNullAndNotEmpty {

}

package com;
import java.lang.reflect.Field;
import java.util.ArrayList;
import java.util.List;

public class NotNullAndNotEmptyValidator {
  public static List<String> validate(Object obj) {
    List<String> errors = new ArrayList<String>();

    NotNullAndNotEmpty annotations = (NotNullAndNotEmpty) obj.getClass().getAnnotation(NotNullAndNotEmpty.class);

    // if annotation not found on class then return empty list
    if (annotations != null) {

      Field[] fields = obj.getClass().getDeclaredFields();
      for (Field field : fields) {
        field.setAccessible(true);
        try {
          if (field.get(obj) == null) {
            errors.add(field.getName() + " is null or empty");
          }
        } catch (Exception e) {
          e.printStackTrace();
        }
      }
    }
    return errors;
  }
}  

package com;

@NotNullAndNotEmpty
public class Employee {
  private String name;
  private String address;

  public Employee() {

  }

  public Employee(String name, String address) {
    super();
    this.name = name;
    this.address = address;
  }

  public String getName() {
    return name;
  }

  public void setName(String name) {
    this.name = name;
  }

  public String getAddress() {
    return address;
  }

  public void setAddress(String address) {
    this.address = address;
  }

}

package com;

import java.util.List;

public class Test {

  public static void main(String[] args) {
    Employee emp = new Employee("Sandeep", null);

    List<String> errors = NotNullAndNotEmptyValidator.validate(emp);

    for (String error : errors) {
      System.out.println(error);
    }

  }
}

address is null or empty